diff options
651 files changed, 16261 insertions, 5782 deletions
diff --git a/.gitignore b/.gitignore index 6c34e37f4cb6..3d07e81baf38 100644 --- a/.gitignore +++ b/.gitignore @@ -16,7 +16,7 @@ # Byte compiled python modules. *.pyc # vim swap files -.*.swp +.*.sw? .sw? #==============================================================================# diff --git a/CMakeLists.txt b/CMakeLists.txt index 357286b0e6ae..ab70f1dab61f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -320,6 +320,17 @@ function(clang_tablegen) endif() endfunction(clang_tablegen) +macro(set_clang_windows_version_resource_properties name) + if(DEFINED windows_resource_file) + set_windows_version_resource_properties(${name} ${windows_resource_file} + VERSION_MAJOR ${CLANG_VERSION_MAJOR} + VERSION_MINOR ${CLANG_VERSION_MINOR} + VERSION_PATCHLEVEL ${CLANG_VERSION_PATCHLEVEL} + VERSION_STRING "${CLANG_VERSION} (${BACKEND_PACKAGE_STRING})" + PRODUCT_NAME "clang") + endif() +endmacro() + macro(add_clang_library name) cmake_parse_arguments(ARG "" @@ -377,11 +388,13 @@ macro(add_clang_library name) endif() set_target_properties(${name} PROPERTIES FOLDER "Clang libraries") + set_clang_windows_version_resource_properties(${name}) endmacro(add_clang_library) macro(add_clang_executable name) add_llvm_executable( ${name} ${ARGN} ) set_target_properties(${name} PROPERTIES FOLDER "Clang executables") + set_clang_windows_version_resource_properties(${name}) endmacro(add_clang_executable) set(CMAKE_INCLUDE_CURRENT_DIR ON) diff --git a/docs/ClangFormatStyleOptions.rst b/docs/ClangFormatStyleOptions.rst index c06a8c76ecd5..f4c4c8cc9a21 100644 --- a/docs/ClangFormatStyleOptions.rst +++ b/docs/ClangFormatStyleOptions.rst @@ -155,23 +155,21 @@ the configuration (without a prefix: ``Auto``). This applies to round brackets (parentheses), angle brackets and square brackets. This will result in formattings like - - .. code-block:: c++ - - someLongFunction(argument1, - argument2); + \code + someLongFunction(argument1, + argument2); + \endcode **AlignConsecutiveAssignments** (``bool``) If ``true``, aligns consecutive assignments. This will align the assignment operators of consecutive lines. This will result in formattings like - - .. code-block:: c++ - - int aaaa = 12; - int b = 23; - int ccc = 23; + \code + int aaaa = 12; + int b = 23; + int ccc = 23; + \endcode **AlignEscapedNewlinesLeft** (``bool``) If ``true``, aligns escaped newlines as far left as possible. @@ -204,10 +202,10 @@ the configuration (without a prefix: ``Auto``). * ``SFS_None`` (in configuration: ``None``) Never merge functions into a single line. - * ``SFS_Inline`` (in configuration: ``Inline``) - Only merge functions defined inside a class. * ``SFS_Empty`` (in configuration: ``Empty``) Only merge empty functions. + * ``SFS_Inline`` (in configuration: ``Inline``) + Only merge functions defined inside a class. Implies "empty". * ``SFS_All`` (in configuration: ``All``) Merge all functions fitting on a single line. @@ -230,6 +228,11 @@ the configuration (without a prefix: ``Auto``). **AlwaysBreakBeforeMultilineStrings** (``bool``) If ``true``, always break before multiline string literals. + This flag is mean to make cases where there are multiple multiline strings + in a file look more consistent. Thus, it will only take effect if wrapping + the string at that point leads to it being indented + ``ContinuationIndentWidth`` spaces from the start of the line. + **AlwaysBreakTemplateDeclarations** (``bool``) If ``true``, always break after the ``template<...>`` of a template declaration. @@ -343,11 +346,10 @@ the configuration (without a prefix: ``Auto``). instead of as function calls. These are expected to be macros of the form: - - .. code-block:: c++ - - FOREACH(<variable-declaration>, ...) - <loop-body> + \code + FOREACH(<variable-declaration>, ...) + <loop-body> + \endcode For example: BOOST_FOREACH. diff --git a/docs/ControlFlowIntegrity.rst b/docs/ControlFlowIntegrity.rst index 915385b7b197..ce1c37bcd408 100644 --- a/docs/ControlFlowIntegrity.rst +++ b/docs/ControlFlowIntegrity.rst @@ -20,8 +20,8 @@ program's control flow. These schemes have been optimized for performance, allowing developers to enable them in release builds. To enable Clang's available CFI schemes, use the flag ``-fsanitize=cfi``. -As currently implemented, CFI relies on link-time optimization (LTO); the CFI -schemes imply ``-flto``, and the linker used must support LTO, for example +As currently implemented, CFI relies on link-time optimization (LTO); so it is +required to specify ``-flto``, and the linker used must support LTO, for example via the `gold plugin`_. To allow the checks to be implemented efficiently, the program must be structured such that certain object files are compiled with CFI enabled, and are statically linked into the program. This may diff --git a/docs/LanguageExtensions.rst b/docs/LanguageExtensions.rst index bd5992e3d6e5..0b4775ba6ad4 100644 --- a/docs/LanguageExtensions.rst +++ b/docs/LanguageExtensions.rst @@ -1845,6 +1845,9 @@ with :doc:`ThreadSanitizer`. Use ``__has_feature(memory_sanitizer)`` to check if the code is being built with :doc:`MemorySanitizer`. +Use ``__has_feature(safe_stack)`` to check if the code is being built +with :doc:`SafeStack`. + Extensions for selectively disabling optimization ================================================= diff --git a/docs/Modules.rst b/docs/Modules.rst index 9999106914f6..1f3d89897513 100644 --- a/docs/Modules.rst +++ b/docs/Modules.rst @@ -159,7 +159,7 @@ Module maps are specified as separate files (each named ``module.modulemap``) al To actually see any benefits from modules, one first has to introduce module maps for the underlying C standard library and the libraries and headers on which it depends. The section `Modularizing a Platform`_ describes the steps one must take to write these module maps. -One can use module maps without modules to check the integrity of the use of header files. To do this, use the ``-fmodule-maps`` option instead of the ``-fmodules`` option. +One can use module maps without modules to check the integrity of the use of header files. To do this, use the ``-fimplicit-module-maps`` option instead of the ``-fmodules`` option, or use ``-fmodule-map-file=`` option to explicitly specify the module map files to load. Compilation model ----------------- @@ -174,8 +174,8 @@ Command-line parameters ``-fmodules`` Enable the modules feature. -``-fmodule-maps`` - Enable interpretation of module maps. This option is implied by ``-fmodules``. +``-fimplicit-module-maps`` + Enable implicit search for module map files named ``module.modulemap`` and similar. This option is implied by ``-fmodules``. If this is disabled with ``-fno-implicit-module-maps``, module map files will only be loaded if they are explicitly specified via ``-fmodule-map-file`` or transitively used by another module map file. ``-fmodules-cache-path=<directory>`` Specify the path to the modules cache. If not provided, Clang will select a system-appropriate default. @@ -207,9 +207,6 @@ Command-line parameters ``-fmodules-search-all`` If a symbol is not found, search modules referenced in the current module maps but not imported for symbols, so the error message can reference the module by name. Note that if the global module index has not been built before, this might take some time as it needs to build all the modules. Note that this option doesn't apply in module builds, to avoid the recursion. -``-fno-modules-implicit-maps`` - Suppresses the implicit search for files called ``module.modulemap`` and similar. Instead, module files need to be explicitly specified via ``-fmodule-map-file`` or transitively used. - ``-fno-implicit-modules`` All modules used by the build must be specified with ``-fmodule-file``. @@ -682,7 +679,7 @@ A *link-declaration* with the ``framework`` specifies that the linker should lin Configuration macros declaration ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -The *config-macros-declaration* specifies the set of configuration macros that have an effect on the the API of the enclosing module. +The *config-macros-declaration* specifies the set of configuration macros that have an effect on the API of the enclosing module. .. parsed-literal:: diff --git a/docs/SafeStack.rst b/docs/SafeStack.rst new file mode 100644 index 000000000000..5115d959954e --- /dev/null +++ b/docs/SafeStack.rst @@ -0,0 +1,163 @@ +========= +SafeStack +========= + +.. contents:: + :local: + +Introduction +============ + +SafeStack is an instrumentation pass that protects programs against attacks +based on stack buffer overflows, without introducing any measurable performance +overhead. It works by separating the program stack into two distinct regions: +the safe stack and the unsafe stack. The safe stack stores return addresses, +register spills, and local variables that are always accessed in a safe way, +while the unsafe stack stores everything else. This separation ensures that +buffer overflows on the unsafe stack cannot be used to overwrite anything +on the safe stack, which includes return addresses. + +Performance +----------- + +The performance overhead of the SafeStack instrumentation is less than 0.1% on +average across a variety of benchmarks (see the `Code-Pointer Integrity +<http://dslab.epfl.ch/pubs/cpi.pdf>`_ paper for details). This is mainly +because most small functions do not have any variables that require the unsafe +stack and, hence, do not need unsafe stack frames to be created. The cost of +creating unsafe stack frames for large functions is amortized by the cost of +executing the function. + +In some cases, SafeStack actually improves the performance. Objects that end up +being moved to the unsafe stack are usually large arrays or variables that are +used through multiple stack frames. Moving such objects away from the safe +stack increases the locality of frequently accessed values on the stack, such +as register spills, return addresses, and small local variables. + +Limitations +----------- + +SafeStack has not been subjected to a comprehensive security review, and there +exist known weaknesses, including but not limited to the following. + +In its current state, the separation of local variables provides protection +against stack buffer overflows, but the safe stack itself is not protected +from being corrupted through a pointer dereference. The Code-Pointer +Integrity paper describes two ways in which we may protect the safe stack: +hardware segmentation on the 32-bit x86 architecture or information hiding +on other architectures. + +Even with information hiding, the safe stack would merely be hidden +from attackers by being somewhere in the address space. Depending on the +application, the address could be predictable even on 64-bit address spaces +because not all the bits are addressable, multiple threads each have their +stack, the application could leak the safe stack address to memory via +``__builtin_frame_address``, bugs in the low-level runtime support etc. +Safe stack leaks could be mitigated by writing and deploying a static binary +analysis or a dynamic binary instrumentation based tool to find leaks. + +This approach doesn't prevent an attacker from "imbalancing" the safe +stack by say having just one call, and doing two rets (thereby returning +to an address that wasn't meant as a return address). This can be at least +partially mitigated by deploying SafeStack alongside a forward control-flow +integrity mechanism to ensure that calls are made using the correct calling +convention. Clang does not currently implement a comprehensive forward +control-flow integrity protection scheme; there exists one that protects +:doc:`virtual calls <ControlFlowIntegrity>` but not non-virtual indirect calls. + +Compatibility +------------- + +Most programs, static libraries, or individual files can be compiled +with SafeStack as is. SafeStack requires basic runtime support, which, on most +platforms, is implemented as a compiler-rt library that is automatically linked +in when the program is compiled with SafeStack. + +Linking a DSO with SafeStack is not currently supported. + +Known compatibility limitations +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Certain code that relies on low-level stack manipulations requires adaption to +work with SafeStack. One example is mark-and-sweep garbage collection +implementations for C/C++ (e.g., Oilpan in chromium/blink), which must be +changed to look for the live pointers on both safe and unsafe stacks. + +SafeStack supports linking together modules that are compiled with and without +SafeStack, both statically and dynamically. One corner case that is not +supported is using ``dlopen()`` to load a dynamic library that uses SafeStack into +a program that is not compiled with SafeStack but uses threads. + +Signal handlers that use ``sigaltstack()`` must not use the unsafe stack (see +``__attribute__((no_sanitize("safe-stack")))`` below). + +Programs that use APIs from ``ucontext.h`` are not supported yet. + +Usage +===== + +To enable SafeStack, just pass ``-fsanitize=safe-stack`` flag to both compile and link +command lines. + +Supported Platforms +------------------- + +SafeStack was tested on Linux, FreeBSD and MacOSX. + +Low-level API +------------- + +``__has_feature(safe_stack)`` +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +In some rare cases one may need to execute different code depending on +whether SafeStack is enabled. The macro ``__has_feature(safe_stack)`` can +be used for this purpose. + +.. code-block:: c + + #if __has_feature(safe_stack) + // code that builds only under SafeStack + #endif + +``__attribute__((no_sanitize("safe-stack")))`` +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Use ``__attribute__((no_sanitize("safe-stack")))`` on a function declaration +to specify that the safe stack instrumentation should not be applied to that +function, even if enabled globally (see ``-fsanitize=safe-stack`` flag). This +attribute may be required for functions that make assumptions about the +exact layout of their stack frames. + +Care should be taken when using this attribute. The return address is not +protected against stack buffer overflows, and it is easier to leak the +address of the safe stack to memory by taking the address of a local variable. + + +``__builtin___get_unsafe_stack_ptr()`` +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +This builtin function returns current unsafe stack pointer of the current +thread. + +``__builtin___get_unsafe_stack_start()`` +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +This builtin function returns a pointer to the start of the unsafe stack of the +current thread. + +Design +====== + +Please refer to +`http://dslab.epfl.ch/proj/cpi/ <http://dslab.epfl.ch/proj/cpi/>`_ for more +information about the design of the SafeStack and its related technologies. + + +Publications +------------ + +`Code-Pointer Integrity <http://dslab.epfl.ch/pubs/cpi.pdf>`_. +Volodymyr Kuznetsov, Laszlo Szekeres, Mathias Payer, George Candea, R. Sekar, Dawn Song. +USENIX Symposium on Operating Systems Design and Implementation +(`OSDI <https://www.usenix.org/conference/osdi14>`_), Broomfield, CO, October 2014 diff --git a/docs/UsersManual.rst b/docs/UsersManual.rst index 2ddf0822dd6e..cd1b2b3c341d 100644 --- a/docs/UsersManual.rst +++ b/docs/UsersManual.rst @@ -970,16 +970,15 @@ are listed below. includes all of the checks listed below other than ``unsigned-integer-overflow``. - - ``-fsanitize=undefined-trap``: This includes all sanitizers - included by ``-fsanitize=undefined``, except those that require - runtime support. This group of sanitizers is intended to be - used in conjunction with the ``-fsanitize-undefined-trap-on-error`` - flag. This includes all of the checks listed below other than - ``unsigned-integer-overflow`` and ``vptr``. + - ``-fsanitize=undefined-trap``: This is a deprecated alias for + ``-fsanitize=undefined``. + - ``-fsanitize=dataflow``: :doc:`DataFlowSanitizer`, a general data flow analysis. - ``-fsanitize=cfi``: :doc:`control flow integrity <ControlFlowIntegrity>` - checks. Implies ``-flto``. + checks. Requires ``-flto``. + - ``-fsanitize=safe-stack``: :doc:`safe stack <SafeStack>` + protection against stack-based memory corruption errors. The following more fine-grained checks are also available: @@ -992,13 +991,13 @@ are listed below. - ``-fsanitize=cfi-cast-strict``: Enables :ref:`strict cast checks <cfi-strictness>`. - ``-fsanitize=cfi-derived-cast``: Base-to-derived cast to the wrong - dynamic type. Implies ``-flto``. + dynamic type. Requires ``-flto``. - ``-fsanitize=cfi-unrelated-cast``: Cast from ``void*`` or another - unrelated type to the wrong dynamic type. Implies ``-flto``. + unrelated type to the wrong dynamic type. Requires ``-flto``. - ``-fsanitize=cfi-nvcall``: Non-virtual call via an object whose vptr is of - the wrong dynamic type. Implies ``-flto``. + the wrong dynamic type. Requires ``-flto``. - ``-fsanitize=cfi-vcall``: Virtual call via an object whose vptr is of the - wrong dynamic type. Implies ``-flto``. + wrong dynamic type. Requires ``-flto``. - ``-fsanitize=enum``: Load of a value of an enumerated type which is not in the range of representable values for that enumerated type. @@ -1067,15 +1066,6 @@ are listed below. through. This mode may use extra memory in programs that copy uninitialized memory a lot. - Extra features of UndefinedBehaviorSanitizer: - - - ``-fsanitize-undefined-trap-on-error``: Causes traps to be emitted - rather than calls to runtime libraries when a problem is detected. - This option is intended for use in cases where the sanitizer runtime - cannot be used (for instance, when building libc or a kernel module). - This is only compatible with the sanitizers in the ``undefined-trap`` - group. - The ``-fsanitize=`` argument must also be provided when linking, in order to link to the appropriate runtime library. When using ``-fsanitize=vptr`` (or a group that includes it, such as @@ -1099,11 +1089,41 @@ are listed below. sanitizers (e.g. :doc:`AddressSanitizer`) may not support recovery, and always crash the program after the issue is detected. + Note that the ``-fsanitize-trap`` flag has precedence over this flag. + This means that if a check has been configured to trap elsewhere on the + command line, or if the check traps by default, this flag will not have + any effect unless that sanitizer's trapping behavior is disabled with + ``-fno-sanitize-trap``. + + For example, if a command line contains the flags ``-fsanitize=undefined + -fsanitize-trap=undefined``, the flag ``-fsanitize-recover=alignment`` + will have no effect on its own; it will need to be accompanied by + ``-fno-sanitize-trap=alignment``. + +**-f[no-]sanitize-trap=check1,check2,...** + + Controls which checks enabled by the ``-fsanitize=`` flag trap. This + option is intended for use in cases where the sanitizer runtime cannot + be used (for instance, when building libc or a kernel module), or where + the binary size increase caused by the sanitizer runtime is a concern. + + This flag is only compatible with ``local-bounds``, + ``unsigned-integer-overflow``, sanitizers in the ``cfi`` group and + sanitizers in the ``undefined`` group other than ``vptr``. If this flag + is supplied together with ``-fsanitize=undefined``, the ``vptr`` sanitizer + will be implicitly disabled. + + This flag is enabled by default for sanitizers in the ``cfi`` group. + **-f[no-]sanitize-coverage=[type,features,...]** Enable simple code coverage in addition to certain sanitizers. See :doc:`SanitizerCoverage` for more details. +.. option:: -fsanitize-undefined-trap-on-error + + Deprecated alias for ``-fsanitize-trap=undefined``. + .. option:: -fno-assume-sane-operator-new Don't assume that the C++'s new operator is sane. diff --git a/docs/index.rst b/docs/index.rst index a3c8ffb8dc69..dec2bc828c1c 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -29,6 +29,7 @@ Using Clang as a Compiler SanitizerCoverage SanitizerSpecialCaseList ControlFlowIntegrity + SafeStack Modules MSVCCompatibility FAQ diff --git a/docs/tools/clang.pod b/docs/tools/clang.pod index f7d2eaf683cb..153f97b2caa0 100644 --- a/docs/tools/clang.pod +++ b/docs/tools/clang.pod @@ -39,12 +39,12 @@ the other tools. This stage handles tokenization of the input source file, macro expansion, #include expansion and handling of other preprocessor directives. The output of this stage is typically called a ".i" (for C), ".ii" (for C++), ".mi" (for -Objective-C) , or ".mii" (for Objective-C++) file. +Objective-C), or ".mii" (for Objective-C++) file. =item B<Parsing and Semantic Analysis> This stage parses the input file, translating preprocessor tokens into a parse -tree. Once in the form of a parser tree, it applies semantic analysis to compute +tree. Once in the form of a parse tree, it applies semantic analysis to compute types for expressions as well and determine whether the code is well formed. This stage is responsible for generating most of the compiler warnings as well as parse errors. The output of this stage is an "Abstract Syntax Tree" (AST). @@ -330,13 +330,13 @@ all by the program. =item B<-fexceptions> -Enable generation of unwind information, this allows exceptions to be thrown +Enable generation of unwind information. This allows exceptions to be thrown through Clang compiled stack frames. This is on by default in x86-64. =item B<-ftrapv> Generate code to catch integer overflow errors. Signed integer overflow is -undefined in C, with this flag, extra code is generated to detect this and abort +undefined in C. With this flag, extra code is generated to detect this and abort when it happens. @@ -389,7 +389,7 @@ Display available options. =item B<-Qunused-arguments> -Don't emit warning for unused driver arguments. +Do not emit any warnings for unused driver arguments. =item B<-Wa,>I<args> @@ -578,7 +578,7 @@ write temporary files used during the compilation process. If this environment variable is present, it is treated as a delimited list of paths to be added to the default system include path list. The -delimiter is the platform dependent delimitor, as used in the I<PATH> +delimiter is the platform dependent delimiter, as used in the I<PATH> environment variable. Empty components in the environment variable are ignored. @@ -592,7 +592,7 @@ which are only used when processing the appropriate language. =item B<MACOSX_DEPLOYMENT_TARGET> If -mmacosx-version-min is unspecified, the default deployment target -is read from this environment variable. This option only affects darwin +is read from this environment variable. This option only affects Darwin targets. =back diff --git a/include/clang-c/Index.h b/include/clang-c/Index.h index 3276afc4b960..a2241802078e 100644 --- a/include/clang-c/Index.h +++ b/include/clang-c/Index.h @@ -2225,7 +2225,12 @@ enum CXCursorKind { */ CXCursor_OMPTeamsDirective = 253, - CXCursor_LastStmt = CXCursor_OMPTeamsDirective, + /** \brief OpenMP taskwait directive. + */ + CXCursor_OMPTaskgroupDirective = 254, + + + CXCursor_LastStmt = CXCursor_OMPTaskgroupDirective, /** * \brief Cursor that represents the translation unit itself. @@ -5628,7 +5633,7 @@ typedef enum { * reused after indexing is finished. Set to \c NULL if you do not require it. * * \returns 0 on success or if there were errors from which the compiler could - * recover. If there is a failure from which the there is no recovery, returns + * recover. If there is a failure from which there is no recovery, returns * a non-zero \c CXErrorCode. * * The rest of the parameters are the same as #clang_parseTranslationUnit. @@ -5659,7 +5664,7 @@ CINDEX_LINKAGE int clang_indexSourceFile(CXIndexAction, * * The parameters are the same as #clang_indexSourceFile. * - * \returns If there is a failure from which the there is no recovery, returns + * \returns If there is a failure from which there is no recovery, returns * non-zero, otherwise returns 0. */ CINDEX_LINKAGE int clang_indexTranslationUnit(CXIndexAction, diff --git a/include/clang/ARCMigrate/ARCMT.h b/include/clang/ARCMigrate/ARCMT.h index ad4f23c604b3..74081867eebc 100644 --- a/include/clang/ARCMigrate/ARCMT.h +++ b/include/clang/ARCMigrate/ARCMT.h @@ -17,6 +17,7 @@ namespace clang { class ASTContext; class DiagnosticConsumer; + class PCHContainerOperations; namespace arcmt { class MigrationPass; @@ -37,19 +38,22 @@ namespace arcmt { /// the pre-migration ARC diagnostics. /// /// \returns false if no error is produced, true otherwise. -bool checkForManualIssues(CompilerInvocation &CI, - const FrontendInputFile &Input, - DiagnosticConsumer *DiagClient, - bool emitPremigrationARCErrors = false, - StringRef plistOut = StringRef()); +bool +checkForManualIssues(CompilerInvocation &CI, const FrontendInputFile &Input, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + DiagnosticConsumer *DiagClient, + bool emitPremigrationARCErrors = false, + StringRef plistOut = StringRef()); /// \brief Works similar to checkForManualIssues but instead of checking, it /// applies automatic modifications to source files to conform to ARC. /// /// \returns false if no error is produced, true otherwise. -bool applyTransformations(CompilerInvocation &origCI, - const FrontendInputFile &Input, - DiagnosticConsumer *DiagClient); +bool +applyTransformations(CompilerInvocation &origCI, + const FrontendInputFile &Input, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + DiagnosticConsumer *DiagClient); /// \brief Applies automatic modifications and produces temporary files /// and metadata into the \p outputDir path. @@ -62,12 +66,11 @@ bool applyTransformations(CompilerInvocation &origCI, /// the pre-migration ARC diagnostics. /// /// \returns false if no error is produced, true otherwise. -bool migrateWithTemporaryFiles(CompilerInvocation &origCI, - const FrontendInputFile &Input, - DiagnosticConsumer *DiagClient, - StringRef outputDir, - bool emitPremigrationARCErrors, - StringRef plistOut); +bool migrateWithTemporaryFiles( + CompilerInvocation &origCI, const FrontendInputFile &Input, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + DiagnosticConsumer *DiagClient, StringRef outputDir, + bool emitPremigrationARCErrors, StringRef plistOut); /// \brief Get the set of file remappings from the \p outputDir path that /// migrateWithTemporaryFiles produced. @@ -93,13 +96,16 @@ std::vector<TransformFn> getAllTransformations(LangOptions::GCMode OrigGCMode, class MigrationProcess { CompilerInvocation OrigCI; + std::shared_ptr<PCHContainerOperations> PCHContainerOps; DiagnosticConsumer *DiagClient; FileRemapper Remapper; public: bool HadARCErrors; - MigrationProcess(const CompilerInvocation &CI, DiagnosticConsumer *diagClient, + MigrationProcess(const CompilerInvocation &CI, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + DiagnosticConsumer *diagClient, StringRef outputDir = StringRef()); class RewriteListener { diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h index 049221ad9144..da288c4fe5ed 100644 --- a/include/clang/AST/ASTContext.h +++ b/include/clang/AST/ASTContext.h @@ -1854,6 +1854,36 @@ public: getCanonicalType(T2).getTypePtr(); } + bool hasSameNullabilityTypeQualifier(QualType SubT, QualType SuperT, + bool IsParam) const { + auto SubTnullability = SubT->getNullability(*this); + auto SuperTnullability = SuperT->getNullability(*this); + if (SubTnullability.hasValue() == SuperTnullability.hasValue()) { + // Neither has nullability; return true + if (!SubTnullability) + return true; + // Both have nullability qualifier. + if (*SubTnullability == *SuperTnullability || + *SubTnullability == NullabilityKind::Unspecified || + *SuperTnullability == NullabilityKind::Unspecified) + return true; + + if (IsParam) { + // Ok for the superclass method parameter to be "nonnull" and the subclass + // method parameter to be "nullable" + return (*SuperTnullability == NullabilityKind::NonNull && + *SubTnullability == NullabilityKind::Nullable); + } + else { + // For the return type, it's okay for the superclass method to specify + // "nullable" and the subclass method specify "nonnull" + return (*SuperTnullability == NullabilityKind::Nullable && + *SubTnullability == NullabilityKind::NonNull); + } + } + return true; + } + bool ObjCMethodsAreEqual(const ObjCMethodDecl *MethodDecl, const ObjCMethodDecl *MethodImp); diff --git a/include/clang/AST/CommentParser.h b/include/clang/AST/CommentParser.h index 42bf4c989a23..fa8862899c14 100644 --- a/include/clang/AST/CommentParser.h +++ b/include/clang/AST/CommentParser.h @@ -75,11 +75,7 @@ class Parser { return; MoreLATokens.push_back(Tok); - for (const Token *I = &Toks.back(), - *B = &Toks.front(); - I != B; --I) { - MoreLATokens.push_back(*I); - } + MoreLATokens.append(Toks.rbegin(), std::prev(Toks.rend())); Tok = Toks[0]; } diff --git a/include/clang/AST/DataRecursiveASTVisitor.h b/include/clang/AST/DataRecursiveASTVisitor.h index 971841e8fb5d..ef8817659338 100644 --- a/include/clang/AST/DataRecursiveASTVisitor.h +++ b/include/clang/AST/DataRecursiveASTVisitor.h @@ -531,10 +531,7 @@ bool RecursiveASTVisitor<Derived>::TraverseStmt(Stmt *S) { } } - for (SmallVectorImpl<Stmt *>::reverse_iterator RI = StmtsToEnqueue.rbegin(), - RE = StmtsToEnqueue.rend(); - RI != RE; ++RI) - Queue.push_back(*RI); + Queue.append(StmtsToEnqueue.rbegin(), StmtsToEnqueue.rend()); } return true; @@ -2204,9 +2201,11 @@ DEF_TRAVERSE_STMT(CXXThisExpr, {}) DEF_TRAVERSE_STMT(CXXThrowExpr, {}) DEF_TRAVERSE_STMT(UserDefinedLiteral, {}) DEF_TRAVERSE_STMT(DesignatedInitExpr, {}) +DEF_TRAVERSE_STMT(DesignatedInitUpdateExpr, {}) DEF_TRAVERSE_STMT(ExtVectorElementExpr, {}) DEF_TRAVERSE_STMT(GNUNullExpr, {}) DEF_TRAVERSE_STMT(ImplicitValueInitExpr, {}) +DEF_TRAVERSE_STMT(NoInitExpr, {}) DEF_TRAVERSE_STMT(ObjCBoolLiteralExpr, {}) DEF_TRAVERSE_STMT(ObjCEncodeExpr, { if (TypeSourceInfo *TInfo = S->getEncodedTypeSourceInfo()) @@ -2356,6 +2355,9 @@ DEF_TRAVERSE_STMT(OMPBarrierDirective, DEF_TRAVERSE_STMT(OMPTaskwaitDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) +DEF_TRAVERSE_STMT(OMPTaskgroupDirective, + { TRY_TO(TraverseOMPExecutableDirective(S)); }) + DEF_TRAVERSE_STMT(OMPFlushDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) diff --git a/include/clang/AST/DeclBase.h b/include/clang/AST/DeclBase.h index f176e5479e1e..6b6ac3f7d5a5 100644 --- a/include/clang/AST/DeclBase.h +++ b/include/clang/AST/DeclBase.h @@ -178,7 +178,12 @@ public: OBJC_TQ_Out = 0x4, OBJC_TQ_Bycopy = 0x8, OBJC_TQ_Byref = 0x10, - OBJC_TQ_Oneway = 0x20 + OBJC_TQ_Oneway = 0x20, + + /// The nullability qualifier is set when the nullability of the + /// result or parameter was expressed via a context-sensitive + /// keyword. + OBJC_TQ_CSNullability = 0x40 }; protected: diff --git a/include/clang/AST/DeclCXX.h b/include/clang/AST/DeclCXX.h index 537ad4640c24..08451c051b57 100644 --- a/include/clang/AST/DeclCXX.h +++ b/include/clang/AST/DeclCXX.h @@ -1440,7 +1440,7 @@ public: /// /// \returns true if this class is derived from \p Base, false otherwise. /// - /// \todo add a separate paramaeter to configure IsDerivedFrom, rather than + /// \todo add a separate parameter to configure IsDerivedFrom, rather than /// tangling input and output in \p Paths bool isDerivedFrom(const CXXRecordDecl *Base, CXXBasePaths &Paths) const; diff --git a/include/clang/AST/DeclObjC.h b/include/clang/AST/DeclObjC.h index 4a5b4f3d0756..c3fb57770245 100644 --- a/include/clang/AST/DeclObjC.h +++ b/include/clang/AST/DeclObjC.h @@ -141,7 +141,7 @@ private: // NOTE: VC++ treats enums as signed, avoid using the ObjCDeclQualifier enum /// in, inout, etc. - unsigned objcDeclQualifier : 6; + unsigned objcDeclQualifier : 7; /// \brief Indicates whether this method has a related result type. unsigned RelatedResultType : 1; @@ -2203,13 +2203,17 @@ public: OBJC_PR_atomic = 0x100, OBJC_PR_weak = 0x200, OBJC_PR_strong = 0x400, - OBJC_PR_unsafe_unretained = 0x800 + OBJC_PR_unsafe_unretained = 0x800, + /// Indicates that the nullability of the type was spelled with a + /// property attribute rather than a type qualifier. + OBJC_PR_nullability = 0x1000, + OBJC_PR_null_resettable = 0x2000 // Adding a property should change NumPropertyAttrsBits }; enum { /// \brief Number of bits fitting all the property attributes. - NumPropertyAttrsBits = 12 + NumPropertyAttrsBits = 14 }; enum SetterKind { Assign, Retain, Copy, Weak }; @@ -2217,7 +2221,8 @@ public: private: SourceLocation AtLoc; // location of \@property SourceLocation LParenLoc; // location of '(' starting attribute list or null. - TypeSourceInfo *DeclType; + QualType DeclType; + TypeSourceInfo *DeclTypeSourceInfo; unsigned PropertyAttributes : NumPropertyAttrsBits; unsigned PropertyAttributesAsWritten : NumPropertyAttrsBits; // \@required/\@optional @@ -2232,12 +2237,13 @@ private: ObjCPropertyDecl(DeclContext *DC, SourceLocation L, IdentifierInfo *Id, SourceLocation AtLocation, SourceLocation LParenLocation, - TypeSourceInfo *T) + QualType T, TypeSourceInfo *TSI, + PropertyControl propControl) : NamedDecl(ObjCProperty, DC, L, Id), AtLoc(AtLocation), - LParenLoc(LParenLocation), DeclType(T), + LParenLoc(LParenLocation), DeclType(T), DeclTypeSourceInfo(TSI), PropertyAttributes(OBJC_PR_noattr), PropertyAttributesAsWritten(OBJC_PR_noattr), - PropertyImplementation(None), + PropertyImplementation(propControl), GetterName(Selector()), SetterName(Selector()), GetterMethodDecl(nullptr), SetterMethodDecl(nullptr), @@ -2248,7 +2254,8 @@ public: SourceLocation L, IdentifierInfo *Id, SourceLocation AtLocation, SourceLocation LParenLocation, - TypeSourceInfo *T, + QualType T, + TypeSourceInfo *TSI, PropertyControl propControl = None); static ObjCPropertyDecl *CreateDeserialized(ASTContext &C, unsigned ID); @@ -2259,9 +2266,14 @@ public: SourceLocation getLParenLoc() const { return LParenLoc; } void setLParenLoc(SourceLocation L) { LParenLoc = L; } - TypeSourceInfo *getTypeSourceInfo() const { return DeclType; } - QualType getType() const { return DeclType->getType(); } - void setType(TypeSourceInfo *T) { DeclType = T; } + TypeSourceInfo *getTypeSourceInfo() const { return DeclTypeSourceInfo; } + + QualType getType() const { return DeclType; } + + void setType(QualType T, TypeSourceInfo *TSI) { + DeclType = T; + DeclTypeSourceInfo = TSI; + } PropertyAttributeKind getPropertyAttributes() const { return PropertyAttributeKind(PropertyAttributes); diff --git a/include/clang/AST/DeclTemplate.h b/include/clang/AST/DeclTemplate.h index 90cfb2049173..0fc9b4947d49 100644 --- a/include/clang/AST/DeclTemplate.h +++ b/include/clang/AST/DeclTemplate.h @@ -217,6 +217,88 @@ public: } }; +void *allocateDefaultArgStorageChain(const ASTContext &C); + +/// Storage for a default argument. This is conceptually either empty, or an +/// argument value, or a pointer to a previous declaration that had a default +/// argument. +/// +/// However, this is complicated by modules: while we require all the default +/// arguments for a template to be equivalent, there may be more than one, and +/// we need to track all the originating parameters to determine if the default +/// argument is visible. +template<typename ParmDecl, typename ArgType> +class DefaultArgStorage { + /// Storage for both the value *and* another parameter from which we inherit + /// the default argument. This is used when multiple default arguments for a + /// parameter are merged together from different modules. + struct Chain { + ParmDecl *PrevDeclWithDefaultArg; + ArgType Value; + }; + static_assert(sizeof(Chain) == sizeof(void *) * 2, + "non-pointer argument type?"); + + llvm::PointerUnion3<ArgType, ParmDecl*, Chain*> ValueOrInherited; + + static ParmDecl *getParmOwningDefaultArg(ParmDecl *Parm) { + const DefaultArgStorage &Storage = Parm->getDefaultArgStorage(); + if (auto *Prev = Storage.ValueOrInherited.template dyn_cast<ParmDecl*>()) + Parm = Prev; + assert(!Parm->getDefaultArgStorage() + .ValueOrInherited.template is<ParmDecl *>() && + "should only be one level of indirection"); + return Parm; + } + +public: + DefaultArgStorage() : ValueOrInherited(ArgType()) {} + + /// Determine whether there is a default argument for this parameter. + bool isSet() const { return !ValueOrInherited.isNull(); } + /// Determine whether the default argument for this parameter was inherited + /// from a previous declaration of the same entity. + bool isInherited() const { return ValueOrInherited.template is<ParmDecl*>(); } + /// Get the default argument's value. This does not consider whether the + /// default argument is visible. + ArgType get() const { + const DefaultArgStorage *Storage = this; + if (auto *Prev = ValueOrInherited.template dyn_cast<ParmDecl*>()) + Storage = &Prev->getDefaultArgStorage(); + if (auto *C = Storage->ValueOrInherited.template dyn_cast<Chain*>()) + return C->Value; + return Storage->ValueOrInherited.template get<ArgType>(); + } + /// Get the parameter from which we inherit the default argument, if any. + /// This is the parameter on which the default argument was actually written. + const ParmDecl *getInheritedFrom() const { + if (auto *D = ValueOrInherited.template dyn_cast<ParmDecl*>()) + return D; + if (auto *C = ValueOrInherited.template dyn_cast<Chain*>()) + return C->PrevDeclWithDefaultArg; + return nullptr; + } + /// Set the default argument. + void set(ArgType Arg) { + assert(!isSet() && "default argument already set"); + ValueOrInherited = Arg; + } + /// Set that the default argument was inherited from another parameter. + void setInherited(const ASTContext &C, ParmDecl *InheritedFrom) { + assert(!isInherited() && "default argument already inherited"); + InheritedFrom = getParmOwningDefaultArg(InheritedFrom); + if (!isSet()) + ValueOrInherited = InheritedFrom; + else + ValueOrInherited = new (allocateDefaultArgStorageChain(C)) + Chain{InheritedFrom, ValueOrInherited.template get<ArgType>()}; + } + /// Remove the default argument, even if it was inherited. + void clear() { + ValueOrInherited = ArgType(); + } +}; + //===----------------------------------------------------------------------===// // Kinds of Templates //===----------------------------------------------------------------------===// @@ -942,18 +1024,16 @@ class TemplateTypeParmDecl : public TypeDecl { /// If false, it was declared with the 'class' keyword. bool Typename : 1; - /// \brief Whether this template type parameter inherited its - /// default argument. - bool InheritedDefault : 1; - /// \brief The default template argument, if any. - TypeSourceInfo *DefaultArgument; + typedef DefaultArgStorage<TemplateTypeParmDecl, TypeSourceInfo *> + DefArgStorage; + DefArgStorage DefaultArgument; TemplateTypeParmDecl(DeclContext *DC, SourceLocation KeyLoc, SourceLocation IdLoc, IdentifierInfo *Id, bool Typename) : TypeDecl(TemplateTypeParm, DC, IdLoc, Id, KeyLoc), Typename(Typename), - InheritedDefault(false), DefaultArgument() { } + DefaultArgument() { } /// Sema creates these on the stack during auto type deduction. friend class Sema; @@ -974,35 +1054,45 @@ public: /// If not, it was declared with the 'class' keyword. bool wasDeclaredWithTypename() const { return Typename; } + const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; } + /// \brief Determine whether this template parameter has a default /// argument. - bool hasDefaultArgument() const { return DefaultArgument != nullptr; } + bool hasDefaultArgument() const { return DefaultArgument.isSet(); } /// \brief Retrieve the default argument, if any. - QualType getDefaultArgument() const { return DefaultArgument->getType(); } + QualType getDefaultArgument() const { + return DefaultArgument.get()->getType(); + } /// \brief Retrieves the default argument's source information, if any. - TypeSourceInfo *getDefaultArgumentInfo() const { return DefaultArgument; } + TypeSourceInfo *getDefaultArgumentInfo() const { + return DefaultArgument.get(); + } /// \brief Retrieves the location of the default argument declaration. SourceLocation getDefaultArgumentLoc() const; /// \brief Determines whether the default argument was inherited /// from a previous declaration of this template. - bool defaultArgumentWasInherited() const { return InheritedDefault; } + bool defaultArgumentWasInherited() const { + return DefaultArgument.isInherited(); + } - /// \brief Set the default argument for this template parameter, and - /// whether that default argument was inherited from another - /// declaration. - void setDefaultArgument(TypeSourceInfo *DefArg, bool Inherited) { - DefaultArgument = DefArg; - InheritedDefault = Inherited; + /// \brief Set the default argument for this template parameter. + void setDefaultArgument(TypeSourceInfo *DefArg) { + DefaultArgument.set(DefArg); + } + /// \brief Set that this default argument was inherited from another + /// parameter. + void setInheritedDefaultArgument(const ASTContext &C, + TemplateTypeParmDecl *Prev) { + DefaultArgument.setInherited(C, Prev); } /// \brief Removes the default argument of this template parameter. void removeDefaultArgument() { - DefaultArgument = nullptr; - InheritedDefault = false; + DefaultArgument.clear(); } /// \brief Set whether this template type parameter was declared with @@ -1034,7 +1124,8 @@ class NonTypeTemplateParmDecl : public DeclaratorDecl, protected TemplateParmPosition { /// \brief The default template argument, if any, and whether or not /// it was inherited. - llvm::PointerIntPair<Expr*, 1, bool> DefaultArgumentAndInherited; + typedef DefaultArgStorage<NonTypeTemplateParmDecl, Expr*> DefArgStorage; + DefArgStorage DefaultArgument; // FIXME: Collapse this into TemplateParamPosition; or, just move depth/index // down here to save memory. @@ -1055,9 +1146,8 @@ class NonTypeTemplateParmDecl IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo) : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc), - TemplateParmPosition(D, P), DefaultArgumentAndInherited(nullptr, false), - ParameterPack(ParameterPack), ExpandedParameterPack(false), - NumExpandedTypes(0) + TemplateParmPosition(D, P), ParameterPack(ParameterPack), + ExpandedParameterPack(false), NumExpandedTypes(0) { } NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc, @@ -1097,16 +1187,14 @@ public: SourceRange getSourceRange() const override LLVM_READONLY; + const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; } + /// \brief Determine whether this template parameter has a default /// argument. - bool hasDefaultArgument() const { - return DefaultArgumentAndInherited.getPointer() != nullptr; - } + bool hasDefaultArgument() const { return DefaultArgument.isSet(); } /// \brief Retrieve the default argument, if any. - Expr *getDefaultArgument() const { - return DefaultArgumentAndInherited.getPointer(); - } + Expr *getDefaultArgument() const { return DefaultArgument.get(); } /// \brief Retrieve the location of the default argument, if any. SourceLocation getDefaultArgumentLoc() const; @@ -1114,22 +1202,20 @@ public: /// \brief Determines whether the default argument was inherited /// from a previous declaration of this template. bool defaultArgumentWasInherited() const { - return DefaultArgumentAndInherited.getInt(); + return DefaultArgument.isInherited(); } /// \brief Set the default argument for this template parameter, and /// whether that default argument was inherited from another /// declaration. - void setDefaultArgument(Expr *DefArg, bool Inherited) { - DefaultArgumentAndInherited.setPointer(DefArg); - DefaultArgumentAndInherited.setInt(Inherited); + void setDefaultArgument(Expr *DefArg) { DefaultArgument.set(DefArg); } + void setInheritedDefaultArgument(const ASTContext &C, + NonTypeTemplateParmDecl *Parm) { + DefaultArgument.setInherited(C, Parm); } /// \brief Removes the default argument of this template parameter. - void removeDefaultArgument() { - DefaultArgumentAndInherited.setPointer(nullptr); - DefaultArgumentAndInherited.setInt(false); - } + void removeDefaultArgument() { DefaultArgument.clear(); } /// \brief Whether this parameter is a non-type template parameter pack. /// @@ -1217,10 +1303,10 @@ class TemplateTemplateParmDecl : public TemplateDecl, { void anchor() override; - /// DefaultArgument - The default template argument, if any. - TemplateArgumentLoc DefaultArgument; - /// Whether or not the default argument was inherited. - bool DefaultArgumentWasInherited; + /// \brief The default template argument, if any. + typedef DefaultArgStorage<TemplateTemplateParmDecl, TemplateArgumentLoc *> + DefArgStorage; + DefArgStorage DefaultArgument; /// \brief Whether this parameter is a parameter pack. bool ParameterPack; @@ -1237,8 +1323,7 @@ class TemplateTemplateParmDecl : public TemplateDecl, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, TemplateParameterList *Params) : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params), - TemplateParmPosition(D, P), DefaultArgument(), - DefaultArgumentWasInherited(false), ParameterPack(ParameterPack), + TemplateParmPosition(D, P), ParameterPack(ParameterPack), ExpandedParameterPack(false), NumExpandedParams(0) { } @@ -1322,15 +1407,16 @@ public: return reinterpret_cast<TemplateParameterList *const *>(this + 1)[I]; } + const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; } + /// \brief Determine whether this template parameter has a default /// argument. - bool hasDefaultArgument() const { - return !DefaultArgument.getArgument().isNull(); - } + bool hasDefaultArgument() const { return DefaultArgument.isSet(); } /// \brief Retrieve the default argument, if any. const TemplateArgumentLoc &getDefaultArgument() const { - return DefaultArgument; + static const TemplateArgumentLoc None; + return DefaultArgument.isSet() ? *DefaultArgument.get() : None; } /// \brief Retrieve the location of the default argument, if any. @@ -1339,22 +1425,21 @@ public: /// \brief Determines whether the default argument was inherited /// from a previous declaration of this template. bool defaultArgumentWasInherited() const { - return DefaultArgumentWasInherited; + return DefaultArgument.isInherited(); } /// \brief Set the default argument for this template parameter, and /// whether that default argument was inherited from another /// declaration. - void setDefaultArgument(const TemplateArgumentLoc &DefArg, bool Inherited) { - DefaultArgument = DefArg; - DefaultArgumentWasInherited = Inherited; + void setDefaultArgument(const ASTContext &C, + const TemplateArgumentLoc &DefArg); + void setInheritedDefaultArgument(const ASTContext &C, + TemplateTemplateParmDecl *Prev) { + DefaultArgument.setInherited(C, Prev); } /// \brief Removes the default argument of this template parameter. - void removeDefaultArgument() { - DefaultArgument = TemplateArgumentLoc(); - DefaultArgumentWasInherited = false; - } + void removeDefaultArgument() { DefaultArgument.clear(); } SourceRange getSourceRange() const override LLVM_READONLY { SourceLocation End = getLocation(); diff --git a/include/clang/AST/EvaluatedExprVisitor.h b/include/clang/AST/EvaluatedExprVisitor.h index 59de104b83f9..5cae5d9eca3f 100644 --- a/include/clang/AST/EvaluatedExprVisitor.h +++ b/include/clang/AST/EvaluatedExprVisitor.h @@ -26,29 +26,32 @@ class ASTContext; /// \brief Given a potentially-evaluated expression, this visitor visits all /// of its potentially-evaluated subexpressions, recursively. -template<typename ImplClass> -class EvaluatedExprVisitor : public StmtVisitor<ImplClass> { - ASTContext &Context; - +template<template <typename> class Ptr, typename ImplClass> +class EvaluatedExprVisitorBase : public StmtVisitorBase<Ptr, ImplClass, void> { +protected: + const ASTContext &Context; + public: - explicit EvaluatedExprVisitor(ASTContext &Context) : Context(Context) { } - +#define PTR(CLASS) typename Ptr<CLASS>::type + + explicit EvaluatedExprVisitorBase(const ASTContext &Context) : Context(Context) { } + // Expressions that have no potentially-evaluated subexpressions (but may have // other sub-expressions). - void VisitDeclRefExpr(DeclRefExpr *E) { } - void VisitOffsetOfExpr(OffsetOfExpr *E) { } - void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { } - void VisitExpressionTraitExpr(ExpressionTraitExpr *E) { } - void VisitBlockExpr(BlockExpr *E) { } - void VisitCXXUuidofExpr(CXXUuidofExpr *E) { } - void VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { } - - void VisitMemberExpr(MemberExpr *E) { + void VisitDeclRefExpr(PTR(DeclRefExpr) E) { } + void VisitOffsetOfExpr(PTR(OffsetOfExpr) E) { } + void VisitUnaryExprOrTypeTraitExpr(PTR(UnaryExprOrTypeTraitExpr) E) { } + void VisitExpressionTraitExpr(PTR(ExpressionTraitExpr) E) { } + void VisitBlockExpr(PTR(BlockExpr) E) { } + void VisitCXXUuidofExpr(PTR(CXXUuidofExpr) E) { } + void VisitCXXNoexceptExpr(PTR(CXXNoexceptExpr) E) { } + + void VisitMemberExpr(PTR(MemberExpr) E) { // Only the base matters. return this->Visit(E->getBase()); } - - void VisitChooseExpr(ChooseExpr *E) { + + void VisitChooseExpr(PTR(ChooseExpr) E) { // Don't visit either child expression if the condition is dependent. if (E->getCond()->isValueDependent()) return; @@ -56,7 +59,7 @@ public: return this->Visit(E->getChosenSubExpr()); } - void VisitGenericSelectionExpr(GenericSelectionExpr *E) { + void VisitGenericSelectionExpr(PTR(GenericSelectionExpr) E) { // The controlling expression of a generic selection is not evaluated. // Don't visit either child expression if the condition is type-dependent. @@ -67,23 +70,23 @@ public: return this->Visit(E->getResultExpr()); } - void VisitDesignatedInitExpr(DesignatedInitExpr *E) { + void VisitDesignatedInitExpr(PTR(DesignatedInitExpr) E) { // Only the actual initializer matters; the designators are all constant // expressions. return this->Visit(E->getInit()); } - void VisitCXXTypeidExpr(CXXTypeidExpr *E) { + void VisitCXXTypeidExpr(PTR(CXXTypeidExpr) E) { if (E->isPotentiallyEvaluated()) return this->Visit(E->getExprOperand()); } - void VisitCallExpr(CallExpr *CE) { + void VisitCallExpr(PTR(CallExpr) CE) { if (!CE->isUnevaluatedBuiltinCall(Context)) return static_cast<ImplClass*>(this)->VisitExpr(CE); } - void VisitLambdaExpr(LambdaExpr *LE) { + void VisitLambdaExpr(PTR(LambdaExpr) LE) { // Only visit the capture initializers, and not the body. for (LambdaExpr::capture_init_iterator I = LE->capture_init_begin(), E = LE->capture_init_end(); @@ -94,11 +97,31 @@ public: /// \brief The basis case walks all of the children of the statement or /// expression, assuming they are all potentially evaluated. - void VisitStmt(Stmt *S) { - for (Stmt::child_range C = S->children(); C; ++C) + void VisitStmt(PTR(Stmt) S) { + for (auto C = S->children(); C; ++C) if (*C) this->Visit(*C); } + +#undef PTR +}; + +/// EvaluatedExprVisitor - This class visits 'Expr *'s +template<typename ImplClass> +class EvaluatedExprVisitor + : public EvaluatedExprVisitorBase<make_ptr, ImplClass> { +public: + explicit EvaluatedExprVisitor(const ASTContext &Context) : + EvaluatedExprVisitorBase<make_ptr, ImplClass>(Context) { } +}; + +/// ConstEvaluatedExprVisitor - This class visits 'const Expr *'s. +template<typename ImplClass> +class ConstEvaluatedExprVisitor + : public EvaluatedExprVisitorBase<make_const_ptr, ImplClass> { +public: + explicit ConstEvaluatedExprVisitor(const ASTContext &Context) : + EvaluatedExprVisitorBase<make_const_ptr, ImplClass>(Context) { } }; } diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h index a3be7d06c4b1..2a5b4c0f5ed0 100644 --- a/include/clang/AST/Expr.h +++ b/include/clang/AST/Expr.h @@ -598,7 +598,7 @@ public: /// \brief Determine whether this expression involves a call to any function /// that is not trivial. - bool hasNonTrivialCall(ASTContext &Ctx); + bool hasNonTrivialCall(const ASTContext &Ctx) const; /// EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded /// integer. This must be called on an expression that constant folds to an @@ -2273,7 +2273,7 @@ public: /// \brief Returns \c true if this is a call to a builtin which does not /// evaluate side-effects within its arguments. - bool isUnevaluatedBuiltinCall(ASTContext &Ctx) const; + bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const; /// getCallReturnType - Get the return type of the call expr. This is not /// always the type of the expr itself, if the return type is a reference @@ -4267,6 +4267,80 @@ public: } }; +/// \brief Represents a place-holder for an object not to be initialized by +/// anything. +/// +/// This only makes sense when it appears as part of an updater of a +/// DesignatedInitUpdateExpr (see below). The base expression of a DIUE +/// initializes a big object, and the NoInitExpr's mark the spots within the +/// big object not to be overwritten by the updater. +/// +/// \see DesignatedInitUpdateExpr +class NoInitExpr : public Expr { +public: + explicit NoInitExpr(QualType ty) + : Expr(NoInitExprClass, ty, VK_RValue, OK_Ordinary, + false, false, ty->isInstantiationDependentType(), false) { } + + explicit NoInitExpr(EmptyShell Empty) + : Expr(NoInitExprClass, Empty) { } + + static bool classof(const Stmt *T) { + return T->getStmtClass() == NoInitExprClass; + } + + SourceLocation getLocStart() const LLVM_READONLY { return SourceLocation(); } + SourceLocation getLocEnd() const LLVM_READONLY { return SourceLocation(); } + + // Iterators + child_range children() { return child_range(); } +}; + +// In cases like: +// struct Q { int a, b, c; }; +// Q *getQ(); +// void foo() { +// struct A { Q q; } a = { *getQ(), .q.b = 3 }; +// } +// +// We will have an InitListExpr for a, with type A, and then a +// DesignatedInitUpdateExpr for "a.q" with type Q. The "base" for this DIUE +// is the call expression *getQ(); the "updater" for the DIUE is ".q.b = 3" +// +class DesignatedInitUpdateExpr : public Expr { + // BaseAndUpdaterExprs[0] is the base expression; + // BaseAndUpdaterExprs[1] is an InitListExpr overwriting part of the base. + Stmt *BaseAndUpdaterExprs[2]; + +public: + DesignatedInitUpdateExpr(const ASTContext &C, SourceLocation lBraceLoc, + Expr *baseExprs, SourceLocation rBraceLoc); + + explicit DesignatedInitUpdateExpr(EmptyShell Empty) + : Expr(DesignatedInitUpdateExprClass, Empty) { } + + SourceLocation getLocStart() const LLVM_READONLY; + SourceLocation getLocEnd() const LLVM_READONLY; + + static bool classof(const Stmt *T) { + return T->getStmtClass() == DesignatedInitUpdateExprClass; + } + + Expr *getBase() const { return cast<Expr>(BaseAndUpdaterExprs[0]); } + void setBase(Expr *Base) { BaseAndUpdaterExprs[0] = Base; } + + InitListExpr *getUpdater() const { + return cast<InitListExpr>(BaseAndUpdaterExprs[1]); + } + void setUpdater(Expr *Updater) { BaseAndUpdaterExprs[1] = Updater; } + + // Iterators + // children = the base and the updater + child_range children() { + return child_range(&BaseAndUpdaterExprs[0], &BaseAndUpdaterExprs[0] + 2); + } +}; + /// \brief Represents an implicitly-generated value initialization of /// an object of a given type. /// diff --git a/include/clang/AST/OpenMPClause.h b/include/clang/AST/OpenMPClause.h index c8ecef8ce50c..386c8dd3ee94 100644 --- a/include/clang/AST/OpenMPClause.h +++ b/include/clang/AST/OpenMPClause.h @@ -1752,7 +1752,7 @@ public: StmtRange children() { return StmtRange(reinterpret_cast<Stmt **>(varlist_begin()), - reinterpret_cast<Stmt **>(getFinals().end() + 2)); + reinterpret_cast<Stmt **>(varlist_end())); } static bool classof(const OMPClause *T) { @@ -1837,7 +1837,7 @@ public: StmtRange children() { return StmtRange(reinterpret_cast<Stmt **>(varlist_begin()), - reinterpret_cast<Stmt **>(varlist_end() + 1)); + reinterpret_cast<Stmt **>(varlist_end())); } static bool classof(const OMPClause *T) { diff --git a/include/clang/AST/RecursiveASTVisitor.h b/include/clang/AST/RecursiveASTVisitor.h index 95e0df3066b0..95d773073184 100644 --- a/include/clang/AST/RecursiveASTVisitor.h +++ b/include/clang/AST/RecursiveASTVisitor.h @@ -2234,9 +2234,11 @@ DEF_TRAVERSE_STMT(CXXThisExpr, {}) DEF_TRAVERSE_STMT(CXXThrowExpr, {}) DEF_TRAVERSE_STMT(UserDefinedLiteral, {}) DEF_TRAVERSE_STMT(DesignatedInitExpr, {}) +DEF_TRAVERSE_STMT(DesignatedInitUpdateExpr, {}) DEF_TRAVERSE_STMT(ExtVectorElementExpr, {}) DEF_TRAVERSE_STMT(GNUNullExpr, {}) DEF_TRAVERSE_STMT(ImplicitValueInitExpr, {}) +DEF_TRAVERSE_STMT(NoInitExpr, {}) DEF_TRAVERSE_STMT(ObjCBoolLiteralExpr, {}) DEF_TRAVERSE_STMT(ObjCEncodeExpr, { if (TypeSourceInfo *TInfo = S->getEncodedTypeSourceInfo()) @@ -2386,6 +2388,9 @@ DEF_TRAVERSE_STMT(OMPBarrierDirective, DEF_TRAVERSE_STMT(OMPTaskwaitDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) +DEF_TRAVERSE_STMT(OMPTaskgroupDirective, + { TRY_TO(TraverseOMPExecutableDirective(S)); }) + DEF_TRAVERSE_STMT(OMPFlushDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) diff --git a/include/clang/AST/StmtOpenMP.h b/include/clang/AST/StmtOpenMP.h index 5161eff0993b..63f295ddfec0 100644 --- a/include/clang/AST/StmtOpenMP.h +++ b/include/clang/AST/StmtOpenMP.h @@ -285,24 +285,23 @@ class OMPLoopDirective : public OMPExecutableDirective { CalcLastIterationOffset = 3, PreConditionOffset = 4, CondOffset = 5, - SeparatedCondOffset = 6, - InitOffset = 7, - IncOffset = 8, + InitOffset = 6, + IncOffset = 7, // The '...End' enumerators do not correspond to child expressions - they // specify the offset to the end (and start of the following counters/ // updates/finals arrays). - DefaultEnd = 9, + DefaultEnd = 8, // The following 7 exprs are used by worksharing loops only. - IsLastIterVariableOffset = 9, - LowerBoundVariableOffset = 10, - UpperBoundVariableOffset = 11, - StrideVariableOffset = 12, - EnsureUpperBoundOffset = 13, - NextLowerBoundOffset = 14, - NextUpperBoundOffset = 15, + IsLastIterVariableOffset = 8, + LowerBoundVariableOffset = 9, + UpperBoundVariableOffset = 10, + StrideVariableOffset = 11, + EnsureUpperBoundOffset = 12, + NextLowerBoundOffset = 13, + NextUpperBoundOffset = 14, // Offset to the end (and start of the following counters/updates/finals // arrays) for worksharing loop directives. - WorksharingEnd = 16, + WorksharingEnd = 15, }; /// \brief Get the counters storage. @@ -374,9 +373,8 @@ protected: void setPreCond(Expr *PC) { *std::next(child_begin(), PreConditionOffset) = PC; } - void setCond(Expr *Cond, Expr *SeparatedCond) { + void setCond(Expr *Cond) { *std::next(child_begin(), CondOffset) = Cond; - *std::next(child_begin(), SeparatedCondOffset) = SeparatedCond; } void setInit(Expr *Init) { *std::next(child_begin(), InitOffset) = Init; } void setInc(Expr *Inc) { *std::next(child_begin(), IncOffset) = Inc; } @@ -435,8 +433,6 @@ public: Expr *PreCond; /// \brief Loop condition. Expr *Cond; - /// \brief A condition with 1 iteration separated. - Expr *SeparatedCond; /// \brief Loop iteration variable init. Expr *Init; /// \brief Loop increment. @@ -467,8 +463,7 @@ public: bool builtAll() { return IterationVarRef != nullptr && LastIteration != nullptr && NumIterations != nullptr && PreCond != nullptr && - Cond != nullptr && SeparatedCond != nullptr && Init != nullptr && - Inc != nullptr; + Cond != nullptr && Init != nullptr && Inc != nullptr; } /// \brief Initialize all the fields to null. @@ -479,7 +474,6 @@ public: CalcLastIteration = nullptr; PreCond = nullptr; Cond = nullptr; - SeparatedCond = nullptr; Init = nullptr; Inc = nullptr; IL = nullptr; @@ -519,10 +513,9 @@ public: return const_cast<Expr *>(reinterpret_cast<const Expr *>( *std::next(child_begin(), PreConditionOffset))); } - Expr *getCond(bool SeparateIter) const { - return const_cast<Expr *>(reinterpret_cast<const Expr *>( - *std::next(child_begin(), - (SeparateIter ? SeparatedCondOffset : CondOffset)))); + Expr *getCond() const { + return const_cast<Expr *>( + reinterpret_cast<const Expr *>(*std::next(child_begin(), CondOffset))); } Expr *getInit() const { return const_cast<Expr *>( @@ -1462,6 +1455,53 @@ public: } }; +/// \brief This represents '#pragma omp taskgroup' directive. +/// +/// \code +/// #pragma omp taskgroup +/// \endcode +/// +class OMPTaskgroupDirective : public OMPExecutableDirective { + friend class ASTStmtReader; + /// \brief Build directive with the given start and end location. + /// + /// \param StartLoc Starting location of the directive kind. + /// \param EndLoc Ending location of the directive. + /// + OMPTaskgroupDirective(SourceLocation StartLoc, SourceLocation EndLoc) + : OMPExecutableDirective(this, OMPTaskgroupDirectiveClass, OMPD_taskgroup, + StartLoc, EndLoc, 0, 1) {} + + /// \brief Build an empty directive. + /// + explicit OMPTaskgroupDirective() + : OMPExecutableDirective(this, OMPTaskgroupDirectiveClass, OMPD_taskgroup, + SourceLocation(), SourceLocation(), 0, 1) {} + +public: + /// \brief Creates directive. + /// + /// \param C AST context. + /// \param StartLoc Starting location of the directive kind. + /// \param EndLoc Ending Location of the directive. + /// \param AssociatedStmt Statement, associated with the directive. + /// + static OMPTaskgroupDirective *Create(const ASTContext &C, + SourceLocation StartLoc, + SourceLocation EndLoc, + Stmt *AssociatedStmt); + + /// \brief Creates an empty directive. + /// + /// \param C AST context. + /// + static OMPTaskgroupDirective *CreateEmpty(const ASTContext &C, EmptyShell); + + static bool classof(const Stmt *T) { + return T->getStmtClass() == OMPTaskgroupDirectiveClass; + } +}; + /// \brief This represents '#pragma omp flush' directive. /// /// \code diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h index 8cd29b7b917e..d903b9d8cbcf 100644 --- a/include/clang/AST/Type.h +++ b/include/clang/AST/Type.h @@ -1818,6 +1818,19 @@ public: /// checking. Should always return true. bool isLinkageValid() const; + /// Determine the nullability of the given type. + /// + /// Note that nullability is only captured as sugar within the type + /// system, not as part of the canonical type, so nullability will + /// be lost by canonicalization and desugaring. + Optional<NullabilityKind> getNullability(const ASTContext &context) const; + + /// Determine whether the given type can have a nullability + /// specifier applied to it, i.e., if it is any kind of pointer type + /// or a dependent type that could instantiate to any kind of + /// pointer type. + bool canHaveNullability() const; + const char *getTypeClassName() const; QualType getCanonicalTypeInternal() const { @@ -3479,7 +3492,10 @@ public: attr_ptr32, attr_ptr64, attr_sptr, - attr_uptr + attr_uptr, + attr_nonnull, + attr_nullable, + attr_null_unspecified, }; private: @@ -3513,6 +3529,35 @@ public: bool isCallingConv() const; + llvm::Optional<NullabilityKind> getImmediateNullability() const; + + /// Retrieve the attribute kind corresponding to the given + /// nullability kind. + static Kind getNullabilityAttrKind(NullabilityKind kind) { + switch (kind) { + case NullabilityKind::NonNull: + return attr_nonnull; + + case NullabilityKind::Nullable: + return attr_nullable; + + case NullabilityKind::Unspecified: + return attr_null_unspecified; + } + llvm_unreachable("Unknown nullability kind."); + } + + /// Strip off the top-level nullability annotation on the given + /// type, if it's there. + /// + /// \param T The type to strip. If the type is exactly an + /// AttributedType specifying nullability (without looking through + /// type sugar), the nullability is returned and this type changed + /// to the underlying modified type. + /// + /// \returns the top-level nullability, if present. + static Optional<NullabilityKind> stripOuterNullability(QualType &T); + void Profile(llvm::FoldingSetNodeID &ID) { Profile(ID, getAttrKind(), ModifiedType, EquivalentType); } diff --git a/include/clang/ASTMatchers/ASTMatchersMacros.h b/include/clang/ASTMatchers/ASTMatchersMacros.h index e8eab864b298..8ad0c16ef83a 100644 --- a/include/clang/ASTMatchers/ASTMatchersMacros.h +++ b/include/clang/ASTMatchers/ASTMatchersMacros.h @@ -20,17 +20,30 @@ // to only have the functions (which is all the user cares about) in the // 'ast_matchers' namespace and hide the boilerplate. // -// To define a matcher in user code, always put it into the clang::ast_matchers -// namespace and refer to the internal types via the 'internal::': +// To define a matcher in user code, put it into your own namespace. This would +// help to prevent ODR violations in case a matcher with the same name is +// defined in multiple translation units: +// +// namespace my_matchers { +// AST_MATCHER_P(clang::MemberExpr, Member, +// clang::ast_matchers::internal::Matcher<clang::ValueDecl>, +// InnerMatcher) { +// return InnerMatcher.matches(*Node.getMemberDecl(), Finder, Builder); +// } +// } // namespace my_matchers +// +// Alternatively, an unnamed namespace may be used: // // namespace clang { // namespace ast_matchers { +// namespace { // AST_MATCHER_P(MemberExpr, Member, // internal::Matcher<ValueDecl>, InnerMatcher) { // return InnerMatcher.matches(*Node.getMemberDecl(), Finder, Builder); // } -// } // end namespace ast_matchers -// } // end namespace clang +// } // namespace +// } // namespace ast_matchers +// } // namespace clang // //===----------------------------------------------------------------------===// @@ -43,12 +56,13 @@ #define AST_MATCHER_FUNCTION(ReturnType, DefineMatcher) \ inline ReturnType DefineMatcher##_getInstance(); \ inline ReturnType DefineMatcher() { \ - return internal::MemoizedMatcher< \ + return ::clang::ast_matchers::internal::MemoizedMatcher< \ ReturnType, DefineMatcher##_getInstance>::getInstance(); \ } \ inline ReturnType DefineMatcher##_getInstance() -/// \brief AST_MATCHER_FUNCTION_P(ReturnType, DefineMatcher, ParamType, Param) { ... } +/// \brief AST_MATCHER_FUNCTION_P(ReturnType, DefineMatcher, ParamType, Param) { +/// ... } /// defines a single-parameter function named DefineMatcher() that returns a /// ReturnType object. /// @@ -80,20 +94,24 @@ /// The code should return true if 'Node' matches. #define AST_MATCHER(Type, DefineMatcher) \ namespace internal { \ - class matcher_##DefineMatcher##Matcher : public MatcherInterface<Type> { \ + class matcher_##DefineMatcher##Matcher \ + : public ::clang::ast_matchers::internal::MatcherInterface<Type> { \ public: \ explicit matcher_##DefineMatcher##Matcher() {} \ - bool matches(const Type &Node, ASTMatchFinder *Finder, \ - BoundNodesTreeBuilder *Builder) const override; \ + bool matches(const Type &Node, \ + ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ + ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ + *Builder) const override; \ }; \ } \ - inline internal::Matcher<Type> DefineMatcher() { \ - return internal::makeMatcher( \ + inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher() { \ + return ::clang::ast_matchers::internal::makeMatcher( \ new internal::matcher_##DefineMatcher##Matcher()); \ } \ inline bool internal::matcher_##DefineMatcher##Matcher::matches( \ - const Type &Node, ASTMatchFinder *Finder, \ - BoundNodesTreeBuilder *Builder) const + const Type &Node, \ + ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ + ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const /// \brief AST_MATCHER_P(Type, DefineMatcher, ParamType, Param) { ... } /// defines a single-parameter function named DefineMatcher() that returns a @@ -115,27 +133,31 @@ OverloadId) \ namespace internal { \ class matcher_##DefineMatcher##OverloadId##Matcher \ - : public MatcherInterface<Type> { \ + : public ::clang::ast_matchers::internal::MatcherInterface<Type> { \ public: \ explicit matcher_##DefineMatcher##OverloadId##Matcher( \ ParamType const &A##Param) \ : Param(A##Param) {} \ - bool matches(const Type &Node, ASTMatchFinder *Finder, \ - BoundNodesTreeBuilder *Builder) const override; \ + bool matches(const Type &Node, \ + ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ + ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ + *Builder) const override; \ \ private: \ ParamType const Param; \ }; \ } \ - inline internal::Matcher<Type> DefineMatcher(ParamType const &Param) { \ - return internal::makeMatcher( \ + inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher( \ + ParamType const &Param) { \ + return ::clang::ast_matchers::internal::makeMatcher( \ new internal::matcher_##DefineMatcher##OverloadId##Matcher(Param)); \ } \ - typedef internal::Matcher<Type>(&DefineMatcher##_Type##OverloadId)( \ - ParamType const &Param); \ + typedef ::clang::ast_matchers::internal::Matcher<Type>( \ + &DefineMatcher##_Type##OverloadId)(ParamType const &Param); \ inline bool internal::matcher_##DefineMatcher##OverloadId##Matcher::matches( \ - const Type &Node, ASTMatchFinder *Finder, \ - BoundNodesTreeBuilder *Builder) const + const Type &Node, \ + ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ + ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const /// \brief AST_MATCHER_P2( /// Type, DefineMatcher, ParamType1, Param1, ParamType2, Param2) { ... } @@ -160,30 +182,34 @@ ParamType2, Param2, OverloadId) \ namespace internal { \ class matcher_##DefineMatcher##OverloadId##Matcher \ - : public MatcherInterface<Type> { \ + : public ::clang::ast_matchers::internal::MatcherInterface<Type> { \ public: \ matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 const &A##Param1, \ ParamType2 const &A##Param2) \ : Param1(A##Param1), Param2(A##Param2) {} \ - bool matches(const Type &Node, ASTMatchFinder *Finder, \ - BoundNodesTreeBuilder *Builder) const override; \ + bool matches(const Type &Node, \ + ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ + ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ + *Builder) const override; \ \ private: \ ParamType1 const Param1; \ ParamType2 const Param2; \ }; \ } \ - inline internal::Matcher<Type> DefineMatcher(ParamType1 const &Param1, \ - ParamType2 const &Param2) { \ - return internal::makeMatcher( \ + inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher( \ + ParamType1 const &Param1, ParamType2 const &Param2) { \ + return ::clang::ast_matchers::internal::makeMatcher( \ new internal::matcher_##DefineMatcher##OverloadId##Matcher(Param1, \ Param2)); \ } \ - typedef internal::Matcher<Type>(&DefineMatcher##_Type##OverloadId)( \ - ParamType1 const &Param1, ParamType2 const &Param2); \ + typedef ::clang::ast_matchers::internal::Matcher<Type>( \ + &DefineMatcher##_Type##OverloadId)(ParamType1 const &Param1, \ + ParamType2 const &Param2); \ inline bool internal::matcher_##DefineMatcher##OverloadId##Matcher::matches( \ - const Type &Node, ASTMatchFinder *Finder, \ - BoundNodesTreeBuilder *Builder) const + const Type &Node, \ + ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ + ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const /// \brief Construct a type-list to be passed to the AST_POLYMORPHIC_MATCHER* /// macros. @@ -194,7 +220,7 @@ /// The \c PolymorphicMatcherWithParam* classes will unpack the function type to /// extract the TypeList object. #define AST_POLYMORPHIC_SUPPORTED_TYPES(...) \ - void(internal::TypeList<__VA_ARGS__>) + void(::clang::ast_matchers::internal::TypeList<__VA_ARGS__>) /// \brief AST_POLYMORPHIC_MATCHER(DefineMatcher) { ... } /// defines a single-parameter function named DefineMatcher() that is @@ -205,22 +231,26 @@ #define AST_POLYMORPHIC_MATCHER(DefineMatcher, ReturnTypesF) \ namespace internal { \ template <typename NodeType> \ - class matcher_##DefineMatcher##Matcher : public MatcherInterface<NodeType> { \ + class matcher_##DefineMatcher##Matcher \ + : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \ public: \ - bool matches(const NodeType &Node, ASTMatchFinder *Finder, \ - BoundNodesTreeBuilder *Builder) const override; \ + bool matches(const NodeType &Node, \ + ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ + ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ + *Builder) const override; \ }; \ } \ - inline internal::PolymorphicMatcherWithParam0< \ + inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam0< \ internal::matcher_##DefineMatcher##Matcher, ReturnTypesF> \ DefineMatcher() { \ - return internal::PolymorphicMatcherWithParam0< \ + return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam0< \ internal::matcher_##DefineMatcher##Matcher, ReturnTypesF>(); \ } \ template <typename NodeType> \ bool internal::matcher_##DefineMatcher##Matcher<NodeType>::matches( \ - const NodeType &Node, ASTMatchFinder *Finder, \ - BoundNodesTreeBuilder *Builder) const + const NodeType &Node, \ + ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ + ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const /// \brief AST_POLYMORPHIC_MATCHER_P(DefineMatcher, ParamType, Param) { ... } /// defines a single-parameter function named DefineMatcher() that is @@ -241,33 +271,39 @@ namespace internal { \ template <typename NodeType, typename ParamT> \ class matcher_##DefineMatcher##OverloadId##Matcher \ - : public MatcherInterface<NodeType> { \ + : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \ public: \ explicit matcher_##DefineMatcher##OverloadId##Matcher( \ ParamType const &A##Param) \ : Param(A##Param) {} \ - bool matches(const NodeType &Node, ASTMatchFinder *Finder, \ - BoundNodesTreeBuilder *Builder) const override; \ + bool matches(const NodeType &Node, \ + ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ + ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ + *Builder) const override; \ \ private: \ ParamType const Param; \ }; \ } \ - inline internal::PolymorphicMatcherWithParam1< \ + inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \ - ReturnTypesF> DefineMatcher(ParamType const &Param) { \ - return internal::PolymorphicMatcherWithParam1< \ + ReturnTypesF> \ + DefineMatcher(ParamType const &Param) { \ + return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \ ReturnTypesF>(Param); \ } \ - typedef internal::PolymorphicMatcherWithParam1< \ + typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \ ReturnTypesF>(&DefineMatcher##_Type##OverloadId)( \ ParamType const &Param); \ template <typename NodeType, typename ParamT> \ - bool internal::matcher_##DefineMatcher##OverloadId##Matcher< \ - NodeType, ParamT>::matches(const NodeType &Node, ASTMatchFinder *Finder, \ - BoundNodesTreeBuilder *Builder) const + bool internal:: \ + matcher_##DefineMatcher##OverloadId##Matcher<NodeType, ParamT>::matches( \ + const NodeType &Node, \ + ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ + ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) \ + const /// \brief AST_POLYMORPHIC_MATCHER_P2( /// DefineMatcher, ParamType1, Param1, ParamType2, Param2) { ... } @@ -288,41 +324,46 @@ namespace internal { \ template <typename NodeType, typename ParamT1, typename ParamT2> \ class matcher_##DefineMatcher##OverloadId##Matcher \ - : public MatcherInterface<NodeType> { \ + : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \ public: \ matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 const &A##Param1, \ ParamType2 const &A##Param2) \ : Param1(A##Param1), Param2(A##Param2) {} \ - bool matches(const NodeType &Node, ASTMatchFinder *Finder, \ - BoundNodesTreeBuilder *Builder) const override; \ + bool matches(const NodeType &Node, \ + ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ + ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ + *Builder) const override; \ \ private: \ ParamType1 const Param1; \ ParamType2 const Param2; \ }; \ } \ - inline internal::PolymorphicMatcherWithParam2< \ + inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam2< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \ - ParamType2, ReturnTypesF> DefineMatcher(ParamType1 const &Param1, \ - ParamType2 const &Param2) { \ - return internal::PolymorphicMatcherWithParam2< \ + ParamType2, ReturnTypesF> \ + DefineMatcher(ParamType1 const &Param1, ParamType2 const &Param2) { \ + return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam2< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \ ParamType2, ReturnTypesF>(Param1, Param2); \ } \ - typedef internal::PolymorphicMatcherWithParam2< \ + typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParam2< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \ ParamType2, ReturnTypesF>(&DefineMatcher##_Type##OverloadId)( \ ParamType1 const &Param1, ParamType2 const &Param2); \ template <typename NodeType, typename ParamT1, typename ParamT2> \ bool internal::matcher_##DefineMatcher##OverloadId##Matcher< \ - NodeType, ParamT1, ParamT2>::matches( \ - const NodeType &Node, ASTMatchFinder *Finder, \ - BoundNodesTreeBuilder *Builder) const + NodeType, ParamT1, ParamT2>:: \ + matches(const NodeType &Node, \ + ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ + ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) \ + const /// \brief Creates a variadic matcher for both a specific \c Type as well as /// the corresponding \c TypeLoc. #define AST_TYPE_MATCHER(NodeType, MatcherName) \ - const internal::VariadicDynCastAllOfMatcher<Type, NodeType> MatcherName + const ::clang::ast_matchers::internal::VariadicDynCastAllOfMatcher< \ + Type, NodeType> MatcherName // FIXME: add a matcher for TypeLoc derived classes using its custom casting // API (no longer dyn_cast) if/when we need such matching @@ -330,7 +371,7 @@ /// the matcher \c MatcherName that can be used to traverse from one \c Type /// to another. /// -/// For a specific \c SpecificType, the traversal is done using +/// For a specific \c SpecificType, the traversal is done using /// \c SpecificType::FunctionName. The existence of such a function determines /// whether a corresponding matcher can be used on \c SpecificType. #define AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName, ReturnTypesF) \ @@ -339,9 +380,11 @@ static QualType (T::*value())() const { return &T::FunctionName; } \ }; \ } \ - const internal::TypeTraversePolymorphicMatcher< \ - QualType, internal::TypeMatcher##MatcherName##Getter, \ - internal::TypeTraverseMatcher, ReturnTypesF>::Func MatcherName + const ::clang::ast_matchers::internal::TypeTraversePolymorphicMatcher< \ + QualType, \ + ::clang::ast_matchers::internal::TypeMatcher##MatcherName##Getter, \ + ::clang::ast_matchers::internal::TypeTraverseMatcher, \ + ReturnTypesF>::Func MatcherName /// \brief AST_TYPELOC_TRAVERSE_MATCHER(MatcherName, FunctionName) works /// identical to \c AST_TYPE_TRAVERSE_MATCHER but operates on \c TypeLocs. @@ -351,9 +394,11 @@ static TypeLoc (T::*value())() const { return &T::FunctionName##Loc; } \ }; \ } \ - const internal::TypeTraversePolymorphicMatcher< \ - TypeLoc, internal::TypeLocMatcher##MatcherName##Getter, \ - internal::TypeLocTraverseMatcher, ReturnTypesF>::Func MatcherName##Loc; \ + const ::clang::ast_matchers::internal::TypeTraversePolymorphicMatcher< \ + TypeLoc, \ + ::clang::ast_matchers::internal::TypeLocMatcher##MatcherName##Getter, \ + ::clang::ast_matchers::internal::TypeLocTraverseMatcher, \ + ReturnTypesF>::Func MatcherName##Loc; \ AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName##Type, ReturnTypesF) #endif diff --git a/include/clang/Basic/Attr.td b/include/clang/Basic/Attr.td index c310d25a5518..f36f654ff630 100644 --- a/include/clang/Basic/Attr.td +++ b/include/clang/Basic/Attr.td @@ -195,7 +195,8 @@ class CXX11<string namespace, string name, int version = 1> : Spelling<name, "CXX11"> { string Namespace = namespace; int Version = version; -} class Keyword<string name> : Spelling<name, "Keyword">; +} +class Keyword<string name> : Spelling<name, "Keyword">; class Pragma<string namespace, string name> : Spelling<name, "Pragma"> { string Namespace = namespace; } @@ -959,6 +960,22 @@ def ReturnsNonNull : InheritableAttr { let Documentation = [Undocumented]; } +// Nullability type attributes. +def TypeNonNull : TypeAttr { + let Spellings = [Keyword<"__nonnull">]; + let Documentation = [Undocumented]; +} + +def TypeNullable : TypeAttr { + let Spellings = [Keyword<"__nullable">]; + let Documentation = [Undocumented]; +} + +def TypeNullUnspecified : TypeAttr { + let Spellings = [Keyword<"__null_unspecified">]; + let Documentation = [Undocumented]; +} + def AssumeAligned : InheritableAttr { let Spellings = [GCC<"assume_aligned">]; let Subjects = SubjectList<[ObjCMethod, Function]>; @@ -1250,6 +1267,14 @@ def Pascal : InheritableAttr { let Documentation = [Undocumented]; } +def Target : InheritableAttr { + let Spellings = [GCC<"target">]; + let Args = [StringArgument<"features">]; + let Subjects = + SubjectList<[Function], ErrorDiag, "ExpectedFunctionMethodOrClass">; + let Documentation = [Undocumented]; +} + def TransparentUnion : InheritableAttr { let Spellings = [GCC<"transparent_union">]; // let Subjects = SubjectList<[Record, TypedefName]>; @@ -1935,8 +1960,8 @@ def LoopHint : Attr { ["Vectorize", "VectorizeWidth", "Interleave", "InterleaveCount", "Unroll", "UnrollCount"]>, EnumArgument<"State", "LoopHintState", - ["default", "enable", "disable"], - ["Default", "Enable", "Disable"]>, + ["default", "enable", "disable", "assume_safety"], + ["Default", "Enable", "Disable", "AssumeSafety"]>, ExprArgument<"Value">]; let AdditionalMembers = [{ @@ -1982,6 +2007,8 @@ def LoopHint : Attr { return ""; else if (state == Enable) OS << (option == Unroll ? "full" : "enable"); + else if (state == AssumeSafety) + OS << "assume_safety"; else OS << "disable"; OS << ")"; diff --git a/include/clang/Basic/Builtins.def b/include/clang/Basic/Builtins.def index 192790749be8..bf65b5fa2ea8 100644 --- a/include/clang/Basic/Builtins.def +++ b/include/clang/Basic/Builtins.def @@ -1240,6 +1240,10 @@ BUILTIN(__builtin_addressof, "v*v&", "nct") BUILTIN(__builtin_operator_new, "v*z", "c") BUILTIN(__builtin_operator_delete, "vv*", "n") +// Safestack builtins +BUILTIN(__builtin___get_unsafe_stack_start, "v*", "Fn") +BUILTIN(__builtin___get_unsafe_stack_ptr, "v*", "Fn") + #undef BUILTIN #undef LIBBUILTIN #undef LANGBUILTIN diff --git a/include/clang/Basic/BuiltinsAArch64.def b/include/clang/Basic/BuiltinsAArch64.def index 9d223c3e8516..1db4c1471029 100644 --- a/include/clang/Basic/BuiltinsAArch64.def +++ b/include/clang/Basic/BuiltinsAArch64.def @@ -53,4 +53,12 @@ BUILTIN(__builtin_arm_isb, "vUi", "nc") // Prefetch BUILTIN(__builtin_arm_prefetch, "vvC*UiUiUiUi", "nc") +// System Registers +BUILTIN(__builtin_arm_rsr, "UicC*", "nc") +BUILTIN(__builtin_arm_rsr64, "LUicC*", "nc") +BUILTIN(__builtin_arm_rsrp, "v*cC*", "nc") +BUILTIN(__builtin_arm_wsr, "vcC*Ui", "nc") +BUILTIN(__builtin_arm_wsr64, "vcC*LUi", "nc") +BUILTIN(__builtin_arm_wsrp, "vcC*vC*", "nc") + #undef BUILTIN diff --git a/include/clang/Basic/BuiltinsR600.def b/include/clang/Basic/BuiltinsAMDGPU.def index 84fc4fae4eab..bb9931f7a206 100644 --- a/include/clang/Basic/BuiltinsR600.def +++ b/include/clang/Basic/BuiltinsAMDGPU.def @@ -1,4 +1,4 @@ -//==- BuiltinsR600.def - R600 Builtin function database ----------*- C++ -*-==// +//==- BuiltinsAMDGPU.def - AMDGPU Builtin function database ------*- C++ -*-==// // // The LLVM Compiler Infrastructure // diff --git a/include/clang/Basic/BuiltinsARM.def b/include/clang/Basic/BuiltinsARM.def index 98d5ab73aa38..0610d47f8ba1 100644 --- a/include/clang/Basic/BuiltinsARM.def +++ b/include/clang/Basic/BuiltinsARM.def @@ -84,6 +84,14 @@ BUILTIN(__builtin_arm_isb, "vUi", "nc") // Prefetch BUILTIN(__builtin_arm_prefetch, "vvC*UiUi", "nc") +// System registers (ACLE) +BUILTIN(__builtin_arm_rsr, "UicC*", "nc") +BUILTIN(__builtin_arm_rsr64, "LLUicC*", "nc") +BUILTIN(__builtin_arm_rsrp, "v*cC*", "nc") +BUILTIN(__builtin_arm_wsr, "vcC*Ui", "nc") +BUILTIN(__builtin_arm_wsr64, "vcC*LLUi", "nc") +BUILTIN(__builtin_arm_wsrp, "vcC*vC*", "nc") + // MSVC LANGBUILTIN(__emit, "vIUiC", "", ALL_MS_LANGUAGES) diff --git a/include/clang/Basic/BuiltinsPPC.def b/include/clang/Basic/BuiltinsPPC.def index 57ae63e634f4..6f3bea887f59 100644 --- a/include/clang/Basic/BuiltinsPPC.def +++ b/include/clang/Basic/BuiltinsPPC.def @@ -231,6 +231,9 @@ BUILTIN(__builtin_altivec_vcmpgtsd_p, "iiV2LLiV2LLi", "") BUILTIN(__builtin_altivec_vcmpgtud_p, "iiV2ULLiV2ULLi", "") BUILTIN(__builtin_altivec_vcmpgtfp_p, "iiV4fV4f", "") +BUILTIN(__builtin_altivec_vgbbd, "V16UcV16Uc", "") +BUILTIN(__builtin_altivec_vbpermq, "V2ULLiV16UcV16Uc", "") + // P8 Crypto built-ins. BUILTIN(__builtin_altivec_crypto_vsbox, "V2ULLiV2ULLi", "") BUILTIN(__builtin_altivec_crypto_vpermxor, "V16UcV16UcV16UcV16Uc", "") diff --git a/include/clang/Basic/BuiltinsX86.def b/include/clang/Basic/BuiltinsX86.def index 1a597b5c27d4..00c1340ac37f 100644 --- a/include/clang/Basic/BuiltinsX86.def +++ b/include/clang/Basic/BuiltinsX86.def @@ -59,6 +59,9 @@ BUILTIN(__builtin_ia32_pswapdsi, "V2iV2i", "nc") // All MMX instructions will be generated via builtins. Any MMX vector // types (<1 x i64>, <2 x i32>, etc.) that aren't used by these builtins will be // expanded by the back-end. +// FIXME: _mm_prefetch must be a built-in because it takes a compile-time constant +// argument and our prior approach of using a #define to the current built-in +// doesn't work in the presence of re-declaration of _mm_prefetch for windows. BUILTIN(_mm_prefetch, "vcC*i", "nc") BUILTIN(__builtin_ia32_emms, "v", "") BUILTIN(__builtin_ia32_paddb, "V8cV8cV8c", "") diff --git a/include/clang/Basic/DiagnosticCommonKinds.td b/include/clang/Basic/DiagnosticCommonKinds.td index deb23f3149cb..82718d9255f3 100644 --- a/include/clang/Basic/DiagnosticCommonKinds.td +++ b/include/clang/Basic/DiagnosticCommonKinds.td @@ -99,6 +99,37 @@ def err_enum_template : Error<"enumeration cannot be a template">; } +let CategoryName = "Nullability Issue" in { + +def warn_nullability_duplicate : Warning< + "duplicate nullability specifier " + "'%select{__|}1%select{nonnull|nullable|null_unspecified}0'">, + InGroup<Nullability>; + +def warn_conflicting_nullability_attr_overriding_ret_types : Warning< + "conflicting nullability specifier on return types, " + "'%select{%select{__|}1nonnull|" + "%select{__|}1nullable|%select{__|}1null_unspecified}0' " + "conflicts with existing specifier '%select{%select{__|}3nonnull|" + "%select{__|}3nullable|%select{__|}3null_unspecified}2'">, + InGroup<Nullability>; + +def warn_conflicting_nullability_attr_overriding_param_types : Warning< + "conflicting nullability specifier on parameter types, " + "'%select{%select{__|}1nonnull|" + "%select{__|}1nullable|%select{__|}1null_unspecified}0' " + "conflicts with existing specifier '%select{%select{__|}3nonnull|" + "%select{__|}3nullable|%select{__|}3null_unspecified}2'">, + InGroup<Nullability>; + +def err_nullability_conflicting : Error< + "nullability specifier " + "'%select{__|}1%select{nonnull|nullable|null_unspecified}0' conflicts with " + "existing specifier '%select{__|}3%select{nonnull|nullable|" + "null_unspecified}2'">; + +} + // Sema && Lex def ext_c99_longlong : Extension< "'long long' is an extension when C99 mode is not enabled">, diff --git a/include/clang/Basic/DiagnosticGroups.td b/include/clang/Basic/DiagnosticGroups.td index 016c2e198e3a..85796cc0d325 100644 --- a/include/clang/Basic/DiagnosticGroups.td +++ b/include/clang/Basic/DiagnosticGroups.td @@ -248,6 +248,10 @@ def MissingFieldInitializers : DiagGroup<"missing-field-initializers">; def ModuleBuild : DiagGroup<"module-build">; def ModuleConflict : DiagGroup<"module-conflict">; def NewlineEOF : DiagGroup<"newline-eof">; +def Nullability : DiagGroup<"nullability">; +def NullabilityDeclSpec : DiagGroup<"nullability-declspec">; +def NullableToNonNullConversion : DiagGroup<"nullable-to-nonnull-conversion">; +def NullabilityCompleteness : DiagGroup<"nullability-completeness">; def NullArithmetic : DiagGroup<"null-arithmetic">; def NullCharacter : DiagGroup<"null-character">; def NullDereference : DiagGroup<"null-dereference">; @@ -598,6 +602,7 @@ def Most : DiagGroup<"most", [ DeleteNonVirtualDtor, Format, Implicit, + InfiniteRecursion, MismatchedTags, MissingBraces, Move, diff --git a/include/clang/Basic/DiagnosticLexKinds.td b/include/clang/Basic/DiagnosticLexKinds.td index 3d568e84a9a6..5dd4ae0ac7fd 100644 --- a/include/clang/Basic/DiagnosticLexKinds.td +++ b/include/clang/Basic/DiagnosticLexKinds.td @@ -646,5 +646,20 @@ def warn_header_guard : Warning< "%0 is used as a header guard here, followed by #define of a different macro">, InGroup<DiagGroup<"header-guard">>; def note_header_guard : Note< - "%0 is defined here; did you mean %1?">; + "%0 is defined here; did you mean %1?">; + +let CategoryName = "Nullability Issue" in { + +def err_pp_assume_nonnull_syntax : Error<"expected 'begin' or 'end'">; +def err_pp_double_begin_of_assume_nonnull : Error< + "already inside '#pragma clang assume_nonnull'">; +def err_pp_unmatched_end_of_assume_nonnull : Error< + "not currently inside '#pragma clang assume_nonnull'">; +def err_pp_include_in_assume_nonnull : Error< + "cannot #include files inside '#pragma clang assume_nonnull'">; +def err_pp_eof_in_assume_nonnull : Error< + "'#pragma clang assume_nonnull' was not ended within this file">; + +} + } diff --git a/include/clang/Basic/DiagnosticOptions.def b/include/clang/Basic/DiagnosticOptions.def index fdd325446e27..f4ba6da81fe0 100644 --- a/include/clang/Basic/DiagnosticOptions.def +++ b/include/clang/Basic/DiagnosticOptions.def @@ -69,7 +69,10 @@ ENUM_DIAGOPT(ShowOverloads, OverloadsShown, 1, DIAGOPT(VerifyDiagnostics, 1, 0) /// Check that diagnostics match the expected /// diagnostics, indicated by markers in the /// input source file. - +ENUM_DIAGOPT(VerifyIgnoreUnexpected, DiagnosticLevelMask, 4, + DiagnosticLevelMask::None) /// Ignore unexpected diagnostics of + /// the specified levels when using + /// -verify. DIAGOPT(ElideType, 1, 0) /// Elide identical types in template diffing DIAGOPT(ShowTemplateTree, 1, 0) /// Print a template tree when diffing DIAGOPT(CLFallbackMode, 1, 0) /// Format for clang-cl fallback mode diff --git a/include/clang/Basic/DiagnosticOptions.h b/include/clang/Basic/DiagnosticOptions.h index a16c7747cec3..c9b0c5def992 100644 --- a/include/clang/Basic/DiagnosticOptions.h +++ b/include/clang/Basic/DiagnosticOptions.h @@ -13,6 +13,7 @@ #include "clang/Basic/LLVM.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include <string> +#include <type_traits> #include <vector> namespace clang { @@ -24,6 +25,38 @@ enum OverloadsShown : unsigned { Ovl_Best ///< Show just the "best" overload candidates. }; +/// \brief A bitmask representing the diagnostic levels used by +/// VerifyDiagnosticConsumer. +enum class DiagnosticLevelMask : unsigned { + None = 0, + Note = 1 << 0, + Remark = 1 << 1, + Warning = 1 << 2, + Error = 1 << 3, + All = Note | Remark | Warning | Error +}; + +inline DiagnosticLevelMask operator~(DiagnosticLevelMask M) { + using UT = std::underlying_type<DiagnosticLevelMask>::type; + return static_cast<DiagnosticLevelMask>(~static_cast<UT>(M)); +} + +inline DiagnosticLevelMask operator|(DiagnosticLevelMask LHS, + DiagnosticLevelMask RHS) { + using UT = std::underlying_type<DiagnosticLevelMask>::type; + return static_cast<DiagnosticLevelMask>( + static_cast<UT>(LHS) | static_cast<UT>(RHS)); +} + +inline DiagnosticLevelMask operator&(DiagnosticLevelMask LHS, + DiagnosticLevelMask RHS) { + using UT = std::underlying_type<DiagnosticLevelMask>::type; + return static_cast<DiagnosticLevelMask>( + static_cast<UT>(LHS) & static_cast<UT>(RHS)); +} + +raw_ostream& operator<<(raw_ostream& Out, DiagnosticLevelMask M); + /// \brief Options for controlling the compiler diagnostics engine. class DiagnosticOptions : public RefCountedBase<DiagnosticOptions>{ public: diff --git a/include/clang/Basic/DiagnosticParseKinds.td b/include/clang/Basic/DiagnosticParseKinds.td index f00a3b39d23b..6a11d240c63c 100644 --- a/include/clang/Basic/DiagnosticParseKinds.td +++ b/include/clang/Basic/DiagnosticParseKinds.td @@ -65,6 +65,10 @@ def ext_keyword_as_ident : ExtWarn< "%select{here|for the remainder of the translation unit}1">, InGroup<KeywordCompat>; +def ext_nullability : Extension< + "type nullability specifier %0 is a Clang extension">, + InGroup<DiagGroup<"nullability-extension">>; + def error_empty_enum : Error<"use of empty enum">; def err_invalid_sign_spec : Error<"'%0' cannot be signed or unsigned">; def err_invalid_short_spec : Error<"'short %0' is invalid">; @@ -989,17 +993,21 @@ def err_omp_expected_identifier_for_critical : Error< // Pragma loop support. def err_pragma_loop_missing_argument : Error< "missing argument; expected %select{an integer value|" - "'%select{enable|full}1' or 'disable'}0">; + "%select{'enable', 'assume_safety'|'full'}1 or 'disable'}0">; def err_pragma_loop_invalid_option : Error< "%select{invalid|missing}0 option%select{ %1|}0; expected vectorize, " "vectorize_width, interleave, interleave_count, unroll, or unroll_count">; def err_pragma_invalid_keyword : Error< - "invalid argument; expected '%select{enable|full}0' or 'disable'">; + "invalid argument; expected %select{'enable', 'assume_safety'|'full'}0 or 'disable'">; // Pragma unroll support. def warn_pragma_unroll_cuda_value_in_parens : Warning< "argument to '#pragma unroll' should not be in parentheses in CUDA C/C++">, InGroup<CudaCompat>; + +def err_empty_attribute_block : Error< + "Microsoft attribute block cannot be empty">; + } // end of Parse Issue category. let CategoryName = "Modules Issue" in { diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index be1911e7d506..803203cc50be 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -108,6 +108,7 @@ def err_ice_ambiguous_conversion : Error< def err_ice_too_large : Error< "integer constant expression evaluates to value %0 that cannot be " "represented in a %1-bit %select{signed|unsigned}2 integer type">; +def err_expr_not_string_literal : Error<"expression is not a string literal">; // Semantic analysis of constant literals. def ext_predef_outside_function : Warning< @@ -424,6 +425,7 @@ def warn_redecl_library_builtin : Warning< "incompatible redeclaration of library function %0">, InGroup<DiagGroup<"incompatible-library-redeclaration">>; def err_builtin_definition : Error<"definition of builtin function %0">; +def err_arm_invalid_specialreg : Error<"invalid special register for builtin">; def warn_builtin_unknown : Warning<"use of unknown builtin %0">, InGroup<ImplicitFunctionDeclare>, DefaultError; def warn_dyn_class_memaccess : Warning< @@ -1974,8 +1976,11 @@ def err_attribute_too_few_arguments : Error< def err_attribute_invalid_vector_type : Error<"invalid vector element type %0">; def err_attribute_bad_neon_vector_size : Error< "Neon vector size must be 64 or 128 bits">; -def err_attribute_unsupported : Error< - "%0 attribute is not supported for this target">; +def warn_unsupported_target_attribute + : Warning<"Ignoring unsupported '%0' in the target attribute string">, + InGroup<IgnoredAttributes>; +def err_attribute_unsupported + : Error<"%0 attribute is not supported for this target">; // The err_*_attribute_argument_not_int are seperate because they're used by // VerifyIntegerConstantExpression. def err_aligned_attribute_argument_not_int : Error< @@ -2249,7 +2254,7 @@ def warn_attribute_dllimport_static_field_definition : Warning< InGroup<DiagGroup<"dllimport-static-field-def">>; def warn_attribute_dllexport_explicit_instantiation_decl : Warning< "explicit instantiation declaration should not be 'dllexport'">, - InGroup<DiagGroup<"dllexport-explicit-instantation-decl">>; + InGroup<DiagGroup<"dllexport-explicit-instantiation-decl">>; def warn_invalid_initializer_from_system_header : Warning< "invalid constructor form class in system header, should not be explicit">, InGroup<DiagGroup<"invalid-initializer-from-system-header">>; @@ -2680,6 +2685,8 @@ def err_mode_not_primitive : Error< "mode attribute only supported for integer and floating-point types">; def err_mode_wrong_type : Error< "type of machine mode does not match type of base type">; +def err_complex_mode_vector_type : Error< + "type of machine mode does not support base vector types">; def err_attr_wrong_decl : Error< "%0 attribute invalid on this declaration, requires typedef or value">; def warn_attribute_nonnull_no_pointers : Warning< @@ -2744,8 +2751,8 @@ def warn_ns_attribute_wrong_return_type : Warning< "return %select{an Objective-C object|a pointer|a non-retainable pointer}2">, InGroup<IgnoredAttributes>; def warn_ns_attribute_wrong_parameter_type : Warning< - "%0 attribute only applies to %select{Objective-C object|pointer}1 " - "parameters">, + "%0 attribute only applies to " + "%select{Objective-C object|pointer|pointer-to-CF-pointer}1 parameters">, InGroup<IgnoredAttributes>; def warn_objc_requires_super_protocol : Warning< "%0 attribute cannot be applied to %select{methods in protocols|dealloc}1">, @@ -7631,10 +7638,12 @@ def err_module_private_local : Error< def err_module_private_local_class : Error< "local %select{struct|interface|union|class|enum}0 cannot be declared " "__module_private__">; -def err_module_private_declaration : Error< - "declaration of %0 must be imported from module '%1' before it is required">; -def err_module_private_definition : Error< - "definition of %0 must be imported from module '%1' before it is required">; +def err_module_unimported_use : Error< + "%select{declaration|definition|default argument}0 of %1 must be imported " + "from module '%2' before it is required">; +def err_module_unimported_use_multiple : Error< + "%select{declaration|definition|default argument}0 of %1 must be imported " + "from one of the following modules before it is required:%2">; def err_module_import_in_extern_c : Error< "import of C++ module '%0' appears within extern \"C\" language linkage " "specification">; @@ -7665,4 +7674,55 @@ def warn_profile_data_unprofiled : Warning< } // end of instrumentation issue category +let CategoryName = "Nullability Issue" in { + +def warn_mismatched_nullability_attr : Warning< + "nullability specifier " + "'%select{__|}1%select{nonnull|nullable|null_unspecified}0' " + "conflicts with existing specifier " + "'%select{__|}3%select{nonnull|nullable|null_unspecified}2'">, + InGroup<Nullability>; + +def warn_nullability_declspec : Warning< + "nullability specifier " + "'%select{__nonnull|__nullable|__null_unspecified}0' cannot be applied " + "to non-pointer type %1; did you mean to apply the specifier to the " + "%select{pointer|block pointer|member pointer|function pointer|" + "member function pointer}2?">, + InGroup<NullabilityDeclSpec>, + DefaultError; + +def note_nullability_here : Note< + "'%select{__nonnull|__nullable|__null_unspecified}0' specified here">; + +def err_nullability_nonpointer : Error< + "nullability specifier " + "'%select{__|}1%select{nonnull|nullable|null_unspecified}0' cannot be applied " + "to non-pointer type %2">; + +def warn_nullability_lost : Warning< + "implicit conversion from nullable pointer %0 to non-nullable pointer " + "type %1">, + InGroup<NullableToNonNullConversion>, DefaultIgnore; + +def err_nullability_cs_multilevel : Error< + "nullability keyword " + "'%select{nonnull|nullable|null_unspecified}0' cannot be applied to " + "multi-level pointer type %1">; +def note_nullability_type_specifier : Note< + "use nullability type specifier " + "'%select{__nonnull|__nullable|__null_unspecified}0' to affect the innermost " + "pointer type of %1">; + +def warn_null_resettable_setter : Warning< + "synthesized setter %0 for null_resettable property %1 does not handle nil">, + InGroup<Nullability>; + +def warn_nullability_missing : Warning< + "%select{pointer|block pointer|member pointer}0 is missing a nullability " + "type specifier (__nonnull, __nullable, or __null_unspecified)">, + InGroup<NullabilityCompleteness>; + +} + } // end of sema component. diff --git a/include/clang/Basic/FileManager.h b/include/clang/Basic/FileManager.h index 37e19e1e279d..ac0d7a15e568 100644 --- a/include/clang/Basic/FileManager.h +++ b/include/clang/Basic/FileManager.h @@ -25,16 +25,8 @@ #include "llvm/ADT/StringRef.h" #include "llvm/Support/Allocator.h" #include <memory> -// FIXME: Enhance libsystem to support inode and other fields in stat. -#include <sys/types.h> #include <map> -#ifdef _MSC_VER -typedef unsigned short mode_t; -#endif - -struct stat; - namespace llvm { class MemoryBuffer; } diff --git a/include/clang/Basic/LangOptions.def b/include/clang/Basic/LangOptions.def index 95d3f0682abd..bef122f093c4 100644 --- a/include/clang/Basic/LangOptions.def +++ b/include/clang/Basic/LangOptions.def @@ -127,8 +127,7 @@ LANGOPT(Modules , 1, 0, "modules extension to C") COMPATIBLE_LANGOPT(ModulesDeclUse , 1, 0, "require declaration of module uses") LANGOPT(ModulesSearchAll , 1, 1, "search even non-imported modules to find unresolved references") COMPATIBLE_LANGOPT(ModulesStrictDeclUse, 1, 0, "require declaration of module uses and all headers to be in modules") -LANGOPT(ModulesErrorRecovery, 1, 1, "automatically import modules as needed when performing error recovery") -BENIGN_LANGOPT(ModulesImplicitMaps, 1, 1, "use files called module.modulemap implicitly as module maps") +BENIGN_LANGOPT(ModulesErrorRecovery, 1, 1, "automatically import modules as needed when performing error recovery") BENIGN_LANGOPT(ImplicitModules, 1, 1, "build modules that are not specified via -fmodule-file") COMPATIBLE_LANGOPT(ModulesLocalVisibility, 1, 0, "local submodule visibility") COMPATIBLE_LANGOPT(Optimize , 1, 0, "__OPTIMIZE__ predefined macro") diff --git a/include/clang/Basic/OpenMPKinds.def b/include/clang/Basic/OpenMPKinds.def index 0145db059329..b09f012c4317 100644 --- a/include/clang/Basic/OpenMPKinds.def +++ b/include/clang/Basic/OpenMPKinds.def @@ -84,6 +84,7 @@ OPENMP_DIRECTIVE(critical) OPENMP_DIRECTIVE(taskyield) OPENMP_DIRECTIVE(barrier) OPENMP_DIRECTIVE(taskwait) +OPENMP_DIRECTIVE(taskgroup) OPENMP_DIRECTIVE(flush) OPENMP_DIRECTIVE(ordered) OPENMP_DIRECTIVE(atomic) diff --git a/include/clang/Basic/Sanitizers.def b/include/clang/Basic/Sanitizers.def index 65ababd5ac86..1b528c8d6f69 100644 --- a/include/clang/Basic/Sanitizers.def +++ b/include/clang/Basic/Sanitizers.def @@ -41,6 +41,9 @@ // AddressSanitizer SANITIZER("address", Address) +// Kernel AddressSanitizer (KASan) +SANITIZER("kernel-address", KernelAddress) + // MemorySanitizer SANITIZER("memory", Memory) @@ -87,18 +90,20 @@ SANITIZER("cfi-vcall", CFIVCall) SANITIZER_GROUP("cfi", CFI, CFIDerivedCast | CFIUnrelatedCast | CFINVCall | CFIVCall) -// -fsanitize=undefined-trap includes sanitizers from -fsanitize=undefined -// that can be used without runtime support, generally by providing extra -// -fsanitize-undefined-trap-on-error flag. -SANITIZER_GROUP("undefined-trap", UndefinedTrap, +// Safe Stack +SANITIZER("safe-stack", SafeStack) + +// -fsanitize=undefined includes all the sanitizers which have low overhead, no +// ABI or address space layout implications, and only catch undefined behavior. +SANITIZER_GROUP("undefined", Undefined, Alignment | Bool | ArrayBounds | Enum | FloatCastOverflow | FloatDivideByZero | IntegerDivideByZero | NonnullAttribute | Null | ObjectSize | Return | ReturnsNonnullAttribute | - Shift | SignedIntegerOverflow | Unreachable | VLABound) + Shift | SignedIntegerOverflow | Unreachable | VLABound | + Function | Vptr) -// -fsanitize=undefined includes all the sanitizers which have low overhead, no -// ABI or address space layout implications, and only catch undefined behavior. -SANITIZER_GROUP("undefined", Undefined, UndefinedTrap | Function | Vptr) +// -fsanitize=undefined-trap is an alias for -fsanitize=undefined. +SANITIZER_GROUP("undefined-trap", UndefinedTrap, Undefined) SANITIZER_GROUP("integer", Integer, SignedIntegerOverflow | UnsignedIntegerOverflow | Shift | diff --git a/include/clang/Basic/Sanitizers.h b/include/clang/Basic/Sanitizers.h index 3b1797e9f539..78c1ddb56f9b 100644 --- a/include/clang/Basic/Sanitizers.h +++ b/include/clang/Basic/Sanitizers.h @@ -52,6 +52,9 @@ struct SanitizerSet { /// \brief Check if a certain (single) sanitizer is enabled. bool has(SanitizerMask K) const; + /// \brief Check if one or more sanitizers are enabled. + bool hasOneOf(SanitizerMask K) const; + /// \brief Enable or disable a certain (single) sanitizer. void set(SanitizerMask K, bool Value); diff --git a/include/clang/Basic/Specifiers.h b/include/clang/Basic/Specifiers.h index 7569c16412b2..5ce56c0ee1f8 100644 --- a/include/clang/Basic/Specifiers.h +++ b/include/clang/Basic/Specifiers.h @@ -16,6 +16,9 @@ #ifndef LLVM_CLANG_BASIC_SPECIFIERS_H #define LLVM_CLANG_BASIC_SPECIFIERS_H +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/DataTypes.h" + namespace clang { /// \brief Specifies the width of a type, e.g., short, long, or long long. enum TypeSpecifierWidth { @@ -239,6 +242,22 @@ namespace clang { SD_Static, ///< Static storage duration. SD_Dynamic ///< Dynamic storage duration. }; + + /// Describes the nullability of a particular type. + enum class NullabilityKind : uint8_t { + /// Values of this type can never be null. + NonNull = 0, + /// Values of this type can be null. + Nullable, + /// Whether values of this type can be null is (explicitly) + /// unspecified. This captures a (fairly rare) case where we + /// can't conclude anything about the nullability of the type even + /// though it has been considered. + Unspecified + }; + + /// Retrieve the spelling of the given nullability kind. + llvm::StringRef getNullabilitySpelling(NullabilityKind kind); } // end namespace clang #endif // LLVM_CLANG_BASIC_SPECIFIERS_H diff --git a/include/clang/Basic/StmtNodes.td b/include/clang/Basic/StmtNodes.td index 750108f39f9a..675e91d866d0 100644 --- a/include/clang/Basic/StmtNodes.td +++ b/include/clang/Basic/StmtNodes.td @@ -77,7 +77,9 @@ def CompoundLiteralExpr : DStmt<Expr>; def ExtVectorElementExpr : DStmt<Expr>; def InitListExpr : DStmt<Expr>; def DesignatedInitExpr : DStmt<Expr>; +def DesignatedInitUpdateExpr : DStmt<Expr>; def ImplicitValueInitExpr : DStmt<Expr>; +def NoInitExpr : DStmt<Expr>; def ParenListExpr : DStmt<Expr>; def VAArgExpr : DStmt<Expr>; def GenericSelectionExpr : DStmt<Expr>; @@ -197,6 +199,7 @@ def OMPTaskDirective : DStmt<OMPExecutableDirective>; def OMPTaskyieldDirective : DStmt<OMPExecutableDirective>; def OMPBarrierDirective : DStmt<OMPExecutableDirective>; def OMPTaskwaitDirective : DStmt<OMPExecutableDirective>; +def OMPTaskgroupDirective : DStmt<OMPExecutableDirective>; def OMPFlushDirective : DStmt<OMPExecutableDirective>; def OMPOrderedDirective : DStmt<OMPExecutableDirective>; def OMPAtomicDirective : DStmt<OMPExecutableDirective>; diff --git a/include/clang/Basic/TargetBuiltins.h b/include/clang/Basic/TargetBuiltins.h index eece4e8de13c..b4740c595226 100644 --- a/include/clang/Basic/TargetBuiltins.h +++ b/include/clang/Basic/TargetBuiltins.h @@ -73,12 +73,12 @@ namespace clang { }; } - /// \brief R600 builtins - namespace R600 { + /// \brief AMDGPU builtins + namespace AMDGPU { enum { LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1, #define BUILTIN(ID, TYPE, ATTRS) BI##ID, - #include "clang/Basic/BuiltinsR600.def" + #include "clang/Basic/BuiltinsAMDGPU.def" LastTSBuiltin }; } diff --git a/include/clang/Basic/TargetInfo.h b/include/clang/Basic/TargetInfo.h index 8406205c7fd9..e415733189ab 100644 --- a/include/clang/Basic/TargetInfo.h +++ b/include/clang/Basic/TargetInfo.h @@ -363,6 +363,10 @@ public: return *LongDoubleFormat; } + /// \brief Return true if the 'long double' type should be mangled like + /// __float128. + virtual bool useFloat128ManglingForLongDouble() const { return false; } + /// \brief Return the value for the C99 FLT_EVAL_METHOD macro. virtual unsigned getFloatEvalMethod() const { return 0; } diff --git a/include/clang/Basic/TargetOptions.h b/include/clang/Basic/TargetOptions.h index 97825394202f..ca0cca78bfc8 100644 --- a/include/clang/Basic/TargetOptions.h +++ b/include/clang/Basic/TargetOptions.h @@ -45,6 +45,8 @@ public: /// The list of target specific features to enable or disable -- this should /// be a list of strings starting with by '+' or '-'. std::vector<std::string> Features; + + std::vector<std::string> Reciprocals; }; } // end namespace clang diff --git a/include/clang/Basic/TokenKinds.def b/include/clang/Basic/TokenKinds.def index b6d983b55245..67b9933562eb 100644 --- a/include/clang/Basic/TokenKinds.def +++ b/include/clang/Basic/TokenKinds.def @@ -548,6 +548,11 @@ ALIAS("__typeof__" , typeof , KEYALL) ALIAS("__volatile" , volatile , KEYALL) ALIAS("__volatile__" , volatile , KEYALL) +// Type nullability. +KEYWORD(__nonnull , KEYALL) +KEYWORD(__nullable , KEYALL) +KEYWORD(__null_unspecified , KEYALL) + // Microsoft extensions which should be disabled in strict conformance mode KEYWORD(__ptr64 , KEYMS) KEYWORD(__ptr32 , KEYMS) diff --git a/include/clang/Basic/arm_neon.td b/include/clang/Basic/arm_neon.td index 933f204bfb52..c6f879513eac 100644 --- a/include/clang/Basic/arm_neon.td +++ b/include/clang/Basic/arm_neon.td @@ -803,6 +803,13 @@ def VREINTERPRET def VFMA : SInst<"vfma", "dddd", "fQf">; //////////////////////////////////////////////////////////////////////////////// +// fp16 vector operations +def SCALAR_HALF_GET_LANE : IOpInst<"vget_lane", "sdi", "h", OP_SCALAR_HALF_GET_LN>; +def SCALAR_HALF_SET_LANE : IOpInst<"vset_lane", "dsdi", "h", OP_SCALAR_HALF_SET_LN>; +def SCALAR_HALF_GET_LANEQ : IOpInst<"vget_lane", "sdi", "Qh", OP_SCALAR_HALF_GET_LNQ>; +def SCALAR_HALF_SET_LANEQ : IOpInst<"vset_lane", "dsdi", "Qh", OP_SCALAR_HALF_SET_LNQ>; + +//////////////////////////////////////////////////////////////////////////////// // AArch64 Intrinsics let ArchGuard = "defined(__aarch64__)" in { @@ -1594,10 +1601,4 @@ def SCALAR_SQRDMULH_LANEQ : SOpInst<"vqrdmulh_laneq", "ssji", "SsSi", OP_SCALAR_ def SCALAR_VDUP_LANE : IInst<"vdup_lane", "sdi", "ScSsSiSlSfSdSUcSUsSUiSUlSPcSPs">; def SCALAR_VDUP_LANEQ : IInst<"vdup_laneq", "sji", "ScSsSiSlSfSdSUcSUsSUiSUlSPcSPs">; - -// FIXME: Rename so it is obvious this only applies to halfs. -def SCALAR_HALF_GET_LANE : IOpInst<"vget_lane", "sdi", "h", OP_SCALAR_HALF_GET_LN>; -def SCALAR_HALF_SET_LANE : IOpInst<"vset_lane", "dsdi", "h", OP_SCALAR_HALF_SET_LN>; -def SCALAR_HALF_GET_LANEQ : IOpInst<"vget_lane", "sdi", "Qh", OP_SCALAR_HALF_GET_LNQ>; -def SCALAR_HALF_SET_LANEQ : IOpInst<"vset_lane", "dsdi", "Qh", OP_SCALAR_HALF_SET_LNQ>; } diff --git a/include/clang/Driver/CC1Options.td b/include/clang/Driver/CC1Options.td index 1622c41fe13a..f2ef71e2f919 100644 --- a/include/clang/Driver/CC1Options.td +++ b/include/clang/Driver/CC1Options.td @@ -301,6 +301,10 @@ def fmessage_length : Separate<["-"], "fmessage-length">, MetaVarName<"<N>">, HelpText<"Format message diagnostics so that they fit within N columns or fewer, when possible.">; def verify : Flag<["-"], "verify">, HelpText<"Verify diagnostic output using comment directives">; +def verify_ignore_unexpected : Flag<["-"], "verify-ignore-unexpected">, + HelpText<"Ignore unexpected diagnostic messages">; +def verify_ignore_unexpected_EQ : CommaJoined<["-"], "verify-ignore-unexpected=">, + HelpText<"Ignore unexpected diagnostic messages">; def Wno_rewrite_macros : Flag<["-"], "Wno-rewrite-macros">, HelpText<"Silence ObjC rewriting warnings">; diff --git a/include/clang/Driver/CLCompatOptions.td b/include/clang/Driver/CLCompatOptions.td index e217cb755f6e..01913be93d56 100644 --- a/include/clang/Driver/CLCompatOptions.td +++ b/include/clang/Driver/CLCompatOptions.td @@ -139,6 +139,8 @@ def _SLASH_wd4005 : CLFlag<"wd4005">, Alias<W_Joined>, AliasArgs<["no-macro-redefined"]>; def _SLASH_wd4996 : CLFlag<"wd4996">, Alias<W_Joined>, AliasArgs<["no-deprecated-declarations"]>; +def _SLASH_wd4910 : CLFlag<"wd4910">, Alias<W_Joined>, + AliasArgs<["no-dllexport-explicit-instantiation-decl"]>; def _SLASH_vd : CLJoined<"vd">, HelpText<"Control vtordisp placement">, Alias<vtordisp_mode_EQ>; def _SLASH_Zc_sizedDealloc : CLFlag<"Zc:sizedDealloc">, @@ -202,7 +204,6 @@ def _SLASH_Fi : CLCompileJoined<"Fi">, def _SLASH_Fo : CLCompileJoined<"Fo">, HelpText<"Set output object file, or directory (ends in / or \\)">, MetaVarName<"<file or directory>">; -def _SLASH_GL : CLFlag<"GL">, Alias<flto>; def _SLASH_LD : CLFlag<"LD">, HelpText<"Create DLL">; def _SLASH_LDd : CLFlag<"LDd">, HelpText<"Create debug DLL">; def _SLASH_link : CLRemainingArgs<"link">, @@ -287,6 +288,7 @@ def _SLASH_G2 : CLFlag<"G2">; def _SLASH_Ge : CLFlag<"Ge">; def _SLASH_Gh : CLFlag<"Gh">; def _SLASH_GH : CLFlag<"GH">; +def _SLASH_GL : CLFlag<"GL">; def _SLASH_GL_ : CLFlag<"GL-">; def _SLASH_Gm : CLFlag<"Gm">; def _SLASH_Gm_ : CLFlag<"Gm-">; diff --git a/include/clang/Driver/Driver.h b/include/clang/Driver/Driver.h index 09521c2bae3f..d7bb1d2283fb 100644 --- a/include/clang/Driver/Driver.h +++ b/include/clang/Driver/Driver.h @@ -91,7 +91,7 @@ public: /// The path to the compiler resource directory. std::string ResourceDir; - /// A prefix directory used to emulated a limited subset of GCC's '-Bprefix' + /// A prefix directory used to emulate a limited subset of GCC's '-Bprefix' /// functionality. /// FIXME: This type of customization should be removed in favor of the /// universal driver when it is ready. @@ -402,7 +402,7 @@ public: /// handle this action. bool ShouldUseClangCompiler(const JobAction &JA) const; - bool IsUsingLTO(const ToolChain &TC, const llvm::opt::ArgList &Args) const; + bool IsUsingLTO(const llvm::opt::ArgList &Args) const; private: /// \brief Retrieves a ToolChain for a particular target triple. diff --git a/include/clang/Driver/Options.td b/include/clang/Driver/Options.td index 7e39a9ae5b22..aae377693551 100644 --- a/include/clang/Driver/Options.td +++ b/include/clang/Driver/Options.td @@ -561,8 +561,13 @@ def fno_sanitize_recover_EQ : CommaJoined<["-"], "fno-sanitize-recover=">, Group<f_clang_Group>, HelpText<"Disable recovery for specified sanitizers">; +def fsanitize_trap_EQ : CommaJoined<["-"], "fsanitize-trap=">, Group<f_clang_Group>, + Flags<[CC1Option, CoreOption]>, + HelpText<"Enable trapping for specified sanitizers">; +def fno_sanitize_trap_EQ : CommaJoined<["-"], "fno-sanitize-trap=">, Group<f_clang_Group>, + HelpText<"Disable trapping for specified sanitizers">; def fsanitize_undefined_trap_on_error : Flag<["-"], "fsanitize-undefined-trap-on-error">, - Group<f_clang_Group>, Flags<[CC1Option]>; + Group<f_clang_Group>; def fno_sanitize_undefined_trap_on_error : Flag<["-"], "fno-sanitize-undefined-trap-on-error">, Group<f_clang_Group>; def fsanitize_link_cxx_runtime : Flag<["-"], "fsanitize-link-c++-runtime">, @@ -691,9 +696,10 @@ def fmodules_validate_system_headers : Flag<["-"], "fmodules-validate-system-hea def fmodules : Flag <["-"], "fmodules">, Group<f_Group>, Flags<[DriverOption, CC1Option]>, HelpText<"Enable the 'modules' language feature">; -def fmodule_maps : Flag <["-"], "fmodule-maps">, Group<f_Group>, - Flags<[DriverOption,CC1Option]>, - HelpText<"Read module maps to understand the structure of library headers">; +def fimplicit_module_maps : Flag <["-"], "fimplicit-module-maps">, Group<f_Group>, + Flags<[DriverOption, CC1Option]>, + HelpText<"Implicitly search the file system for module map files.">; +def fmodule_maps : Flag <["-"], "fmodule-maps">, Alias<fimplicit_module_maps>; def fmodule_name : JoinedOrSeparate<["-"], "fmodule-name=">, Group<f_Group>, Flags<[DriverOption,CC1Option]>, MetaVarName<"<name>">, HelpText<"Specify the name of the module to build">; @@ -713,12 +719,6 @@ def fmodules_strict_decluse : Flag <["-"], "fmodules-strict-decluse">, Group<f_G HelpText<"Like -fmodules-decluse but requires all headers to be in modules">; def fno_modules_search_all : Flag <["-"], "fno-modules-search-all">, Group<f_Group>, Flags<[DriverOption, CC1Option]>; -def fmodules_implicit_maps : - Flag <["-"], "fmodules-implicit-maps">, - Group<f_Group>, Flags<[DriverOption, CC1Option]>; -def fno_modules_implicit_maps : - Flag <["-"], "fno-modules-implicit-maps">, - Group<f_Group>, Flags<[DriverOption, CC1Option]>; def fno_implicit_modules : Flag <["-"], "fno-implicit-modules">, Group<f_Group>, Flags<[DriverOption, CC1Option]>; @@ -780,8 +780,9 @@ def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Gr Flags<[CC1Option]>, HelpText<"Disallow merging of constants">; def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>, Flags<[DriverOption]>; -def fno_module_maps : Flag <["-"], "fno-module-maps">, Group<f_Group>, +def fno_implicit_module_maps : Flag <["-"], "fno-implicit-module-maps">, Group<f_Group>, Flags<[DriverOption]>; +def fno_module_maps : Flag <["-"], "fno-module-maps">, Alias<fno_implicit_module_maps>; def fno_modules_decluse : Flag <["-"], "fno-modules-decluse">, Group<f_Group>, Flags<[DriverOption]>; def fno_modules_strict_decluse : Flag <["-"], "fno-strict-modules-decluse">, Group<f_Group>, @@ -1338,6 +1339,8 @@ def msoft_float : Flag<["-"], "msoft-float">, Group<m_Group>, Flags<[CC1Option]> def mno_implicit_float : Flag<["-"], "mno-implicit-float">, Group<m_Group>, HelpText<"Don't generate implicit floating point instructions">; def mimplicit_float : Flag<["-"], "mimplicit-float">, Group<m_Group>; +def mrecip : Flag<["-"], "mrecip">, Group<m_Group>; +def mrecip_EQ : CommaJoined<["-"], "mrecip=">, Group<m_Group>, Flags<[CC1Option]>; def msse2 : Flag<["-"], "msse2">, Group<m_x86_Features_Group>; def msse3 : Flag<["-"], "msse3">, Group<m_x86_Features_Group>; def msse4a : Flag<["-"], "msse4a">, Group<m_x86_Features_Group>; diff --git a/include/clang/Driver/SanitizerArgs.h b/include/clang/Driver/SanitizerArgs.h index bfa63e7734fb..ceba912dad13 100644 --- a/include/clang/Driver/SanitizerArgs.h +++ b/include/clang/Driver/SanitizerArgs.h @@ -23,13 +23,13 @@ class ToolChain; class SanitizerArgs { SanitizerSet Sanitizers; SanitizerSet RecoverableSanitizers; + SanitizerSet TrapSanitizers; std::vector<std::string> BlacklistFiles; int CoverageFeatures; int MsanTrackOrigins; int AsanFieldPadding; bool AsanZeroBaseShadow; - bool UbsanTrapOnError; bool AsanSharedRuntime; bool LinkCXXRuntimes; @@ -47,10 +47,12 @@ class SanitizerArgs { } bool needsUbsanRt() const; bool needsDfsanRt() const { return Sanitizers.has(SanitizerKind::DataFlow); } + bool needsSafeStackRt() const { + return Sanitizers.has(SanitizerKind::SafeStack); + } bool requiresPIE() const; bool needsUnwindTables() const; - bool needsLTO() const; bool linkCXXRuntimes() const { return LinkCXXRuntimes; } void addArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const; diff --git a/include/clang/Driver/ToolChain.h b/include/clang/Driver/ToolChain.h index 560df19e25ce..aba18c9916c3 100644 --- a/include/clang/Driver/ToolChain.h +++ b/include/clang/Driver/ToolChain.h @@ -10,6 +10,7 @@ #ifndef LLVM_CLANG_DRIVER_TOOLCHAIN_H #define LLVM_CLANG_DRIVER_TOOLCHAIN_H +#include "clang/Basic/Sanitizers.h" #include "clang/Driver/Action.h" #include "clang/Driver/Multilib.h" #include "clang/Driver/Types.h" @@ -164,7 +165,10 @@ public: } /// Choose a tool to use to handle the action \p JA. - Tool *SelectTool(const JobAction &JA) const; + /// + /// This can be overridden when a particular ToolChain needs to use + /// a C compiler other than Clang. + virtual Tool *SelectTool(const JobAction &JA) const; // Helper methods @@ -345,6 +349,9 @@ public: virtual bool AddFastMathRuntimeIfAvailable(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const; + + /// \brief Return sanitizers which are available in this toolchain. + virtual SanitizerMask getSupportedSanitizers() const; }; } // end namespace driver diff --git a/include/clang/Format/Format.h b/include/clang/Format/Format.h index 3fdee99f3e55..ad87a057a6a7 100644 --- a/include/clang/Format/Format.h +++ b/include/clang/Format/Format.h @@ -210,10 +210,10 @@ struct FormatStyle { enum ShortFunctionStyle { /// \brief Never merge functions into a single line. SFS_None, - /// \brief Only merge functions defined inside a class. - SFS_Inline, /// \brief Only merge empty functions. SFS_Empty, + /// \brief Only merge functions defined inside a class. Implies "empty". + SFS_Inline, /// \brief Merge all functions fitting on a single line. SFS_All, }; @@ -287,6 +287,11 @@ struct FormatStyle { bool AlwaysBreakTemplateDeclarations; /// \brief If \c true, always break before multiline string literals. + /// + /// This flag is mean to make cases where there are multiple multiline strings + /// in a file look more consistent. Thus, it will only take effect if wrapping + /// the string at that point leads to it being indented + /// \c ContinuationIndentWidth spaces from the start of the line. bool AlwaysBreakBeforeMultilineStrings; /// \brief Different ways to use tab in formatting. diff --git a/include/clang/Frontend/ASTUnit.h b/include/clang/Frontend/ASTUnit.h index 405774b811c8..2d38352d22a8 100644 --- a/include/clang/Frontend/ASTUnit.h +++ b/include/clang/Frontend/ASTUnit.h @@ -56,6 +56,7 @@ class FileEntry; class FileManager; class HeaderSearch; class Preprocessor; +class PCHContainerOperations; class SourceManager; class TargetInfo; class ASTFrontendAction; @@ -422,7 +423,8 @@ private: explicit ASTUnit(bool MainFileIsAST); void CleanTemporaryFiles(); - bool Parse(std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer); + bool Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps, + std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer); struct ComputedPreamble { llvm::MemoryBuffer *Buffer; @@ -442,6 +444,7 @@ private: unsigned MaxLines); std::unique_ptr<llvm::MemoryBuffer> getMainBufferWithPrecompiledPreamble( + std::shared_ptr<PCHContainerOperations> PCHContainerOps, const CompilerInvocation &PreambleInvocationIn, bool AllowRebuild = true, unsigned MaxLines = 0); void RealizeTopLevelDeclsFromPreamble(); @@ -715,12 +718,16 @@ public: /// /// \param Filename - The AST file to load. /// + /// \param PCHContainerOps - The PCHContainerOperations to use for loading and + /// creating modules. /// \param Diags - The diagnostics engine to use for reporting errors; its /// lifetime is expected to extend past that of the returned ASTUnit. /// /// \returns - The initialized ASTUnit or null if the AST failed to load. static std::unique_ptr<ASTUnit> LoadFromASTFile( - const std::string &Filename, IntrusiveRefCntPtr<DiagnosticsEngine> Diags, + const std::string &Filename, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + IntrusiveRefCntPtr<DiagnosticsEngine> Diags, const FileSystemOptions &FileSystemOpts, bool OnlyLocalDecls = false, ArrayRef<RemappedFile> RemappedFiles = None, bool CaptureDiagnostics = false, bool AllowPCHWithCompilerErrors = false, @@ -735,8 +742,10 @@ private: /// /// \returns \c true if a catastrophic failure occurred (which means that the /// \c ASTUnit itself is invalid), or \c false otherwise. - bool LoadFromCompilerInvocation(bool PrecompilePreamble); - + bool LoadFromCompilerInvocation( + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + bool PrecompilePreamble); + public: /// \brief Create an ASTUnit from a source file, via a CompilerInvocation @@ -745,6 +754,9 @@ public: /// \param CI - The compiler invocation to use; it must have exactly one input /// source file. The ASTUnit takes ownership of the CompilerInvocation object. /// + /// \param PCHContainerOps - The PCHContainerOperations to use for loading and + /// creating modules. + /// /// \param Diags - The diagnostics engine to use for reporting errors; its /// lifetime is expected to extend past that of the returned ASTUnit. /// @@ -765,7 +777,9 @@ public: /// created ASTUnit was passed in \p Unit then the caller can check that. /// static ASTUnit *LoadFromCompilerInvocationAction( - CompilerInvocation *CI, IntrusiveRefCntPtr<DiagnosticsEngine> Diags, + CompilerInvocation *CI, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + IntrusiveRefCntPtr<DiagnosticsEngine> Diags, ASTFrontendAction *Action = nullptr, ASTUnit *Unit = nullptr, bool Persistent = true, StringRef ResourceFilesPath = StringRef(), bool OnlyLocalDecls = false, bool CaptureDiagnostics = false, @@ -780,15 +794,20 @@ public: /// \param CI - The compiler invocation to use; it must have exactly one input /// source file. The ASTUnit takes ownership of the CompilerInvocation object. /// + /// \param PCHContainerOps - The PCHContainerOperations to use for loading and + /// creating modules. + /// /// \param Diags - The diagnostics engine to use for reporting errors; its /// lifetime is expected to extend past that of the returned ASTUnit. // // FIXME: Move OnlyLocalDecls, UseBumpAllocator to setters on the ASTUnit, we // shouldn't need to specify them at construction time. static std::unique_ptr<ASTUnit> LoadFromCompilerInvocation( - CompilerInvocation *CI, IntrusiveRefCntPtr<DiagnosticsEngine> Diags, - bool OnlyLocalDecls = false, bool CaptureDiagnostics = false, - bool PrecompilePreamble = false, TranslationUnitKind TUKind = TU_Complete, + CompilerInvocation *CI, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + IntrusiveRefCntPtr<DiagnosticsEngine> Diags, bool OnlyLocalDecls = false, + bool CaptureDiagnostics = false, bool PrecompilePreamble = false, + TranslationUnitKind TUKind = TU_Complete, bool CacheCodeCompletionResults = false, bool IncludeBriefCommentsInCodeCompletion = false, bool UserFilesAreVolatile = false); @@ -800,6 +819,9 @@ public: /// /// \param ArgEnd - The end of the argument vector. /// + /// \param PCHContainerOps - The PCHContainerOperations to use for loading and + /// creating modules. + /// /// \param Diags - The diagnostics engine to use for reporting errors; its /// lifetime is expected to extend past that of the returned ASTUnit. /// @@ -813,6 +835,7 @@ public: // shouldn't need to specify them at construction time. static ASTUnit *LoadFromCommandLine( const char **ArgBegin, const char **ArgEnd, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, IntrusiveRefCntPtr<DiagnosticsEngine> Diags, StringRef ResourceFilesPath, bool OnlyLocalDecls = false, bool CaptureDiagnostics = false, ArrayRef<RemappedFile> RemappedFiles = None, @@ -828,8 +851,9 @@ public: /// were originally used to produce this translation unit. /// /// \returns True if a failure occurred that causes the ASTUnit not to - /// contain any translation-unit information, false otherwise. - bool Reparse(ArrayRef<RemappedFile> RemappedFiles = None); + /// contain any translation-unit information, false otherwise. + bool Reparse(std::shared_ptr<PCHContainerOperations> PCHContainerOps, + ArrayRef<RemappedFile> RemappedFiles = None); /// \brief Perform code completion at the given file, line, and /// column within this translation unit. @@ -852,14 +876,14 @@ public: /// FIXME: The Diag, LangOpts, SourceMgr, FileMgr, StoredDiagnostics, and /// OwnedBuffers parameters are all disgusting hacks. They will go away. void CodeComplete(StringRef File, unsigned Line, unsigned Column, - ArrayRef<RemappedFile> RemappedFiles, - bool IncludeMacros, bool IncludeCodePatterns, - bool IncludeBriefComments, + ArrayRef<RemappedFile> RemappedFiles, bool IncludeMacros, + bool IncludeCodePatterns, bool IncludeBriefComments, CodeCompleteConsumer &Consumer, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, DiagnosticsEngine &Diag, LangOptions &LangOpts, SourceManager &SourceMgr, FileManager &FileMgr, SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics, - SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers); + SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers); /// \brief Save this translation unit to a file with the given name. /// diff --git a/include/clang/Frontend/CodeGenOptions.def b/include/clang/Frontend/CodeGenOptions.def index adf1c879d40e..d34cf0cad1c9 100644 --- a/include/clang/Frontend/CodeGenOptions.def +++ b/include/clang/Frontend/CodeGenOptions.def @@ -120,8 +120,6 @@ CODEGENOPT(SanitizeCoverageTraceCmp, 1, 0) ///< Enable cmp instruction tracing ///< in sanitizer coverage. CODEGENOPT(SanitizeCoverage8bitCounters, 1, 0) ///< Use 8-bit frequency counters ///< in sanitizer coverage. -CODEGENOPT(SanitizeUndefinedTrapOnError, 1, 0) ///< Set on - /// -fsanitize-undefined-trap-on-error CODEGENOPT(SimplifyLibCalls , 1, 1) ///< Set when -fbuiltin is enabled. CODEGENOPT(SoftFloat , 1, 0) ///< -soft-float. CODEGENOPT(StrictEnums , 1, 0) ///< Optimize based on strict enum definition. diff --git a/include/clang/Frontend/CodeGenOptions.h b/include/clang/Frontend/CodeGenOptions.h index 0c5ce5813769..66597bd0af8e 100644 --- a/include/clang/Frontend/CodeGenOptions.h +++ b/include/clang/Frontend/CodeGenOptions.h @@ -197,6 +197,9 @@ public: /// continued when possible). SanitizerSet SanitizeRecover; + /// Set of sanitizer checks that trap rather than diagnose. + SanitizerSet SanitizeTrap; + public: // Define accessors/mutators for code generation options of enumeration type. #define CODEGENOPT(Name, Bits, Default) diff --git a/include/clang/Frontend/CompilerInstance.h b/include/clang/Frontend/CompilerInstance.h index 8d0d939d7811..9cd806c99b85 100644 --- a/include/clang/Frontend/CompilerInstance.h +++ b/include/clang/Frontend/CompilerInstance.h @@ -11,6 +11,7 @@ #define LLVM_CLANG_FRONTEND_COMPILERINSTANCE_H_ #include "clang/AST/ASTConsumer.h" +#include "clang/Frontend/PCHContainerOperations.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/SourceManager.h" #include "clang/Frontend/CompilerInvocation.h" @@ -109,6 +110,9 @@ class CompilerInstance : public ModuleLoader { /// \brief The module dependency collector for crashdumps std::shared_ptr<ModuleDependencyCollector> ModuleDepCollector; + /// \brief The module provider. + std::shared_ptr<PCHContainerOperations> ThePCHContainerOperations; + /// \brief The dependency file generator. std::unique_ptr<DependencyFileGenerator> TheDependencyFileGenerator; @@ -172,7 +176,10 @@ class CompilerInstance : public ModuleLoader { CompilerInstance(const CompilerInstance &) = delete; void operator=(const CompilerInstance &) = delete; public: - explicit CompilerInstance(bool BuildingModule = false); + explicit CompilerInstance( + std::shared_ptr<PCHContainerOperations> PCHContainerOps = + std::make_shared<RawPCHContainerOperations>(), + bool BuildingModule = false); ~CompilerInstance() override; /// @name High-Level Operations @@ -492,6 +499,10 @@ public: void setModuleDepCollector( std::shared_ptr<ModuleDependencyCollector> Collector); + std::shared_ptr<PCHContainerOperations> getPCHContainerOperations() const { + return ThePCHContainerOperations; + } + /// } /// @name Code Completion /// { @@ -605,6 +616,7 @@ public: static IntrusiveRefCntPtr<ASTReader> createPCHExternalASTSource( StringRef Path, const std::string &Sysroot, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context, + const PCHContainerOperations &PCHContainerOps, void *DeserializationListener, bool OwnDeserializationListener, bool Preamble, bool UseGlobalModuleIndex); diff --git a/include/clang/Frontend/FrontendActions.h b/include/clang/Frontend/FrontendActions.h index b1508287c85f..f61775f014f8 100644 --- a/include/clang/Frontend/FrontendActions.h +++ b/include/clang/Frontend/FrontendActions.h @@ -85,10 +85,9 @@ public: /// create the PCHGenerator instance returned by CreateASTConsumer. /// /// \returns true if an error occurred, false otherwise. - static raw_ostream *ComputeASTConsumerArguments(CompilerInstance &CI, - StringRef InFile, - std::string &Sysroot, - std::string &OutputFile); + static raw_pwrite_stream * + ComputeASTConsumerArguments(CompilerInstance &CI, StringRef InFile, + std::string &Sysroot, std::string &OutputFile); }; class GenerateModuleAction : public ASTFrontendAction { @@ -118,10 +117,10 @@ public: /// create the PCHGenerator instance returned by CreateASTConsumer. /// /// \returns true if an error occurred, false otherwise. - raw_ostream *ComputeASTConsumerArguments(CompilerInstance &CI, - StringRef InFile, - std::string &Sysroot, - std::string &OutputFile); + raw_pwrite_stream *ComputeASTConsumerArguments(CompilerInstance &CI, + StringRef InFile, + std::string &Sysroot, + std::string &OutputFile); }; class SyntaxOnlyAction : public ASTFrontendAction { diff --git a/include/clang/Frontend/PCHContainerOperations.h b/include/clang/Frontend/PCHContainerOperations.h new file mode 100644 index 000000000000..949ee63c615d --- /dev/null +++ b/include/clang/Frontend/PCHContainerOperations.h @@ -0,0 +1,76 @@ +//===--- Frontend/PCHContainerOperations.h - PCH Containers -----*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_PCH_CONTAINER_OPERATIONS_H +#define LLVM_CLANG_PCH_CONTAINER_OPERATIONS_H + +#include "llvm/ADT/SmallVector.h" +#include "llvm/Support/MemoryBuffer.h" +#include <memory> + +namespace llvm { +class raw_pwrite_stream; +class BitstreamReader; +} + +namespace clang { + +class ASTConsumer; +class CodeGenOptions; +class DiagnosticsEngine; +class HeaderSearchOptions; +class LangOptions; +class PreprocessorOptions; +class TargetOptions; + +struct PCHBuffer { + bool IsComplete; + llvm::SmallVector<char, 0> Data; +}; + +/// \brief This abstract interface provides operations for creating +/// and unwrapping containers for serialized ASTs (precompiled headers +/// and clang modules). +class PCHContainerOperations { +public: + virtual ~PCHContainerOperations(); + /// \brief Return an ASTConsumer that can be chained with a + /// PCHGenerator that produces a wrapper file format containing a + /// serialized AST bitstream. + virtual std::unique_ptr<ASTConsumer> CreatePCHContainerGenerator( + DiagnosticsEngine &Diags, const HeaderSearchOptions &HSO, + const PreprocessorOptions &PPO, const TargetOptions &TO, + const LangOptions &LO, const std::string &MainFileName, + const std::string &OutputFileName, llvm::raw_pwrite_stream *OS, + std::shared_ptr<PCHBuffer> Buffer) const = 0; + + /// \brief Initialize an llvm::BitstreamReader with the serialized AST inside + /// the PCH container Buffer. + virtual void ExtractPCH(llvm::MemoryBufferRef Buffer, + llvm::BitstreamReader &StreamFile) const = 0; +}; + +/// \brief Implements a raw pass-through PCH container. +class RawPCHContainerOperations : public PCHContainerOperations { + /// \brief Return an ASTConsumer that can be chained with a + /// PCHGenerator that writes the module to a flat file. + std::unique_ptr<ASTConsumer> CreatePCHContainerGenerator( + DiagnosticsEngine &Diags, const HeaderSearchOptions &HSO, + const PreprocessorOptions &PPO, const TargetOptions &TO, + const LangOptions &LO, const std::string &MainFileName, + const std::string &OutputFileName, llvm::raw_pwrite_stream *OS, + std::shared_ptr<PCHBuffer> Buffer) const override; + + /// \brief Initialize an llvm::BitstreamReader with Buffer. + void ExtractPCH(llvm::MemoryBufferRef Buffer, + llvm::BitstreamReader &StreamFile) const override; +}; +} + +#endif diff --git a/include/clang/Frontend/Utils.h b/include/clang/Frontend/Utils.h index cd0ebf611201..639965343c45 100644 --- a/include/clang/Frontend/Utils.h +++ b/include/clang/Frontend/Utils.h @@ -45,6 +45,7 @@ class HeaderSearch; class HeaderSearchOptions; class IdentifierTable; class LangOptions; +class PCHContainerOperations; class Preprocessor; class PreprocessorOptions; class PreprocessorOutputOptions; @@ -61,8 +62,8 @@ void ApplyHeaderSearchOptions(HeaderSearch &HS, /// InitializePreprocessor - Initialize the preprocessor getting it and the /// environment ready to process a single file. -void InitializePreprocessor(Preprocessor &PP, - const PreprocessorOptions &PPOpts, +void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts, + const PCHContainerOperations &PCHContainerOps, const FrontendOptions &FEOpts); /// DoPrintPreprocessedInput - Implement -E mode. diff --git a/include/clang/Lex/HeaderSearchOptions.h b/include/clang/Lex/HeaderSearchOptions.h index 316134c405b3..c9c32609f19b 100644 --- a/include/clang/Lex/HeaderSearchOptions.h +++ b/include/clang/Lex/HeaderSearchOptions.h @@ -98,8 +98,9 @@ public: /// Note: Only used for testing! unsigned DisableModuleHash : 1; - /// \brief Interpret module maps. This option is implied by full modules. - unsigned ModuleMaps : 1; + /// \brief Implicit module maps. This option is enabld by default when + /// modules is enabled. + unsigned ImplicitModuleMaps : 1; /// \brief Set the 'home directory' of a module map file to the current /// working directory (or the home directory of the module map file that @@ -166,7 +167,7 @@ public: public: HeaderSearchOptions(StringRef _Sysroot = "/") - : Sysroot(_Sysroot), DisableModuleHash(0), ModuleMaps(0), + : Sysroot(_Sysroot), DisableModuleHash(0), ImplicitModuleMaps(0), ModuleMapFileHomeIsCwd(0), ModuleCachePruneInterval(7*24*60*60), ModuleCachePruneAfter(31*24*60*60), diff --git a/include/clang/Lex/ModuleMap.h b/include/clang/Lex/ModuleMap.h index e41efc5d419d..0bbcfac3b81b 100644 --- a/include/clang/Lex/ModuleMap.h +++ b/include/clang/Lex/ModuleMap.h @@ -268,15 +268,10 @@ public: /// /// \param File The header file that is likely to be included. /// - /// \param RequestingModule Specifies the module the header is intended to be - /// used from. Used to disambiguate if a header is present in multiple - /// modules. - /// /// \returns The module KnownHeader, which provides the module that owns the /// given header file. The KnownHeader is default constructed to indicate /// that no module owns this header file. - KnownHeader findModuleForHeader(const FileEntry *File, - Module *RequestingModule = nullptr); + KnownHeader findModuleForHeader(const FileEntry *File); /// \brief Reports errors if a module must not include a specific file. /// diff --git a/include/clang/Lex/Preprocessor.h b/include/clang/Lex/Preprocessor.h index f6e61c0e7ad6..439a28041e2d 100644 --- a/include/clang/Lex/Preprocessor.h +++ b/include/clang/Lex/Preprocessor.h @@ -256,6 +256,10 @@ class Preprocessor : public RefCountedBase<Preprocessor> { /// \#pragma clang arc_cf_code_audited begin. SourceLocation PragmaARCCFCodeAuditedLoc; + /// \brief The source location of the currently-active + /// \#pragma clang assume_nonnull begin. + SourceLocation PragmaAssumeNonNullLoc; + /// \brief True if we hit the code-completion point. bool CodeCompletionReached; @@ -455,8 +459,9 @@ class Preprocessor : public RefCountedBase<Preprocessor> { void overrideActiveModuleMacros(Preprocessor &PP, IdentifierInfo *II) { if (auto *Info = getModuleInfo(PP, II)) { - for (auto *Active : Info->ActiveModuleMacros) - Info->OverriddenMacros.push_back(Active); + Info->OverriddenMacros.insert(Info->OverriddenMacros.end(), + Info->ActiveModuleMacros.begin(), + Info->ActiveModuleMacros.end()); Info->ActiveModuleMacros.clear(); Info->IsAmbiguous = false; } @@ -1249,6 +1254,20 @@ public: PragmaARCCFCodeAuditedLoc = Loc; } + /// \brief The location of the currently-active \#pragma clang + /// assume_nonnull begin. + /// + /// Returns an invalid location if there is no such pragma active. + SourceLocation getPragmaAssumeNonNullLoc() const { + return PragmaAssumeNonNullLoc; + } + + /// \brief Set the location of the currently-active \#pragma clang + /// assume_nonnull begin. An invalid location ends the pragma. + void setPragmaAssumeNonNullLoc(SourceLocation Loc) { + PragmaAssumeNonNullLoc = Loc; + } + /// \brief Set the directory in which the main file should be considered /// to have been found, if it is not a real file. void setMainFileDir(const DirectoryEntry *Dir) { diff --git a/include/clang/Lex/Token.h b/include/clang/Lex/Token.h index e0878093402a..7ba22b2f626c 100644 --- a/include/clang/Lex/Token.h +++ b/include/clang/Lex/Token.h @@ -94,6 +94,13 @@ public: /// "if (Tok.is(tok::l_brace)) {...}". bool is(tok::TokenKind K) const { return Kind == K; } bool isNot(tok::TokenKind K) const { return Kind != K; } + bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const { + return is(K1) || is(K2); + } + template <typename... Ts> + bool isOneOf(tok::TokenKind K1, tok::TokenKind K2, Ts... Ks) const { + return is(K1) || isOneOf(K2, Ks...); + } /// \brief Return true if this is a raw identifier (when lexing /// in raw mode) or a non-keyword identifier (when lexing in non-raw mode). diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h index caba77b74c67..7042a1ef6e29 100644 --- a/include/clang/Parse/Parser.h +++ b/include/clang/Parse/Parser.h @@ -303,6 +303,12 @@ public: return true; } + /// Retrieve the underscored keyword (__nonnull, __nullable) that corresponds + /// to the given nullability kind. + IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability) { + return Actions.getNullabilityKeyword(nullability); + } + private: //===--------------------------------------------------------------------===// // Low-Level token peeking and consumption methods. @@ -620,6 +626,16 @@ private: const char *&PrevSpec, unsigned &DiagID, bool &isInvalid); + /// Returns true if the current token is the identifier 'instancetype'. + /// + /// Should only be used in Objective-C language modes. + bool isObjCInstancetype() { + assert(getLangOpts().ObjC1); + if (!Ident_instancetype) + Ident_instancetype = PP.getIdentifierInfo("instancetype"); + return Tok.getIdentifierInfo() == Ident_instancetype; + } + /// TryKeywordIdentFallback - For compatibility with system headers using /// keywords as identifiers, attempt to convert the current token to an /// identifier and optionally disable the keyword for the remainder of the @@ -1282,6 +1298,7 @@ private: // Definitions for Objective-c context sensitive keywords recognition. enum ObjCTypeQual { objc_in=0, objc_out, objc_inout, objc_oneway, objc_bycopy, objc_byref, + objc_nonnull, objc_nullable, objc_null_unspecified, objc_NumQuals }; IdentifierInfo *ObjCTypeQuals[objc_NumQuals]; @@ -1685,7 +1702,8 @@ private: DSC_trailing, // C++11 trailing-type-specifier in a trailing return type DSC_alias_declaration, // C++11 type-specifier-seq in an alias-declaration DSC_top_level, // top-level/namespace declaration context - DSC_template_type_arg // template type argument context + DSC_template_type_arg, // template type argument context + DSC_objc_method_result, // ObjC method result context, enables 'instancetype' }; /// Is this a context in which we are parsing just a type-specifier (or @@ -1695,6 +1713,7 @@ private: case DSC_normal: case DSC_class: case DSC_top_level: + case DSC_objc_method_result: return false; case DSC_template_type_arg: @@ -2106,6 +2125,7 @@ private: void ParseBorlandTypeAttributes(ParsedAttributes &attrs); void ParseOpenCLAttributes(ParsedAttributes &attrs); void ParseOpenCLQualifiers(ParsedAttributes &Attrs); + void ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs); VersionTuple ParseVersionTuple(SourceRange &Range); void ParseAvailabilityAttribute(IdentifierInfo &Availability, diff --git a/include/clang/Rewrite/Frontend/FixItRewriter.h b/include/clang/Rewrite/Frontend/FixItRewriter.h index ad828e55ae88..3b1b31e0cdee 100644 --- a/include/clang/Rewrite/Frontend/FixItRewriter.h +++ b/include/clang/Rewrite/Frontend/FixItRewriter.h @@ -27,7 +27,7 @@ class FileEntry; class FixItOptions { public: - FixItOptions() : FixWhatYouCan(false), + FixItOptions() : InPlace(false), FixWhatYouCan(false), FixOnlyWarnings(false), Silent(false) { } virtual ~FixItOptions(); @@ -41,6 +41,10 @@ public: /// virtual std::string RewriteFilename(const std::string &Filename, int &fd) = 0; + /// True if files should be updated in place. RewriteFilename is only called + /// if this is false. + bool InPlace; + /// \brief Whether to abort fixing a file when not all errors could be fixed. bool FixWhatYouCan; diff --git a/include/clang/Sema/AttributeList.h b/include/clang/Sema/AttributeList.h index 58b1b9ee2436..4d18633cd338 100644 --- a/include/clang/Sema/AttributeList.h +++ b/include/clang/Sema/AttributeList.h @@ -81,6 +81,8 @@ public: AS_Declspec, /// __ptr16, alignas(...), etc. AS_Keyword, + /// Context-sensitive version of a keyword attribute. + AS_ContextSensitiveKeyword, /// #pragma ... AS_Pragma }; @@ -343,14 +345,20 @@ public: bool isAlignasAttribute() const { // FIXME: Use a better mechanism to determine this. - return getKind() == AT_Aligned && SyntaxUsed == AS_Keyword; + return getKind() == AT_Aligned && isKeywordAttribute(); } bool isDeclspecAttribute() const { return SyntaxUsed == AS_Declspec; } bool isCXX11Attribute() const { return SyntaxUsed == AS_CXX11 || isAlignasAttribute(); } - bool isKeywordAttribute() const { return SyntaxUsed == AS_Keyword; } + bool isKeywordAttribute() const { + return SyntaxUsed == AS_Keyword || SyntaxUsed == AS_ContextSensitiveKeyword; + } + + bool isContextSensitiveKeywordAttribute() const { + return SyntaxUsed == AS_ContextSensitiveKeyword; + } bool isInvalid() const { return Invalid; } void setInvalid(bool b = true) const { Invalid = b; } diff --git a/include/clang/Sema/DeclSpec.h b/include/clang/Sema/DeclSpec.h index de39d83bded4..2ec3286ad799 100644 --- a/include/clang/Sema/DeclSpec.h +++ b/include/clang/Sema/DeclSpec.h @@ -31,6 +31,7 @@ #include "clang/Lex/Token.h" #include "clang/Sema/AttributeList.h" #include "clang/Sema/Ownership.h" +#include "llvm/ADT/Optional.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" @@ -785,7 +786,8 @@ public: DQ_Out = 0x4, DQ_Bycopy = 0x8, DQ_Byref = 0x10, - DQ_Oneway = 0x20 + DQ_Oneway = 0x20, + DQ_CSNullability = 0x40 }; /// PropertyAttributeKind - list of property attributes. @@ -802,17 +804,22 @@ public: DQ_PR_atomic = 0x100, DQ_PR_weak = 0x200, DQ_PR_strong = 0x400, - DQ_PR_unsafe_unretained = 0x800 + DQ_PR_unsafe_unretained = 0x800, + DQ_PR_nullability = 0x1000, + DQ_PR_null_resettable = 0x2000 }; - ObjCDeclSpec() : objcDeclQualifier(DQ_None), PropertyAttributes(DQ_PR_noattr), - GetterName(nullptr), SetterName(nullptr) { } + Nullability(0), GetterName(nullptr), SetterName(nullptr) { } + ObjCDeclQualifier getObjCDeclQualifier() const { return objcDeclQualifier; } void setObjCDeclQualifier(ObjCDeclQualifier DQVal) { objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier | DQVal); } + void clearObjCDeclQualifier(ObjCDeclQualifier DQVal) { + objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier & ~DQVal); + } ObjCPropertyAttributeKind getPropertyAttributes() const { return ObjCPropertyAttributeKind(PropertyAttributes); @@ -822,6 +829,28 @@ public: (ObjCPropertyAttributeKind)(PropertyAttributes | PRVal); } + NullabilityKind getNullability() const { + assert(((getObjCDeclQualifier() & DQ_CSNullability) || + (getPropertyAttributes() & DQ_PR_nullability)) && + "Objective-C declspec doesn't have nullability"); + return static_cast<NullabilityKind>(Nullability); + } + + SourceLocation getNullabilityLoc() const { + assert(((getObjCDeclQualifier() & DQ_CSNullability) || + (getPropertyAttributes() & DQ_PR_nullability)) && + "Objective-C declspec doesn't have nullability"); + return NullabilityLoc; + } + + void setNullability(SourceLocation loc, NullabilityKind kind) { + assert(((getObjCDeclQualifier() & DQ_CSNullability) || + (getPropertyAttributes() & DQ_PR_nullability)) && + "Set the nullability declspec or property attribute first"); + Nullability = static_cast<unsigned>(kind); + NullabilityLoc = loc; + } + const IdentifierInfo *getGetterName() const { return GetterName; } IdentifierInfo *getGetterName() { return GetterName; } void setGetterName(IdentifierInfo *name) { GetterName = name; } @@ -834,10 +863,15 @@ private: // FIXME: These two are unrelated and mutually exclusive. So perhaps // we can put them in a union to reflect their mutual exclusivity // (space saving is negligible). - ObjCDeclQualifier objcDeclQualifier : 6; + ObjCDeclQualifier objcDeclQualifier : 7; // NOTE: VC++ treats enums as signed, avoid using ObjCPropertyAttributeKind - unsigned PropertyAttributes : 12; + unsigned PropertyAttributes : 14; + + unsigned Nullability : 2; + + SourceLocation NullabilityLoc; + IdentifierInfo *GetterName; // getter name or NULL if no getter IdentifierInfo *SetterName; // setter name or NULL if no setter }; @@ -1616,7 +1650,13 @@ private: bool InlineParamsUsed; /// \brief true if the declaration is preceded by \c __extension__. - bool Extension : 1; + unsigned Extension : 1; + + /// Indicates whether this is an Objective-C instance variable. + unsigned ObjCIvar : 1; + + /// Indicates whether this is an Objective-C 'weak' property. + unsigned ObjCWeakProperty : 1; /// \brief If this is the second or subsequent declarator in this declaration, /// the location of the comma before this declarator. @@ -1635,7 +1675,8 @@ public: GroupingParens(false), FunctionDefinition(FDK_Declaration), Redeclaration(false), Attrs(ds.getAttributePool().getFactory()), AsmLabel(nullptr), - InlineParamsUsed(false), Extension(false) { + InlineParamsUsed(false), Extension(false), ObjCIvar(false), + ObjCWeakProperty(false) { } ~Declarator() { @@ -1713,6 +1754,8 @@ public: Attrs.clear(); AsmLabel = nullptr; InlineParamsUsed = false; + ObjCIvar = false; + ObjCWeakProperty = false; CommaLoc = SourceLocation(); EllipsisLoc = SourceLocation(); } @@ -2121,6 +2164,12 @@ public: void setExtension(bool Val = true) { Extension = Val; } bool getExtension() const { return Extension; } + void setObjCIvar(bool Val = true) { ObjCIvar = Val; } + bool isObjCIvar() const { return ObjCIvar; } + + void setObjCWeakProperty(bool Val = true) { ObjCWeakProperty = Val; } + bool isObjCWeakProperty() const { return ObjCWeakProperty; } + void setInvalidType(bool Val = true) { InvalidType = Val; } bool isInvalidType() const { return InvalidType || DS.getTypeSpecType() == DeclSpec::TST_error; diff --git a/include/clang/Sema/Lookup.h b/include/clang/Sema/Lookup.h index 97192b53fa44..5bfee8b0d037 100644 --- a/include/clang/Sema/Lookup.h +++ b/include/clang/Sema/Lookup.h @@ -302,14 +302,10 @@ public: if (!D->isInIdentifierNamespace(IDNS)) return nullptr; - if (isVisible(getSema(), D)) + if (isHiddenDeclarationVisible() || isVisible(getSema(), D)) return D; - if (auto *Visible = getAcceptableDeclSlow(D)) - return Visible; - - // Even if hidden declarations are visible, prefer a visible declaration. - return isHiddenDeclarationVisible() ? D : nullptr; + return getAcceptableDeclSlow(D); } private: diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h index 60664c5fdc99..cb75b969f116 100644 --- a/include/clang/Sema/Sema.h +++ b/include/clang/Sema/Sema.h @@ -210,6 +210,50 @@ namespace threadSafety { typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>, SourceLocation> UnexpandedParameterPack; +/// Describes whether we've seen any nullability information for the given +/// file. +struct FileNullability { + /// The first pointer declarator (of any pointer kind) in the file that does + /// not have a corresponding nullability annotation. + SourceLocation PointerLoc; + + /// Which kind of pointer declarator we saw. + uint8_t PointerKind; + + /// Whether we saw any type nullability annotations in the given file. + bool SawTypeNullability = false; +}; + +/// A mapping from file IDs to a record of whether we've seen nullability +/// information in that file. +class FileNullabilityMap { + /// A mapping from file IDs to the nullability information for each file ID. + llvm::DenseMap<FileID, FileNullability> Map; + + /// A single-element cache based on the file ID. + struct { + FileID File; + FileNullability Nullability; + } Cache; + +public: + FileNullability &operator[](FileID file) { + // Check the single-element cache. + if (file == Cache.File) + return Cache.Nullability; + + // It's not in the single-element cache; flush the cache if we have one. + if (!Cache.File.isInvalid()) { + Map[Cache.File] = Cache.Nullability; + } + + // Pull this entry into the cache. + Cache.File = file; + Cache.Nullability = Map[file]; + return Cache.Nullability; + } +}; + /// Sema - This implements semantic analysis and AST building for C. class Sema { Sema(const Sema &) = delete; @@ -341,6 +385,9 @@ public: PragmaStack<StringLiteral *> ConstSegStack; PragmaStack<StringLiteral *> CodeSegStack; + /// A mapping that describes the nullability we've seen in each header file. + FileNullabilityMap NullabilityMap; + /// Last section used with #pragma init_seg. StringLiteral *CurInitSeg; SourceLocation CurInitSegLoc; @@ -1157,6 +1204,16 @@ public: bool CheckFunctionReturnType(QualType T, SourceLocation Loc); + unsigned deduceWeakPropertyFromType(QualType T) { + if ((getLangOpts().getGC() != LangOptions::NonGC && + T.isObjCGCWeak()) || + (getLangOpts().ObjCAutoRefCount && + T.getObjCLifetime() == Qualifiers::OCL_Weak)) + return ObjCDeclSpec::DQ_PR_weak; + return 0; + } + + /// \brief Build a function type. /// /// This routine checks the function type according to C++ rules and @@ -1325,6 +1382,11 @@ public: return hasVisibleDefinition(const_cast<NamedDecl*>(D), &Hidden); } + /// Determine if the template parameter \p D has a visible default argument. + bool + hasVisibleDefaultArgument(const NamedDecl *D, + llvm::SmallVectorImpl<Module *> *Modules = nullptr); + bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser); bool RequireCompleteType(SourceLocation Loc, QualType T, @@ -1727,6 +1789,22 @@ public: void createImplicitModuleImportForErrorRecovery(SourceLocation Loc, Module *Mod); + /// Kinds of missing import. Note, the values of these enumerators correspond + /// to %select values in diagnostics. + enum class MissingImportKind { + Declaration, + Definition, + DefaultArgument + }; + + /// \brief Diagnose that the specified declaration needs to be visible but + /// isn't, and suggest a module import that would resolve the problem. + void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl, + bool NeedDefinition, bool Recover = true); + void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl, + SourceLocation DeclLoc, ArrayRef<Module *> Modules, + MissingImportKind MIK, bool Recover); + /// \brief Retrieve a suitable printing policy. PrintingPolicy getPrintingPolicy() const { return getPrintingPolicy(Context, PP); @@ -1847,10 +1925,10 @@ public: /// struct, or union). void ActOnTagStartDefinition(Scope *S, Decl *TagDecl); + typedef void *SkippedDefinitionContext; + /// \brief Invoked when we enter a tag definition that we're skipping. - void ActOnTagStartSkippedDefinition(Scope *S, Decl *TD) { - PushDeclContext(S, cast<DeclContext>(TD)); - } + SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD); Decl *ActOnObjCContainerStartDefinition(Decl *IDecl); @@ -1867,9 +1945,7 @@ public: void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl, SourceLocation RBraceLoc); - void ActOnTagFinishSkippedDefinition() { - PopDeclContext(); - } + void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context); void ActOnObjCContainerFinishDefinition(); @@ -2819,6 +2895,7 @@ public: unsigned ArgNum, StringRef &Str, SourceLocation *ArgLocation = nullptr); bool checkSectionName(SourceLocation LiteralLoc, StringRef Str); + void checkTargetAttr(SourceLocation LiteralLoc, StringRef Str); bool checkMSInheritanceAttrOnDefinition( CXXRecordDecl *RD, SourceRange Range, bool BestCase, MSInheritanceAttr::Spelling SemanticSpelling); @@ -2839,6 +2916,26 @@ public: /// Valid types should not have multiple attributes with different CCs. const AttributedType *getCallingConvAttributedType(QualType T) const; + /// Check whether a nullability type specifier can be added to the given + /// type. + /// + /// \param type The type to which the nullability specifier will be + /// added. On success, this type will be updated appropriately. + /// + /// \param nullability The nullability specifier to add. + /// + /// \param nullabilityLoc The location of the nullability specifier. + /// + /// \param isContextSensitive Whether this nullability specifier was + /// written as a context-sensitive keyword (in an Objective-C + /// method) or an Objective-C property attribute, rather than as an + /// underscored type specifier. + /// + /// \returns true if nullability cannot be applied, false otherwise. + bool checkNullabilityTypeSpecifier(QualType &type, NullabilityKind nullability, + SourceLocation nullabilityLoc, + bool isContextSensitive); + /// \brief Stmt attributes - this routine is the top level dispatcher. StmtResult ProcessStmtAttributes(Stmt *Stmt, AttributeList *Attrs, SourceRange Range); @@ -2878,6 +2975,9 @@ public: ObjCContainerDecl *CDecl, bool SynthesizeProperties); + /// Diagnose any null-resettable synthesized setters. + void diagnoseNullResettableSynthesizedSetters(ObjCImplDecl *impDecl); + /// DefaultSynthesizeProperties - This routine default synthesizes all /// properties which must be synthesized in the class's \@implementation. void DefaultSynthesizeProperties (Scope *S, ObjCImplDecl* IMPDecl, @@ -2914,7 +3014,8 @@ public: const unsigned Attributes, const unsigned AttributesAsWritten, bool *isOverridingProperty, - TypeSourceInfo *T, + QualType T, + TypeSourceInfo *TSI, tok::ObjCKeywordKind MethodImplKind); /// Called by ActOnProperty and HandlePropertyInClassExtension to @@ -2930,7 +3031,8 @@ public: const bool isReadWrite, const unsigned Attributes, const unsigned AttributesAsWritten, - TypeSourceInfo *T, + QualType T, + TypeSourceInfo *TSI, tok::ObjCKeywordKind MethodImplKind, DeclContext *lexicalDC = nullptr); @@ -7629,6 +7731,9 @@ public: /// \brief Called on well-formed '\#pragma omp taskwait'. StmtResult ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc, SourceLocation EndLoc); + /// \brief Called on well-formed '\#pragma omp taskgroup'. + StmtResult ActOnOpenMPTaskgroupDirective(Stmt *AStmt, SourceLocation StartLoc, + SourceLocation EndLoc); /// \brief Called on well-formed '\#pragma omp flush'. StmtResult ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses, SourceLocation StartLoc, @@ -8557,9 +8662,10 @@ private: const FunctionProtoType *Proto, SourceLocation Loc); - void checkCall(NamedDecl *FDecl, ArrayRef<const Expr *> Args, - unsigned NumParams, bool IsMemberFunction, SourceLocation Loc, - SourceRange Range, VariadicCallType CallType); + void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, + ArrayRef<const Expr *> Args, bool IsMemberFunction, + SourceLocation Loc, SourceRange Range, + VariadicCallType CallType); bool CheckObjCString(Expr *Arg); @@ -8602,7 +8708,9 @@ private: llvm::APSInt &Result); bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low, int High); - + bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall, + int ArgNum, unsigned ExpectedFieldNum, + bool AllowName); public: enum FormatStringType { FST_Scanf, @@ -8731,6 +8839,13 @@ private: mutable IdentifierInfo *Ident_super; mutable IdentifierInfo *Ident___float128; + /// Nullability type specifiers. + IdentifierInfo *Ident___nonnull = nullptr; + IdentifierInfo *Ident___nullable = nullptr; + IdentifierInfo *Ident___null_unspecified = nullptr; + + IdentifierInfo *Ident_NSError = nullptr; + protected: friend class Parser; friend class InitializationSequence; @@ -8739,6 +8854,15 @@ protected: friend class ASTWriter; public: + /// Retrieve the keyword associated + IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability); + + /// The struct behind the CFErrorRef pointer. + RecordDecl *CFError = nullptr; + + /// Retrieve the identifier "NSError". + IdentifierInfo *getNSErrorIdent(); + /// \brief Retrieve the parser's current scope. /// /// This routine must only be used when it is certain that semantic analysis diff --git a/include/clang/Serialization/ASTBitCodes.h b/include/clang/Serialization/ASTBitCodes.h index e0f01c8a3545..83185a870ab1 100644 --- a/include/clang/Serialization/ASTBitCodes.h +++ b/include/clang/Serialization/ASTBitCodes.h @@ -1211,8 +1211,12 @@ namespace clang { EXPR_INIT_LIST, /// \brief A DesignatedInitExpr record. EXPR_DESIGNATED_INIT, + /// \brief A DesignatedInitUpdateExpr record. + EXPR_DESIGNATED_INIT_UPDATE, /// \brief An ImplicitValueInitExpr record. EXPR_IMPLICIT_VALUE_INIT, + /// \brief An NoInitExpr record. + EXPR_NO_INIT, /// \brief A VAArgExpr record. EXPR_VA_ARG, /// \brief An AddrLabelExpr record. @@ -1392,6 +1396,7 @@ namespace clang { STMT_OMP_ATOMIC_DIRECTIVE, STMT_OMP_TARGET_DIRECTIVE, STMT_OMP_TEAMS_DIRECTIVE, + STMT_OMP_TASKGROUP_DIRECTIVE, // ARC EXPR_OBJC_BRIDGED_CAST, // ObjCBridgedCastExpr diff --git a/include/clang/Serialization/ASTReader.h b/include/clang/Serialization/ASTReader.h index c7cc1be6e62c..429f00f852bb 100644 --- a/include/clang/Serialization/ASTReader.h +++ b/include/clang/Serialization/ASTReader.h @@ -362,6 +362,7 @@ private: SourceManager &SourceMgr; FileManager &FileMgr; + const PCHContainerOperations &PCHContainerOps; DiagnosticsEngine &Diags; /// \brief The semantic analysis object that will be processing the @@ -1237,6 +1238,9 @@ public: /// \param Context the AST context that this precompiled header will be /// loaded into. /// + /// \param PCHContainerOps the PCHContainerOperations to use for loading and + /// creating modules. + /// /// \param isysroot If non-NULL, the system include path specified by the /// user. This is only used with relocatable PCH files. If non-NULL, /// a relocatable PCH file will use the default path "/". @@ -1258,12 +1262,12 @@ public: /// /// \param UseGlobalIndex If true, the AST reader will try to load and use /// the global module index. - ASTReader(Preprocessor &PP, ASTContext &Context, StringRef isysroot = "", - bool DisableValidation = false, + ASTReader(Preprocessor &PP, ASTContext &Context, + const PCHContainerOperations &PCHContainerOps, + StringRef isysroot = "", bool DisableValidation = false, bool AllowASTWithCompilerErrors = false, bool AllowConfigurationMismatch = false, - bool ValidateSystemInputs = false, - bool UseGlobalIndex = true); + bool ValidateSystemInputs = false, bool UseGlobalIndex = true); ~ASTReader() override; @@ -1425,21 +1429,23 @@ public: /// \brief Retrieve the name of the original source file name directly from /// the AST file, without actually loading the AST file. - static std::string getOriginalSourceFile(const std::string &ASTFileName, - FileManager &FileMgr, - DiagnosticsEngine &Diags); + static std::string + getOriginalSourceFile(const std::string &ASTFileName, FileManager &FileMgr, + const PCHContainerOperations &PCHContainerOps, + DiagnosticsEngine &Diags); /// \brief Read the control block for the named AST file. /// /// \returns true if an error occurred, false otherwise. - static bool readASTFileControlBlock(StringRef Filename, - FileManager &FileMgr, - ASTReaderListener &Listener); + static bool + readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, + const PCHContainerOperations &PCHContainerOps, + ASTReaderListener &Listener); /// \brief Determine whether the given AST file is acceptable to load into a /// translation unit with the given language and target options. - static bool isAcceptableASTFile(StringRef Filename, - FileManager &FileMgr, + static bool isAcceptableASTFile(StringRef Filename, FileManager &FileMgr, + const PCHContainerOperations &PCHContainerOps, const LangOptions &LangOpts, const TargetOptions &TargetOpts, const PreprocessorOptions &PPOpts, diff --git a/include/clang/Serialization/ASTWriter.h b/include/clang/Serialization/ASTWriter.h index 297ee22dfa68..decd07a00ed5 100644 --- a/include/clang/Serialization/ASTWriter.h +++ b/include/clang/Serialization/ASTWriter.h @@ -17,6 +17,7 @@ #include "clang/AST/ASTMutationListener.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclarationName.h" +#include "clang/Frontend/PCHContainerOperations.h" #include "clang/AST/TemplateBase.h" #include "clang/Sema/SemaConsumer.h" #include "clang/Serialization/ASTBitCodes.h" @@ -868,30 +869,28 @@ class PCHGenerator : public SemaConsumer { std::string OutputFile; clang::Module *Module; std::string isysroot; - raw_ostream *Out; Sema *SemaPtr; - SmallVector<char, 128> Buffer; + std::shared_ptr<PCHBuffer> Buffer; llvm::BitstreamWriter Stream; ASTWriter Writer; bool AllowASTWithErrors; - bool HasEmittedPCH; protected: ASTWriter &getWriter() { return Writer; } const ASTWriter &getWriter() const { return Writer; } + SmallVectorImpl<char> &getPCH() const { return Buffer->Data; } public: PCHGenerator(const Preprocessor &PP, StringRef OutputFile, - clang::Module *Module, - StringRef isysroot, raw_ostream *Out, + clang::Module *Module, StringRef isysroot, + std::shared_ptr<PCHBuffer> Buffer, bool AllowASTWithErrors = false); ~PCHGenerator() override; void InitializeSema(Sema &S) override { SemaPtr = &S; } void HandleTranslationUnit(ASTContext &Ctx) override; ASTMutationListener *GetASTMutationListener() override; ASTDeserializationListener *GetASTDeserializationListener() override; - - bool hasEmittedPCH() const { return HasEmittedPCH; } + bool hasEmittedPCH() const { return Buffer->IsComplete; } }; } // end namespace clang diff --git a/include/clang/Serialization/GlobalModuleIndex.h b/include/clang/Serialization/GlobalModuleIndex.h index 640c7bb34454..7e205106c4ee 100644 --- a/include/clang/Serialization/GlobalModuleIndex.h +++ b/include/clang/Serialization/GlobalModuleIndex.h @@ -35,6 +35,7 @@ class DirectoryEntry; class FileEntry; class FileManager; class IdentifierIterator; +class PCHContainerOperations; namespace serialization { class ModuleFile; @@ -192,10 +193,13 @@ public: /// \brief Write a global index into the given /// /// \param FileMgr The file manager to use to load module files. - /// + /// \param PCHContainerOps - The PCHContainerOperations to use for loading and + /// creating modules. /// \param Path The path to the directory containing module files, into /// which the global index will be written. - static ErrorCode writeIndex(FileManager &FileMgr, StringRef Path); + static ErrorCode writeIndex(FileManager &FileMgr, + const PCHContainerOperations &PCHContainerOps, + StringRef Path); }; } diff --git a/include/clang/Serialization/ModuleManager.h b/include/clang/Serialization/ModuleManager.h index 3de86feb66b9..ea4b57fa3ace 100644 --- a/include/clang/Serialization/ModuleManager.h +++ b/include/clang/Serialization/ModuleManager.h @@ -24,6 +24,7 @@ namespace clang { class GlobalModuleIndex; class ModuleMap; +class PCHContainerOperations; namespace serialization { @@ -49,7 +50,10 @@ class ModuleManager { /// \brief FileManager that handles translating between filenames and /// FileEntry *. FileManager &FileMgr; - + + /// \brief Knows how to unwrap module containers. + const PCHContainerOperations &PCHContainerOps; + /// \brief A lookup of in-memory (virtual file) buffers llvm::DenseMap<const FileEntry *, std::unique_ptr<llvm::MemoryBuffer>> InMemoryBuffers; @@ -112,8 +116,9 @@ public: typedef SmallVectorImpl<ModuleFile*>::const_iterator ModuleConstIterator; typedef SmallVectorImpl<ModuleFile*>::reverse_iterator ModuleReverseIterator; typedef std::pair<uint32_t, StringRef> ModuleOffset; - - explicit ModuleManager(FileManager &FileMgr); + + explicit ModuleManager(FileManager &FileMgr, + const PCHContainerOperations &PCHContainerOps); ~ModuleManager(); /// \brief Forward iterator to traverse all loaded modules. This is reverse diff --git a/include/clang/StaticAnalyzer/Checkers/ObjCRetainCount.h b/include/clang/StaticAnalyzer/Checkers/ObjCRetainCount.h index ab92a2465c53..5850656916e3 100644 --- a/include/clang/StaticAnalyzer/Checkers/ObjCRetainCount.h +++ b/include/clang/StaticAnalyzer/Checkers/ObjCRetainCount.h @@ -69,6 +69,14 @@ enum ArgEffect { /// transfers the object to the Garbage Collector under GC. MakeCollectable, + /// The argument is a pointer to a retain-counted object; on exit, the new + /// value of the pointer is a +0 value or NULL. + UnretainedOutParameter, + + /// The argument is a pointer to a retain-counted object; on exit, the new + /// value of the pointer is a +1 value or NULL. + RetainedOutParameter, + /// The argument is treated as potentially escaping, meaning that /// even when its reference count hits 0 it should be treated as still /// possibly being alive as someone else *may* be holding onto the object. diff --git a/include/clang/Tooling/Refactoring.h b/include/clang/Tooling/Refactoring.h index e3e7f83c38c8..944fd41f85c1 100644 --- a/include/clang/Tooling/Refactoring.h +++ b/include/clang/Tooling/Refactoring.h @@ -38,7 +38,9 @@ class RefactoringTool : public ClangTool { public: /// \see ClangTool::ClangTool. RefactoringTool(const CompilationDatabase &Compilations, - ArrayRef<std::string> SourcePaths); + ArrayRef<std::string> SourcePaths, + std::shared_ptr<PCHContainerOperations> PCHContainerOps = + std::make_shared<RawPCHContainerOperations>()); /// \brief Returns the set of replacements to which replacements should /// be added during the run of the tool. diff --git a/include/clang/Tooling/Tooling.h b/include/clang/Tooling/Tooling.h index ca187b168448..fb887e1df9e8 100644 --- a/include/clang/Tooling/Tooling.h +++ b/include/clang/Tooling/Tooling.h @@ -31,11 +31,13 @@ #define LLVM_CLANG_TOOLING_TOOLING_H #include "clang/AST/ASTConsumer.h" +#include "clang/Frontend/PCHContainerOperations.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/LLVM.h" #include "clang/Driver/Util.h" #include "clang/Frontend/FrontendAction.h" +#include "clang/Lex/ModuleLoader.h" #include "clang/Tooling/ArgumentsAdjusters.h" #include "clang/Tooling/CompilationDatabase.h" #include "llvm/ADT/StringMap.h" @@ -66,9 +68,10 @@ public: virtual ~ToolAction(); /// \brief Perform an action for an invocation. - virtual bool runInvocation(clang::CompilerInvocation *Invocation, - FileManager *Files, - DiagnosticConsumer *DiagConsumer) = 0; + virtual bool + runInvocation(clang::CompilerInvocation *Invocation, FileManager *Files, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + DiagnosticConsumer *DiagConsumer) = 0; }; /// \brief Interface to generate clang::FrontendActions. @@ -83,6 +86,7 @@ public: /// \brief Invokes the compiler with a FrontendAction created by create(). bool runInvocation(clang::CompilerInvocation *Invocation, FileManager *Files, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, DiagnosticConsumer *DiagConsumer) override; /// \brief Returns a new clang::FrontendAction. @@ -139,10 +143,14 @@ inline std::unique_ptr<FrontendActionFactory> newFrontendActionFactory( /// \param ToolAction The action to run over the code. /// \param Code C++ code. /// \param FileName The file name which 'Code' will be mapped as. +/// \param PCHContainerOps The PCHContainerOperations for loading and creating +/// clang modules. /// /// \return - True if 'ToolAction' was successfully executed. bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code, - const Twine &FileName = "input.cc"); + const Twine &FileName = "input.cc", + std::shared_ptr<PCHContainerOperations> PCHContainerOps = + std::make_shared<RawPCHContainerOperations>()); /// The first part of the pair is the filename, the second part the /// file-content. @@ -155,37 +163,48 @@ typedef std::vector<std::pair<std::string, std::string>> FileContentMappings; /// \param Code C++ code. /// \param Args Additional flags to pass on. /// \param FileName The file name which 'Code' will be mapped as. +/// \param PCHContainerOps The PCHContainerOperations for loading and creating +/// clang modules. /// /// \return - True if 'ToolAction' was successfully executed. bool runToolOnCodeWithArgs( clang::FrontendAction *ToolAction, const Twine &Code, const std::vector<std::string> &Args, const Twine &FileName = "input.cc", + std::shared_ptr<PCHContainerOperations> PCHContainerOps = + std::make_shared<RawPCHContainerOperations>(), const FileContentMappings &VirtualMappedFiles = FileContentMappings()); /// \brief Builds an AST for 'Code'. /// /// \param Code C++ code. /// \param FileName The file name which 'Code' will be mapped as. +/// \param PCHContainerOps The PCHContainerOperations for loading and creating +/// clang modules. /// /// \return The resulting AST or null if an error occurred. -std::unique_ptr<ASTUnit> buildASTFromCode(const Twine &Code, - const Twine &FileName = "input.cc"); +std::unique_ptr<ASTUnit> +buildASTFromCode(const Twine &Code, const Twine &FileName = "input.cc", + std::shared_ptr<PCHContainerOperations> PCHContainerOps = + std::make_shared<RawPCHContainerOperations>()); /// \brief Builds an AST for 'Code' with additional flags. /// /// \param Code C++ code. /// \param Args Additional flags to pass on. /// \param FileName The file name which 'Code' will be mapped as. +/// \param PCHContainerOps The PCHContainerOperations for loading and creating +/// clang modules. /// /// \return The resulting AST or null if an error occurred. -std::unique_ptr<ASTUnit> -buildASTFromCodeWithArgs(const Twine &Code, - const std::vector<std::string> &Args, - const Twine &FileName = "input.cc"); +std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs( + const Twine &Code, const std::vector<std::string> &Args, + const Twine &FileName = "input.cc", + std::shared_ptr<PCHContainerOperations> PCHContainerOps = + std::make_shared<RawPCHContainerOperations>()); /// \brief Utility to run a FrontendAction in a single clang invocation. class ToolInvocation { - public: +public: /// \brief Create a tool invocation. /// /// \param CommandLine The command line arguments to clang. Note that clang @@ -195,16 +214,23 @@ class ToolInvocation { /// \param FAction The action to be executed. Class takes ownership. /// \param Files The FileManager used for the execution. Class does not take /// ownership. + /// \param PCHContainerOps The PCHContainerOperations for loading and creating + /// clang modules. ToolInvocation(std::vector<std::string> CommandLine, FrontendAction *FAction, - FileManager *Files); + FileManager *Files, + std::shared_ptr<PCHContainerOperations> PCHContainerOps = + std::make_shared<RawPCHContainerOperations>()); /// \brief Create a tool invocation. /// /// \param CommandLine The command line arguments to clang. /// \param Action The action to be executed. /// \param Files The FileManager used for the execution. + /// \param PCHContainerOps The PCHContainerOperations for loading and creating + /// clang modules. ToolInvocation(std::vector<std::string> CommandLine, ToolAction *Action, - FileManager *Files); + FileManager *Files, + std::shared_ptr<PCHContainerOperations> PCHContainerOps); ~ToolInvocation(); @@ -229,12 +255,14 @@ class ToolInvocation { bool runInvocation(const char *BinaryName, clang::driver::Compilation *Compilation, - clang::CompilerInvocation *Invocation); + clang::CompilerInvocation *Invocation, + std::shared_ptr<PCHContainerOperations> PCHContainerOps); std::vector<std::string> CommandLine; ToolAction *Action; bool OwnsAction; FileManager *Files; + std::shared_ptr<PCHContainerOperations> PCHContainerOps; // Maps <file name> -> <file content>. llvm::StringMap<StringRef> MappedFileContents; DiagnosticConsumer *DiagConsumer; @@ -255,8 +283,12 @@ class ClangTool { /// command lines for the given source paths. /// \param SourcePaths The source files to run over. If a source files is /// not found in Compilations, it is skipped. + /// \param PCHContainerOps The PCHContainerOperations for loading and creating + /// clang modules. ClangTool(const CompilationDatabase &Compilations, - ArrayRef<std::string> SourcePaths); + ArrayRef<std::string> SourcePaths, + std::shared_ptr<PCHContainerOperations> PCHContainerOps = + std::make_shared<RawPCHContainerOperations>()); ~ClangTool(); @@ -297,6 +329,7 @@ class ClangTool { private: const CompilationDatabase &Compilations; std::vector<std::string> SourcePaths; + std::shared_ptr<PCHContainerOperations> PCHContainerOps; llvm::IntrusiveRefCntPtr<FileManager> Files; // Contains a list of pairs (<file name>, <file content>). diff --git a/lib/ARCMigrate/ARCMT.cpp b/lib/ARCMigrate/ARCMT.cpp index f266eaf83968..f33ad21cf029 100644 --- a/lib/ARCMigrate/ARCMT.cpp +++ b/lib/ARCMigrate/ARCMT.cpp @@ -166,7 +166,8 @@ static bool HasARCRuntime(CompilerInvocation &origCI) { } static CompilerInvocation * -createInvocationForMigration(CompilerInvocation &origCI) { +createInvocationForMigration(CompilerInvocation &origCI, + const PCHContainerOperations &PCHContainerOps) { std::unique_ptr<CompilerInvocation> CInvok; CInvok.reset(new CompilerInvocation(origCI)); PreprocessorOptions &PPOpts = CInvok->getPreprocessorOpts(); @@ -178,9 +179,8 @@ createInvocationForMigration(CompilerInvocation &origCI) { IntrusiveRefCntPtr<DiagnosticsEngine> Diags( new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(), new IgnoringDiagConsumer())); - std::string OriginalFile = - ASTReader::getOriginalSourceFile(PPOpts.ImplicitPCHInclude, - FileMgr, *Diags); + std::string OriginalFile = ASTReader::getOriginalSourceFile( + PPOpts.ImplicitPCHInclude, FileMgr, PCHContainerOps, *Diags); if (!OriginalFile.empty()) PPOpts.Includes.insert(PPOpts.Includes.begin(), OriginalFile); PPOpts.ImplicitPCHInclude.clear(); @@ -230,11 +230,11 @@ static void emitPremigrationErrors(const CapturedDiagList &arcDiags, // checkForManualIssues. //===----------------------------------------------------------------------===// -bool arcmt::checkForManualIssues(CompilerInvocation &origCI, - const FrontendInputFile &Input, - DiagnosticConsumer *DiagClient, - bool emitPremigrationARCErrors, - StringRef plistOut) { +bool arcmt::checkForManualIssues( + CompilerInvocation &origCI, const FrontendInputFile &Input, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + DiagnosticConsumer *DiagClient, bool emitPremigrationARCErrors, + StringRef plistOut) { if (!origCI.getLangOpts()->ObjC1) return false; @@ -247,7 +247,7 @@ bool arcmt::checkForManualIssues(CompilerInvocation &origCI, assert(!transforms.empty()); std::unique_ptr<CompilerInvocation> CInvok; - CInvok.reset(createInvocationForMigration(origCI)); + CInvok.reset(createInvocationForMigration(origCI, *PCHContainerOps)); CInvok->getFrontendOpts().Inputs.clear(); CInvok->getFrontendOpts().Inputs.push_back(Input); @@ -263,8 +263,8 @@ bool arcmt::checkForManualIssues(CompilerInvocation &origCI, CaptureDiagnosticConsumer errRec(*Diags, *DiagClient, capturedDiags); Diags->setClient(&errRec, /*ShouldOwnClient=*/false); - std::unique_ptr<ASTUnit> Unit( - ASTUnit::LoadFromCompilerInvocationAction(CInvok.release(), Diags)); + std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction( + CInvok.release(), PCHContainerOps, Diags)); if (!Unit) { errRec.FinishCapture(); return true; @@ -330,12 +330,11 @@ bool arcmt::checkForManualIssues(CompilerInvocation &origCI, // applyTransformations. //===----------------------------------------------------------------------===// -static bool applyTransforms(CompilerInvocation &origCI, - const FrontendInputFile &Input, - DiagnosticConsumer *DiagClient, - StringRef outputDir, - bool emitPremigrationARCErrors, - StringRef plistOut) { +static bool +applyTransforms(CompilerInvocation &origCI, const FrontendInputFile &Input, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + DiagnosticConsumer *DiagClient, StringRef outputDir, + bool emitPremigrationARCErrors, StringRef plistOut) { if (!origCI.getLangOpts()->ObjC1) return false; @@ -343,15 +342,16 @@ static bool applyTransforms(CompilerInvocation &origCI, // Make sure checking is successful first. CompilerInvocation CInvokForCheck(origCI); - if (arcmt::checkForManualIssues(CInvokForCheck, Input, DiagClient, - emitPremigrationARCErrors, plistOut)) + if (arcmt::checkForManualIssues(CInvokForCheck, Input, PCHContainerOps, + DiagClient, emitPremigrationARCErrors, + plistOut)) return true; CompilerInvocation CInvok(origCI); CInvok.getFrontendOpts().Inputs.clear(); CInvok.getFrontendOpts().Inputs.push_back(Input); - - MigrationProcess migration(CInvok, DiagClient, outputDir); + + MigrationProcess migration(CInvok, PCHContainerOps, DiagClient, outputDir); bool NoFinalizeRemoval = origCI.getMigratorOpts().NoFinalizeRemoval; std::vector<TransformFn> transforms = arcmt::getAllTransformations(OrigGCMode, @@ -376,22 +376,22 @@ static bool applyTransforms(CompilerInvocation &origCI, } } -bool arcmt::applyTransformations(CompilerInvocation &origCI, - const FrontendInputFile &Input, - DiagnosticConsumer *DiagClient) { - return applyTransforms(origCI, Input, DiagClient, +bool arcmt::applyTransformations( + CompilerInvocation &origCI, const FrontendInputFile &Input, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + DiagnosticConsumer *DiagClient) { + return applyTransforms(origCI, Input, PCHContainerOps, DiagClient, StringRef(), false, StringRef()); } -bool arcmt::migrateWithTemporaryFiles(CompilerInvocation &origCI, - const FrontendInputFile &Input, - DiagnosticConsumer *DiagClient, - StringRef outputDir, - bool emitPremigrationARCErrors, - StringRef plistOut) { +bool arcmt::migrateWithTemporaryFiles( + CompilerInvocation &origCI, const FrontendInputFile &Input, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + DiagnosticConsumer *DiagClient, StringRef outputDir, + bool emitPremigrationARCErrors, StringRef plistOut) { assert(!outputDir.empty() && "Expected output directory path"); - return applyTransforms(origCI, Input, DiagClient, - outputDir, emitPremigrationARCErrors, plistOut); + return applyTransforms(origCI, Input, PCHContainerOps, DiagClient, outputDir, + emitPremigrationARCErrors, plistOut); } bool arcmt::getFileRemappings(std::vector<std::pair<std::string,std::string> > & @@ -499,10 +499,12 @@ public: /// \brief Anchor for VTable. MigrationProcess::RewriteListener::~RewriteListener() { } -MigrationProcess::MigrationProcess(const CompilerInvocation &CI, - DiagnosticConsumer *diagClient, - StringRef outputDir) - : OrigCI(CI), DiagClient(diagClient), HadARCErrors(false) { +MigrationProcess::MigrationProcess( + const CompilerInvocation &CI, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + DiagnosticConsumer *diagClient, StringRef outputDir) + : OrigCI(CI), PCHContainerOps(PCHContainerOps), DiagClient(diagClient), + HadARCErrors(false) { if (!outputDir.empty()) { IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); IntrusiveRefCntPtr<DiagnosticsEngine> Diags( @@ -515,7 +517,7 @@ MigrationProcess::MigrationProcess(const CompilerInvocation &CI, bool MigrationProcess::applyTransform(TransformFn trans, RewriteListener *listener) { std::unique_ptr<CompilerInvocation> CInvok; - CInvok.reset(createInvocationForMigration(OrigCI)); + CInvok.reset(createInvocationForMigration(OrigCI, *PCHContainerOps)); CInvok->getDiagnosticOpts().IgnoreWarnings = true; Remapper.applyMappings(CInvok->getPreprocessorOpts()); @@ -537,7 +539,7 @@ bool MigrationProcess::applyTransform(TransformFn trans, ASTAction.reset(new ARCMTMacroTrackerAction(ARCMTMacroLocs)); std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction( - CInvok.release(), Diags, ASTAction.get())); + CInvok.release(), PCHContainerOps, Diags, ASTAction.get())); if (!Unit) { errRec.FinishCapture(); return true; diff --git a/lib/ARCMigrate/ARCMTActions.cpp b/lib/ARCMigrate/ARCMTActions.cpp index 0ed36ddf68c8..39a922f426c3 100644 --- a/lib/ARCMigrate/ARCMTActions.cpp +++ b/lib/ARCMigrate/ARCMTActions.cpp @@ -16,6 +16,7 @@ using namespace arcmt; bool CheckAction::BeginInvocation(CompilerInstance &CI) { if (arcmt::checkForManualIssues(CI.getInvocation(), getCurrentInput(), + CI.getPCHContainerOperations(), CI.getDiagnostics().getClient())) return false; // errors, stop the action. @@ -29,6 +30,7 @@ CheckAction::CheckAction(FrontendAction *WrappedAction) bool ModifyAction::BeginInvocation(CompilerInstance &CI) { return !arcmt::applyTransformations(CI.getInvocation(), getCurrentInput(), + CI.getPCHContainerOperations(), CI.getDiagnostics().getClient()); } @@ -36,12 +38,10 @@ ModifyAction::ModifyAction(FrontendAction *WrappedAction) : WrapperFrontendAction(WrappedAction) {} bool MigrateAction::BeginInvocation(CompilerInstance &CI) { - if (arcmt::migrateWithTemporaryFiles(CI.getInvocation(), - getCurrentInput(), - CI.getDiagnostics().getClient(), - MigrateDir, - EmitPremigrationARCErros, - PlistOut)) + if (arcmt::migrateWithTemporaryFiles( + CI.getInvocation(), getCurrentInput(), CI.getPCHContainerOperations(), + CI.getDiagnostics().getClient(), MigrateDir, EmitPremigrationARCErros, + PlistOut)) return false; // errors, stop the action. // We only want to see diagnostics emitted by migrateWithTemporaryFiles. diff --git a/lib/AST/ASTConsumer.cpp b/lib/AST/ASTConsumer.cpp index 55033b238c66..cff82e9b1003 100644 --- a/lib/AST/ASTConsumer.cpp +++ b/lib/AST/ASTConsumer.cpp @@ -12,6 +12,7 @@ //===----------------------------------------------------------------------===// #include "clang/AST/ASTConsumer.h" +#include "llvm/Bitcode/BitstreamReader.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclGroup.h" using namespace clang; diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp index 4a831d90e645..049eebd82b66 100644 --- a/lib/AST/ASTContext.cpp +++ b/lib/AST/ASTContext.cpp @@ -5610,8 +5610,7 @@ void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, // @encode(class_name) ObjCInterfaceDecl *OI = OIT->getDecl(); S += '{'; - const IdentifierInfo *II = OI->getIdentifier(); - S += II->getName(); + S += OI->getObjCRuntimeNameAsString(); S += '='; SmallVector<const ObjCIvarDecl*, 32> Ivars; DeepCollectObjCIvars(OI, true, Ivars); @@ -5654,7 +5653,7 @@ void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, S += '"'; for (const auto *I : OPT->quals()) { S += '<'; - S += I->getNameAsString(); + S += I->getObjCRuntimeNameAsString(); S += '>'; } S += '"'; @@ -5678,7 +5677,7 @@ void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, for (unsigned i = 0, e = Ivars.size(); i != e; ++i) { if (cast<FieldDecl>(Ivars[i]) == FD) { S += '{'; - S += OI->getIdentifier()->getName(); + S += OI->getObjCRuntimeNameAsString(); S += '}'; return; } @@ -5696,10 +5695,10 @@ void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, if (OPT->getInterfaceDecl() && (FD || EncodingProperty || EncodeClassNames)) { S += '"'; - S += OPT->getInterfaceDecl()->getIdentifier()->getName(); + S += OPT->getInterfaceDecl()->getObjCRuntimeNameAsString(); for (const auto *I : OPT->quals()) { S += '<'; - S += I->getNameAsString(); + S += I->getObjCRuntimeNameAsString(); S += '>'; } S += '"'; diff --git a/lib/AST/ASTImporter.cpp b/lib/AST/ASTImporter.cpp index 911f1681ce61..76e4e1191501 100644 --- a/lib/AST/ASTImporter.cpp +++ b/lib/AST/ASTImporter.cpp @@ -3922,8 +3922,8 @@ Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { } // Import the type. - TypeSourceInfo *T = Importer.Import(D->getTypeSourceInfo()); - if (!T) + TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo()); + if (!TSI) return nullptr; // Create the new property. @@ -3932,7 +3932,8 @@ Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { Name.getAsIdentifierInfo(), Importer.Import(D->getAtLoc()), Importer.Import(D->getLParenLoc()), - T, + Importer.Import(D->getType()), + TSI, D->getPropertyImplementation()); Importer.Imported(D, ToProperty); ToProperty->setLexicalDeclContext(LexicalDC); diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp index 8eff4c4427b3..d9a3389c58f3 100644 --- a/lib/AST/Decl.cpp +++ b/lib/AST/Decl.cpp @@ -3681,7 +3681,8 @@ void RecordDecl::LoadFieldsFromExternalStorage() const { bool RecordDecl::mayInsertExtraPadding(bool EmitRemark) const { ASTContext &Context = getASTContext(); - if (!Context.getLangOpts().Sanitize.has(SanitizerKind::Address) || + if (!Context.getLangOpts().Sanitize.hasOneOf( + SanitizerKind::Address | SanitizerKind::KernelAddress) || !Context.getLangOpts().SanitizeAddressFieldPadding) return false; const auto &Blacklist = Context.getSanitizerBlacklist(); diff --git a/lib/AST/DeclObjC.cpp b/lib/AST/DeclObjC.cpp index a63ba7e698a8..a1600cb11014 100644 --- a/lib/AST/DeclObjC.cpp +++ b/lib/AST/DeclObjC.cpp @@ -1862,16 +1862,18 @@ ObjCPropertyDecl *ObjCPropertyDecl::Create(ASTContext &C, DeclContext *DC, IdentifierInfo *Id, SourceLocation AtLoc, SourceLocation LParenLoc, - TypeSourceInfo *T, + QualType T, + TypeSourceInfo *TSI, PropertyControl propControl) { - return new (C, DC) ObjCPropertyDecl(DC, L, Id, AtLoc, LParenLoc, T); + return new (C, DC) ObjCPropertyDecl(DC, L, Id, AtLoc, LParenLoc, T, TSI, + propControl); } ObjCPropertyDecl *ObjCPropertyDecl::CreateDeserialized(ASTContext &C, unsigned ID) { return new (C, ID) ObjCPropertyDecl(nullptr, SourceLocation(), nullptr, SourceLocation(), SourceLocation(), - nullptr); + QualType(), nullptr, None); } //===----------------------------------------------------------------------===// diff --git a/lib/AST/DeclPrinter.cpp b/lib/AST/DeclPrinter.cpp index d8cd40ec9c60..c3ce47600972 100644 --- a/lib/AST/DeclPrinter.cpp +++ b/lib/AST/DeclPrinter.cpp @@ -37,6 +37,13 @@ namespace { void Print(AccessSpecifier AS); + /// Print an Objective-C method type in parentheses. + /// + /// \param Quals The Objective-C declaration qualifiers. + /// \param T The type to print. + void PrintObjCMethodType(ASTContext &Ctx, Decl::ObjCDeclQualifier Quals, + QualType T); + public: DeclPrinter(raw_ostream &Out, const PrintingPolicy &Policy, unsigned Indentation = 0, bool PrintInstantiation = false) @@ -930,24 +937,52 @@ void DeclPrinter::VisitClassTemplateDecl(ClassTemplateDecl *D) { // Objective-C declarations //---------------------------------------------------------------------------- +void DeclPrinter::PrintObjCMethodType(ASTContext &Ctx, + Decl::ObjCDeclQualifier Quals, + QualType T) { + Out << '('; + if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_In) + Out << "in "; + if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Inout) + Out << "inout "; + if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Out) + Out << "out "; + if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Bycopy) + Out << "bycopy "; + if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Byref) + Out << "byref "; + if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Oneway) + Out << "oneway "; + if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_CSNullability) { + if (auto nullability = AttributedType::stripOuterNullability(T)) { + Out << getNullabilitySpelling(*nullability).substr(2) << ' '; + } + } + + Out << Ctx.getUnqualifiedObjCPointerType(T).getAsString(Policy); + Out << ')'; +} + void DeclPrinter::VisitObjCMethodDecl(ObjCMethodDecl *OMD) { if (OMD->isInstanceMethod()) Out << "- "; else Out << "+ "; - if (!OMD->getReturnType().isNull()) - Out << '(' << OMD->getASTContext() - .getUnqualifiedObjCPointerType(OMD->getReturnType()) - .getAsString(Policy) << ")"; + if (!OMD->getReturnType().isNull()) { + PrintObjCMethodType(OMD->getASTContext(), OMD->getObjCDeclQualifier(), + OMD->getReturnType()); + } std::string name = OMD->getSelector().getAsString(); std::string::size_type pos, lastPos = 0; for (const auto *PI : OMD->params()) { // FIXME: selector is missing here! pos = name.find_first_of(':', lastPos); - Out << " " << name.substr(lastPos, pos - lastPos); - Out << ":(" << PI->getASTContext().getUnqualifiedObjCPointerType(PI->getType()). - getAsString(Policy) << ')' << *PI; + Out << " " << name.substr(lastPos, pos - lastPos) << ':'; + PrintObjCMethodType(OMD->getASTContext(), + PI->getObjCDeclQualifier(), + PI->getType()); + Out << *PI; lastPos = pos + 1; } @@ -1103,6 +1138,8 @@ void DeclPrinter::VisitObjCPropertyDecl(ObjCPropertyDecl *PDecl) { else if (PDecl->getPropertyImplementation() == ObjCPropertyDecl::Optional) Out << "@optional\n"; + QualType T = PDecl->getType(); + Out << "@property"; if (PDecl->getPropertyAttributes() != ObjCPropertyDecl::OBJC_PR_noattr) { bool first = true; @@ -1161,10 +1198,25 @@ void DeclPrinter::VisitObjCPropertyDecl(ObjCPropertyDecl *PDecl) { first = false; } + if (PDecl->getPropertyAttributes() & + ObjCPropertyDecl::OBJC_PR_nullability) { + if (auto nullability = AttributedType::stripOuterNullability(T)) { + if (*nullability == NullabilityKind::Unspecified && + (PDecl->getPropertyAttributes() & + ObjCPropertyDecl::OBJC_PR_null_resettable)) { + Out << (first ? ' ' : ',') << "null_resettable"; + } else { + Out << (first ? ' ' : ',') + << getNullabilitySpelling(*nullability).substr(2); + } + first = false; + } + } + (void) first; // Silence dead store warning due to idiomatic code. Out << " )"; } - Out << ' ' << PDecl->getASTContext().getUnqualifiedObjCPointerType(PDecl->getType()). + Out << ' ' << PDecl->getASTContext().getUnqualifiedObjCPointerType(T). getAsString(Policy) << ' ' << *PDecl; if (Policy.PolishForDeclaration) Out << ';'; diff --git a/lib/AST/DeclTemplate.cpp b/lib/AST/DeclTemplate.cpp index 6374a92621a4..cde497b012e2 100644 --- a/lib/AST/DeclTemplate.cpp +++ b/lib/AST/DeclTemplate.cpp @@ -124,6 +124,12 @@ static void AdoptTemplateParameterList(TemplateParameterList *Params, } } +namespace clang { +void *allocateDefaultArgStorageChain(const ASTContext &C) { + return new (C) char[sizeof(void*) * 2]; +} +} + //===----------------------------------------------------------------------===// // RedeclarableTemplateDecl Implementation //===----------------------------------------------------------------------===// @@ -504,14 +510,14 @@ TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID) { SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const { return hasDefaultArgument() - ? DefaultArgument->getTypeLoc().getBeginLoc() - : SourceLocation(); + ? getDefaultArgumentInfo()->getTypeLoc().getBeginLoc() + : SourceLocation(); } SourceRange TemplateTypeParmDecl::getSourceRange() const { if (hasDefaultArgument() && !defaultArgumentWasInherited()) return SourceRange(getLocStart(), - DefaultArgument->getTypeLoc().getEndLoc()); + getDefaultArgumentInfo()->getTypeLoc().getEndLoc()); else return TypeDecl::getSourceRange(); } @@ -543,10 +549,8 @@ NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(DeclContext *DC, unsigned NumExpandedTypes, TypeSourceInfo **ExpandedTInfos) : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc), - TemplateParmPosition(D, P), DefaultArgumentAndInherited(nullptr, false), - ParameterPack(true), ExpandedParameterPack(true), - NumExpandedTypes(NumExpandedTypes) -{ + TemplateParmPosition(D, P), ParameterPack(true), + ExpandedParameterPack(true), NumExpandedTypes(NumExpandedTypes) { if (ExpandedTypes && ExpandedTInfos) { void **TypesAndInfos = reinterpret_cast<void **>(this + 1); for (unsigned I = 0; I != NumExpandedTypes; ++I) { @@ -621,8 +625,7 @@ TemplateTemplateParmDecl::TemplateTemplateParmDecl( IdentifierInfo *Id, TemplateParameterList *Params, unsigned NumExpansions, TemplateParameterList * const *Expansions) : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params), - TemplateParmPosition(D, P), DefaultArgument(), - DefaultArgumentWasInherited(false), ParameterPack(true), + TemplateParmPosition(D, P), ParameterPack(true), ExpandedParameterPack(true), NumExpandedParams(NumExpansions) { if (Expansions) std::memcpy(reinterpret_cast<void*>(this + 1), Expansions, @@ -663,6 +666,19 @@ TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID, nullptr, NumExpansions, nullptr); } +SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const { + return hasDefaultArgument() ? getDefaultArgument().getLocation() + : SourceLocation(); +} + +void TemplateTemplateParmDecl::setDefaultArgument( + const ASTContext &C, const TemplateArgumentLoc &DefArg) { + if (DefArg.getArgument().isNull()) + DefaultArgument.set(nullptr); + else + DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg)); +} + //===----------------------------------------------------------------------===// // TemplateArgumentList Implementation //===----------------------------------------------------------------------===// diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp index 76a4da2371b5..36f4139f8352 100644 --- a/lib/AST/Expr.cpp +++ b/lib/AST/Expr.cpp @@ -1238,7 +1238,7 @@ unsigned CallExpr::getBuiltinCallee() const { return FDecl->getBuiltinID(); } -bool CallExpr::isUnevaluatedBuiltinCall(ASTContext &Ctx) const { +bool CallExpr::isUnevaluatedBuiltinCall(const ASTContext &Ctx) const { if (unsigned BI = getBuiltinCallee()) return Ctx.BuiltinInfo.isUnevaluated(BI); return false; @@ -2772,6 +2772,11 @@ bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef, const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer(); return Exp->isConstantInitializer(Ctx, false, Culprit); } + case DesignatedInitUpdateExprClass: { + const DesignatedInitUpdateExpr *DIUE = cast<DesignatedInitUpdateExpr>(this); + return DIUE->getBase()->isConstantInitializer(Ctx, false, Culprit) && + DIUE->getUpdater()->isConstantInitializer(Ctx, false, Culprit); + } case InitListExprClass: { const InitListExpr *ILE = cast<InitListExpr>(this); if (ILE->getType()->isArrayType()) { @@ -2818,6 +2823,7 @@ bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef, break; } case ImplicitValueInitExprClass: + case NoInitExprClass: return true; case ParenExprClass: return cast<ParenExpr>(this)->getSubExpr() @@ -2881,6 +2887,28 @@ bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef, return false; } +namespace { + /// \brief Look for any side effects within a Stmt. + class SideEffectFinder : public ConstEvaluatedExprVisitor<SideEffectFinder> { + typedef ConstEvaluatedExprVisitor<SideEffectFinder> Inherited; + const bool IncludePossibleEffects; + bool HasSideEffects; + + public: + explicit SideEffectFinder(const ASTContext &Context, bool IncludePossible) + : Inherited(Context), + IncludePossibleEffects(IncludePossible), HasSideEffects(false) { } + + bool hasSideEffects() const { return HasSideEffects; } + + void VisitExpr(const Expr *E) { + if (!HasSideEffects && + E->HasSideEffects(Context, IncludePossibleEffects)) + HasSideEffects = true; + } + }; +} + bool Expr::HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects) const { // In circumstances where we care about definite side effects instead of @@ -2925,6 +2953,7 @@ bool Expr::HasSideEffects(const ASTContext &Ctx, case UnaryExprOrTypeTraitExprClass: case AddrLabelExprClass: case GNUNullExprClass: + case NoInitExprClass: case CXXBoolLiteralExprClass: case CXXNullPtrLiteralExprClass: case CXXThisExprClass: @@ -2967,7 +2996,6 @@ bool Expr::HasSideEffects(const ASTContext &Ctx, case CompoundAssignOperatorClass: case VAArgExprClass: case AtomicExprClass: - case StmtExprClass: case CXXThrowExprClass: case CXXNewExprClass: case CXXDeleteExprClass: @@ -2975,6 +3003,13 @@ bool Expr::HasSideEffects(const ASTContext &Ctx, // These always have a side-effect. return true; + case StmtExprClass: { + // StmtExprs have a side-effect if any substatement does. + SideEffectFinder Finder(Ctx, IncludePossibleEffects); + Finder.Visit(cast<StmtExpr>(this)->getSubStmt()); + return Finder.hasSideEffects(); + } + case ParenExprClass: case ArraySubscriptExprClass: case MemberExprClass: @@ -2983,6 +3018,7 @@ bool Expr::HasSideEffects(const ASTContext &Ctx, case CompoundLiteralExprClass: case ExtVectorElementExprClass: case DesignatedInitExprClass: + case DesignatedInitUpdateExprClass: case ParenListExprClass: case CXXPseudoDestructorExprClass: case CXXStdInitializerListExprClass: @@ -3128,21 +3164,21 @@ bool Expr::HasSideEffects(const ASTContext &Ctx, namespace { /// \brief Look for a call to a non-trivial function within an expression. - class NonTrivialCallFinder : public EvaluatedExprVisitor<NonTrivialCallFinder> + class NonTrivialCallFinder : public ConstEvaluatedExprVisitor<NonTrivialCallFinder> { - typedef EvaluatedExprVisitor<NonTrivialCallFinder> Inherited; - + typedef ConstEvaluatedExprVisitor<NonTrivialCallFinder> Inherited; + bool NonTrivial; public: - explicit NonTrivialCallFinder(ASTContext &Context) + explicit NonTrivialCallFinder(const ASTContext &Context) : Inherited(Context), NonTrivial(false) { } bool hasNonTrivialCall() const { return NonTrivial; } - - void VisitCallExpr(CallExpr *E) { - if (CXXMethodDecl *Method - = dyn_cast_or_null<CXXMethodDecl>(E->getCalleeDecl())) { + + void VisitCallExpr(const CallExpr *E) { + if (const CXXMethodDecl *Method + = dyn_cast_or_null<const CXXMethodDecl>(E->getCalleeDecl())) { if (Method->isTrivial()) { // Recurse to children of the call. Inherited::VisitStmt(E); @@ -3152,8 +3188,8 @@ namespace { NonTrivial = true; } - - void VisitCXXConstructExpr(CXXConstructExpr *E) { + + void VisitCXXConstructExpr(const CXXConstructExpr *E) { if (E->getConstructor()->isTrivial()) { // Recurse to children of the call. Inherited::VisitStmt(E); @@ -3162,8 +3198,8 @@ namespace { NonTrivial = true; } - - void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { + + void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *E) { if (E->getTemporary()->getDestructor()->isTrivial()) { Inherited::VisitStmt(E); return; @@ -3174,7 +3210,7 @@ namespace { }; } -bool Expr::hasNonTrivialCall(ASTContext &Ctx) { +bool Expr::hasNonTrivialCall(const ASTContext &Ctx) const { NonTrivialCallFinder Finder(Ctx); Finder.Visit(this); return Finder.hasNonTrivialCall(); @@ -3989,6 +4025,25 @@ void DesignatedInitExpr::ExpandDesignator(const ASTContext &C, unsigned Idx, NumDesignators = NumDesignators - 1 + NumNewDesignators; } +DesignatedInitUpdateExpr::DesignatedInitUpdateExpr(const ASTContext &C, + SourceLocation lBraceLoc, Expr *baseExpr, SourceLocation rBraceLoc) + : Expr(DesignatedInitUpdateExprClass, baseExpr->getType(), VK_RValue, + OK_Ordinary, false, false, false, false) { + BaseAndUpdaterExprs[0] = baseExpr; + + InitListExpr *ILE = new (C) InitListExpr(C, lBraceLoc, None, rBraceLoc); + ILE->setType(baseExpr->getType()); + BaseAndUpdaterExprs[1] = ILE; +} + +SourceLocation DesignatedInitUpdateExpr::getLocStart() const { + return getBase()->getLocStart(); +} + +SourceLocation DesignatedInitUpdateExpr::getLocEnd() const { + return getBase()->getLocEnd(); +} + ParenListExpr::ParenListExpr(const ASTContext& C, SourceLocation lparenloc, ArrayRef<Expr*> exprs, SourceLocation rparenloc) diff --git a/lib/AST/ExprClassification.cpp b/lib/AST/ExprClassification.cpp index 5b320c2694ab..9cc612eae9b7 100644 --- a/lib/AST/ExprClassification.cpp +++ b/lib/AST/ExprClassification.cpp @@ -183,6 +183,8 @@ static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E) { case Expr::ObjCIndirectCopyRestoreExprClass: case Expr::AtomicExprClass: case Expr::CXXFoldExprClass: + case Expr::NoInitExprClass: + case Expr::DesignatedInitUpdateExprClass: return Cl::CL_PRValue; // Next come the complicated cases. diff --git a/lib/AST/ExprConstant.cpp b/lib/AST/ExprConstant.cpp index be24a2ae2c8c..8e472f174140 100644 --- a/lib/AST/ExprConstant.cpp +++ b/lib/AST/ExprConstant.cpp @@ -8675,6 +8675,8 @@ static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) { case Expr::CompoundLiteralExprClass: case Expr::ExtVectorElementExprClass: case Expr::DesignatedInitExprClass: + case Expr::NoInitExprClass: + case Expr::DesignatedInitUpdateExprClass: case Expr::ImplicitValueInitExprClass: case Expr::ParenListExprClass: case Expr::VAArgExprClass: diff --git a/lib/AST/ItaniumMangle.cpp b/lib/AST/ItaniumMangle.cpp index d07efaee7bba..e5a31f879b76 100644 --- a/lib/AST/ItaniumMangle.cpp +++ b/lib/AST/ItaniumMangle.cpp @@ -2010,7 +2010,11 @@ void CXXNameMangler::mangleType(const BuiltinType *T) { case BuiltinType::Half: Out << "Dh"; break; case BuiltinType::Float: Out << 'f'; break; case BuiltinType::Double: Out << 'd'; break; - case BuiltinType::LongDouble: Out << 'e'; break; + case BuiltinType::LongDouble: + Out << (getASTContext().getTargetInfo().useFloat128ManglingForLongDouble() + ? 'g' + : 'e'); + break; case BuiltinType::NullPtr: Out << "Dn"; break; #define BUILTIN_TYPE(Id, SingletonId) @@ -2676,7 +2680,9 @@ recurse: // These all can only appear in local or variable-initialization // contexts and so should never appear in a mangling. case Expr::AddrLabelExprClass: + case Expr::DesignatedInitUpdateExprClass: case Expr::ImplicitValueInitExprClass: + case Expr::NoInitExprClass: case Expr::ParenListExprClass: case Expr::LambdaExprClass: case Expr::MSPropertyRefExprClass: @@ -4060,8 +4066,7 @@ void ItaniumMangleContextImpl::mangleTypeName(QualType Ty, raw_ostream &Out) { void ItaniumMangleContextImpl::mangleCXXVTableBitSet(const CXXRecordDecl *RD, raw_ostream &Out) { - Linkage L = RD->getLinkageInternal(); - if (L == InternalLinkage || L == UniqueExternalLinkage) { + if (!RD->isExternallyVisible()) { // This part of the identifier needs to be unique across all translation // units in the linked program. The scheme fails if multiple translation // units are compiled using the same relative source file path, or if diff --git a/lib/AST/MicrosoftCXXABI.cpp b/lib/AST/MicrosoftCXXABI.cpp index 93ff77a2e964..aba6796256a7 100644 --- a/lib/AST/MicrosoftCXXABI.cpp +++ b/lib/AST/MicrosoftCXXABI.cpp @@ -179,8 +179,9 @@ MSVtorDispAttr::Mode CXXRecordDecl::getMSVtorDispMode() const { // // slot. // void *FunctionPointerOrVirtualThunk; // -// // An offset to add to the address of the vbtable pointer after (possibly) -// // selecting the virtual base but before resolving and calling the function. +// // An offset to add to the address of the vbtable pointer after +// // (possibly) selecting the virtual base but before resolving and calling +// // the function. // // Only needed if the class has any virtual bases or bases at a non-zero // // offset. // int NonVirtualBaseAdjustment; diff --git a/lib/AST/MicrosoftMangle.cpp b/lib/AST/MicrosoftMangle.cpp index db5b48e5672d..29a95a5103ce 100644 --- a/lib/AST/MicrosoftMangle.cpp +++ b/lib/AST/MicrosoftMangle.cpp @@ -2761,7 +2761,17 @@ void MicrosoftMangleContextImpl::mangleStringLiteral(const StringLiteral *SL, void MicrosoftMangleContextImpl::mangleCXXVTableBitSet(const CXXRecordDecl *RD, raw_ostream &Out) { - llvm::report_fatal_error("Cannot mangle bitsets yet"); + if (!RD->isExternallyVisible()) { + // This part of the identifier needs to be unique across all translation + // units in the linked program. The scheme fails if multiple translation + // units are compiled using the same relative source file path, or if + // multiple translation units are built from the same source file. + SourceManager &SM = getASTContext().getSourceManager(); + Out << "[" << SM.getFileEntryForID(SM.getMainFileID())->getName() << "]"; + } + + MicrosoftCXXNameMangler mangler(*this, Out); + mangler.mangleName(RD); } MicrosoftMangleContext * diff --git a/lib/AST/RecordLayoutBuilder.cpp b/lib/AST/RecordLayoutBuilder.cpp index 2101a5534a6b..388c91c9cbc0 100644 --- a/lib/AST/RecordLayoutBuilder.cpp +++ b/lib/AST/RecordLayoutBuilder.cpp @@ -1467,7 +1467,7 @@ void RecordLayoutBuilder::LayoutBitField(const FieldDecl *D) { // ms_struct basically requests a complete replacement of the // platform ABI's struct-layout algorithm, with the high-level goal // of duplicating MSVC's layout. For non-bitfields, this follows - // the the standard algorithm. The basic bitfield layout rule is to + // the standard algorithm. The basic bitfield layout rule is to // allocate an entire unit of the bitfield's declared type // (e.g. 'unsigned long'), then parcel it up among successive // bitfields whose declared types have the same size, making a new diff --git a/lib/AST/Stmt.cpp b/lib/AST/Stmt.cpp index 09bb17b0e701..6f4a89fee39c 100644 --- a/lib/AST/Stmt.cpp +++ b/lib/AST/Stmt.cpp @@ -1636,7 +1636,7 @@ OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc, Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); - Dir->setCond(Exprs.Cond, Exprs.SeparatedCond); + Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setCounters(Exprs.Counters); @@ -1675,7 +1675,7 @@ OMPForDirective::Create(const ASTContext &C, SourceLocation StartLoc, Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); - Dir->setCond(Exprs.Cond, Exprs.SeparatedCond); + Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); @@ -1721,7 +1721,7 @@ OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc, Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); - Dir->setCond(Exprs.Cond, Exprs.SeparatedCond); + Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); @@ -1777,7 +1777,7 @@ OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt) { - unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective), + unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective), llvm::alignOf<Stmt *>()); void *Mem = C.Allocate(Size + sizeof(Stmt *)); OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc); @@ -1876,7 +1876,7 @@ OMPParallelForDirective *OMPParallelForDirective::Create( Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); - Dir->setCond(Exprs.Cond, Exprs.SeparatedCond); + Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); @@ -1920,7 +1920,7 @@ OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create( Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); - Dir->setCond(Exprs.Cond, Exprs.SeparatedCond); + Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); @@ -2041,6 +2041,27 @@ OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C, return new (Mem) OMPTaskwaitDirective(); } +OMPTaskgroupDirective *OMPTaskgroupDirective::Create(const ASTContext &C, + SourceLocation StartLoc, + SourceLocation EndLoc, + Stmt *AssociatedStmt) { + unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective), + llvm::alignOf<Stmt *>()); + void *Mem = C.Allocate(Size + sizeof(Stmt *)); + OMPTaskgroupDirective *Dir = + new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc); + Dir->setAssociatedStmt(AssociatedStmt); + return Dir; +} + +OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C, + EmptyShell) { + unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective), + llvm::alignOf<Stmt *>()); + void *Mem = C.Allocate(Size + sizeof(Stmt *)); + return new (Mem) OMPTaskgroupDirective(); +} + OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, diff --git a/lib/AST/StmtPrinter.cpp b/lib/AST/StmtPrinter.cpp index db6d8c231ef2..658e3dfdeed4 100644 --- a/lib/AST/StmtPrinter.cpp +++ b/lib/AST/StmtPrinter.cpp @@ -910,6 +910,11 @@ void StmtPrinter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *Node) { PrintOMPExecutableDirective(Node); } +void StmtPrinter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *Node) { + Indent() << "#pragma omp taskgroup"; + PrintOMPExecutableDirective(Node); +} + void StmtPrinter::VisitOMPFlushDirective(OMPFlushDirective *Node) { Indent() << "#pragma omp flush "; PrintOMPExecutableDirective(Node); @@ -1430,6 +1435,22 @@ void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) { PrintExpr(Node->getInit()); } +void StmtPrinter::VisitDesignatedInitUpdateExpr( + DesignatedInitUpdateExpr *Node) { + OS << "{"; + OS << "/*base*/"; + PrintExpr(Node->getBase()); + OS << ", "; + + OS << "/*updater*/"; + PrintExpr(Node->getUpdater()); + OS << "}"; +} + +void StmtPrinter::VisitNoInitExpr(NoInitExpr *Node) { + OS << "/*no init*/"; +} + void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) { if (Policy.LangOpts.CPlusPlus) { OS << "/*implicit*/"; diff --git a/lib/AST/StmtProfile.cpp b/lib/AST/StmtProfile.cpp index c66b153eadbb..23f8d0c8be7a 100644 --- a/lib/AST/StmtProfile.cpp +++ b/lib/AST/StmtProfile.cpp @@ -510,6 +510,10 @@ void StmtProfiler::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *S) { VisitOMPExecutableDirective(S); } +void StmtProfiler::VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *S) { + VisitOMPExecutableDirective(S); +} + void StmtProfiler::VisitOMPFlushDirective(const OMPFlushDirective *S) { VisitOMPExecutableDirective(S); } @@ -744,6 +748,18 @@ void StmtProfiler::VisitDesignatedInitExpr(const DesignatedInitExpr *S) { } } +// Seems that if VisitInitListExpr() only works on the syntactic form of an +// InitListExpr, then a DesignatedInitUpdateExpr is not encountered. +void StmtProfiler::VisitDesignatedInitUpdateExpr( + const DesignatedInitUpdateExpr *S) { + llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of " + "initializer"); +} + +void StmtProfiler::VisitNoInitExpr(const NoInitExpr *S) { + llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer"); +} + void StmtProfiler::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *S) { VisitExpr(S); } diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp index 09bb7692596c..3ac117194099 100644 --- a/lib/AST/Type.cpp +++ b/lib/AST/Type.cpp @@ -1919,7 +1919,10 @@ bool AttributedType::isCallingConv() const { case attr_objc_gc: case attr_objc_ownership: case attr_noreturn: - return false; + case attr_nonnull: + case attr_nullable: + case attr_null_unspecified: + return false; case attr_pcs: case attr_pcs_vfp: case attr_cdecl: @@ -2340,6 +2343,153 @@ LinkageInfo Type::getLinkageAndVisibility() const { return LV; } +Optional<NullabilityKind> Type::getNullability(const ASTContext &context) const { + QualType type(this, 0); + do { + // Check whether this is an attributed type with nullability + // information. + if (auto attributed = dyn_cast<AttributedType>(type.getTypePtr())) { + if (auto nullability = attributed->getImmediateNullability()) + return nullability; + } + + // Desugar the type. If desugaring does nothing, we're done. + QualType desugared = type.getSingleStepDesugaredType(context); + if (desugared.getTypePtr() == type.getTypePtr()) + return None; + + type = desugared; + } while (true); +} + +bool Type::canHaveNullability() const { + QualType type = getCanonicalTypeInternal(); + + switch (type->getTypeClass()) { + // We'll only see canonical types here. +#define NON_CANONICAL_TYPE(Class, Parent) \ + case Type::Class: \ + llvm_unreachable("non-canonical type"); +#define TYPE(Class, Parent) +#include "clang/AST/TypeNodes.def" + + // Pointer types. + case Type::Pointer: + case Type::BlockPointer: + case Type::MemberPointer: + case Type::ObjCObjectPointer: + return true; + + // Dependent types that could instantiate to pointer types. + case Type::UnresolvedUsing: + case Type::TypeOfExpr: + case Type::TypeOf: + case Type::Decltype: + case Type::UnaryTransform: + case Type::TemplateTypeParm: + case Type::SubstTemplateTypeParmPack: + case Type::DependentName: + case Type::DependentTemplateSpecialization: + return true; + + // Dependent template specializations can instantiate to pointer + // types unless they're known to be specializations of a class + // template. + case Type::TemplateSpecialization: + if (TemplateDecl *templateDecl + = cast<TemplateSpecializationType>(type.getTypePtr()) + ->getTemplateName().getAsTemplateDecl()) { + if (isa<ClassTemplateDecl>(templateDecl)) + return false; + } + return true; + + // auto is considered dependent when it isn't deduced. + case Type::Auto: + return !cast<AutoType>(type.getTypePtr())->isDeduced(); + + case Type::Builtin: + switch (cast<BuiltinType>(type.getTypePtr())->getKind()) { + // Signed, unsigned, and floating-point types cannot have nullability. +#define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: +#define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: +#define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id: +#define BUILTIN_TYPE(Id, SingletonId) +#include "clang/AST/BuiltinTypes.def" + return false; + + // Dependent types that could instantiate to a pointer type. + case BuiltinType::Dependent: + case BuiltinType::Overload: + case BuiltinType::BoundMember: + case BuiltinType::PseudoObject: + case BuiltinType::UnknownAny: + case BuiltinType::ARCUnbridgedCast: + return true; + + case BuiltinType::Void: + case BuiltinType::ObjCId: + case BuiltinType::ObjCClass: + case BuiltinType::ObjCSel: + case BuiltinType::OCLImage1d: + case BuiltinType::OCLImage1dArray: + case BuiltinType::OCLImage1dBuffer: + case BuiltinType::OCLImage2d: + case BuiltinType::OCLImage2dArray: + case BuiltinType::OCLImage3d: + case BuiltinType::OCLSampler: + case BuiltinType::OCLEvent: + case BuiltinType::BuiltinFn: + case BuiltinType::NullPtr: + return false; + } + + // Non-pointer types. + case Type::Complex: + case Type::LValueReference: + case Type::RValueReference: + case Type::ConstantArray: + case Type::IncompleteArray: + case Type::VariableArray: + case Type::DependentSizedArray: + case Type::DependentSizedExtVector: + case Type::Vector: + case Type::ExtVector: + case Type::FunctionProto: + case Type::FunctionNoProto: + case Type::Record: + case Type::Enum: + case Type::InjectedClassName: + case Type::PackExpansion: + case Type::ObjCObject: + case Type::ObjCInterface: + case Type::Atomic: + return false; + } + llvm_unreachable("bad type kind!"); +} + +llvm::Optional<NullabilityKind> AttributedType::getImmediateNullability() const { + if (getAttrKind() == AttributedType::attr_nonnull) + return NullabilityKind::NonNull; + if (getAttrKind() == AttributedType::attr_nullable) + return NullabilityKind::Nullable; + if (getAttrKind() == AttributedType::attr_null_unspecified) + return NullabilityKind::Unspecified; + return None; +} + +Optional<NullabilityKind> AttributedType::stripOuterNullability(QualType &T) { + if (auto attributed = dyn_cast<AttributedType>(T.getTypePtr())) { + if (auto nullability = attributed->getImmediateNullability()) { + T = attributed->getModifiedType(); + return nullability; + } + } + + return None; +} + Qualifiers::ObjCLifetime Type::getObjCARCImplicitLifetime() const { if (isObjCARCImplicitlyUnretainedType()) return Qualifiers::OCL_ExplicitNone; diff --git a/lib/AST/TypePrinter.cpp b/lib/AST/TypePrinter.cpp index 3928fe8f8942..ebe09d85495e 100644 --- a/lib/AST/TypePrinter.cpp +++ b/lib/AST/TypePrinter.cpp @@ -1141,6 +1141,21 @@ void TypePrinter::printAttributedBefore(const AttributedType *T, } spaceBeforePlaceHolder(OS); } + + // Print nullability type specifiers. + if (T->getAttrKind() == AttributedType::attr_nonnull || + T->getAttrKind() == AttributedType::attr_nullable || + T->getAttrKind() == AttributedType::attr_null_unspecified) { + if (T->getAttrKind() == AttributedType::attr_nonnull) + OS << " __nonnull"; + else if (T->getAttrKind() == AttributedType::attr_nullable) + OS << " __nullable"; + else if (T->getAttrKind() == AttributedType::attr_null_unspecified) + OS << " __null_unspecified"; + else + llvm_unreachable("unhandled nullability"); + spaceBeforePlaceHolder(OS); + } } void TypePrinter::printAttributedAfter(const AttributedType *T, @@ -1154,12 +1169,34 @@ void TypePrinter::printAttributedAfter(const AttributedType *T, if (T->isMSTypeSpec()) return; + // Nothing to print after. + if (T->getAttrKind() == AttributedType::attr_nonnull || + T->getAttrKind() == AttributedType::attr_nullable || + T->getAttrKind() == AttributedType::attr_null_unspecified) + return printAfter(T->getModifiedType(), OS); + // If this is a calling convention attribute, don't print the implicit CC from // the modified type. SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv()); printAfter(T->getModifiedType(), OS); + // Print nullability type specifiers that occur after + if (T->getAttrKind() == AttributedType::attr_nonnull || + T->getAttrKind() == AttributedType::attr_nullable || + T->getAttrKind() == AttributedType::attr_null_unspecified) { + if (T->getAttrKind() == AttributedType::attr_nonnull) + OS << " __nonnull"; + else if (T->getAttrKind() == AttributedType::attr_nullable) + OS << " __nullable"; + else if (T->getAttrKind() == AttributedType::attr_null_unspecified) + OS << " __null_unspecified"; + else + llvm_unreachable("unhandled nullability"); + + return; + } + OS << " __attribute__(("; switch (T->getAttrKind()) { default: llvm_unreachable("This attribute should have been handled already"); diff --git a/lib/Analysis/CFG.cpp b/lib/Analysis/CFG.cpp index b2fdd2787985..19b3f5a47654 100644 --- a/lib/Analysis/CFG.cpp +++ b/lib/Analysis/CFG.cpp @@ -454,7 +454,7 @@ private: TerminatorExpr(nullptr) {} /// Returns whether we need to start a new branch for a temporary destructor - /// call. This is the case when the the temporary destructor is + /// call. This is the case when the temporary destructor is /// conditionally executed, and it is the first one we encounter while /// visiting a subexpression - other temporary destructors at the same level /// will be added to the same block and are executed under the same diff --git a/lib/Analysis/CocoaConventions.cpp b/lib/Analysis/CocoaConventions.cpp index 0db3cac58b56..be1262dc9910 100644 --- a/lib/Analysis/CocoaConventions.cpp +++ b/lib/Analysis/CocoaConventions.cpp @@ -25,7 +25,7 @@ using namespace ento; bool cocoa::isRefType(QualType RetTy, StringRef Prefix, StringRef Name) { // Recursively walk the typedef stack, allowing typedefs of reference types. - while (const TypedefType *TD = dyn_cast<TypedefType>(RetTy.getTypePtr())) { + while (const TypedefType *TD = RetTy->getAs<TypedefType>()) { StringRef TDName = TD->getDecl()->getIdentifier()->getName(); if (TDName.startswith(Prefix) && TDName.endswith("Ref")) return true; diff --git a/lib/Basic/CMakeLists.txt b/lib/Basic/CMakeLists.txt index 50a06d9e7a42..cfad8c3649ed 100644 --- a/lib/Basic/CMakeLists.txt +++ b/lib/Basic/CMakeLists.txt @@ -61,6 +61,7 @@ add_clang_library(clangBasic CharInfo.cpp Diagnostic.cpp DiagnosticIDs.cpp + DiagnosticOptions.cpp FileManager.cpp FileSystemStatCache.cpp IdentifierTable.cpp diff --git a/lib/Basic/Diagnostic.cpp b/lib/Basic/Diagnostic.cpp index 19928042fdac..7f5a15dab6b2 100644 --- a/lib/Basic/Diagnostic.cpp +++ b/lib/Basic/Diagnostic.cpp @@ -321,18 +321,10 @@ void DiagnosticsEngine::Report(const StoredDiagnostic &storedDiag) { NumDiagArgs = 0; DiagRanges.clear(); - DiagRanges.reserve(storedDiag.range_size()); - for (StoredDiagnostic::range_iterator - RI = storedDiag.range_begin(), - RE = storedDiag.range_end(); RI != RE; ++RI) - DiagRanges.push_back(*RI); + DiagRanges.append(storedDiag.range_begin(), storedDiag.range_end()); DiagFixItHints.clear(); - DiagFixItHints.reserve(storedDiag.fixit_size()); - for (StoredDiagnostic::fixit_iterator - FI = storedDiag.fixit_begin(), - FE = storedDiag.fixit_end(); FI != FE; ++FI) - DiagFixItHints.push_back(*FI); + DiagFixItHints.append(storedDiag.fixit_begin(), storedDiag.fixit_end()); assert(Client && "DiagnosticConsumer not set!"); Level DiagLevel = storedDiag.getLevel(); diff --git a/lib/Basic/DiagnosticOptions.cpp b/lib/Basic/DiagnosticOptions.cpp new file mode 100644 index 000000000000..f54a0ef4edb2 --- /dev/null +++ b/lib/Basic/DiagnosticOptions.cpp @@ -0,0 +1,24 @@ +//===--- DiagnosticOptions.cpp - C Language Family Diagnostic Handling ----===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file implements the DiagnosticOptions related interfaces. +// +//===----------------------------------------------------------------------===// + +#include "clang/Basic/DiagnosticOptions.h" +#include "llvm/Support/raw_ostream.h" + +namespace clang { + +raw_ostream& operator<<(raw_ostream& Out, DiagnosticLevelMask M) { + using UT = std::underlying_type<DiagnosticLevelMask>::type; + return Out << static_cast<UT>(M); +} + +} // end namespace clang diff --git a/lib/Basic/FileSystemStatCache.cpp b/lib/Basic/FileSystemStatCache.cpp index 83e42bdb8483..187ea37e0c28 100644 --- a/lib/Basic/FileSystemStatCache.cpp +++ b/lib/Basic/FileSystemStatCache.cpp @@ -15,19 +15,8 @@ #include "clang/Basic/VirtualFileSystem.h" #include "llvm/Support/Path.h" -// FIXME: This is terrible, we need this for ::close. -#if !defined(_MSC_VER) && !defined(__MINGW32__) -#include <unistd.h> -#include <sys/uio.h> -#else -#include <io.h> -#endif using namespace clang; -#if defined(_MSC_VER) -#define S_ISDIR(s) ((_S_IFDIR & s) !=0) -#endif - void FileSystemStatCache::anchor() { } static void copyStatusToFileData(const vfs::Status &Status, diff --git a/lib/Basic/IdentifierTable.cpp b/lib/Basic/IdentifierTable.cpp index 4e06352d31d8..b29500810003 100644 --- a/lib/Basic/IdentifierTable.cpp +++ b/lib/Basic/IdentifierTable.cpp @@ -16,6 +16,7 @@ #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/OperatorKinds.h" +#include "clang/Basic/Specifiers.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/SmallString.h" @@ -645,3 +646,17 @@ const char *clang::getOperatorSpelling(OverloadedOperatorKind Operator) { llvm_unreachable("Invalid OverloadedOperatorKind!"); } + +StringRef clang::getNullabilitySpelling(NullabilityKind kind) { + switch (kind) { + case NullabilityKind::NonNull: + return "__nonnull"; + + case NullabilityKind::Nullable: + return "__nullable"; + + case NullabilityKind::Unspecified: + return "__null_unspecified"; + } + llvm_unreachable("Unknown nullability kind."); +} diff --git a/lib/Basic/OpenMPKinds.cpp b/lib/Basic/OpenMPKinds.cpp index b83a0692c132..b2798b7f0fd3 100644 --- a/lib/Basic/OpenMPKinds.cpp +++ b/lib/Basic/OpenMPKinds.cpp @@ -332,6 +332,7 @@ bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, case OMPD_taskyield: case OMPD_barrier: case OMPD_taskwait: + case OMPD_taskgroup: case OMPD_ordered: break; } diff --git a/lib/Basic/Sanitizers.cpp b/lib/Basic/Sanitizers.cpp index 8c4884b8ec36..d3676b6b465c 100644 --- a/lib/Basic/Sanitizers.cpp +++ b/lib/Basic/Sanitizers.cpp @@ -25,6 +25,10 @@ bool SanitizerSet::has(SanitizerMask K) const { return Mask & K; } +bool SanitizerSet::hasOneOf(SanitizerMask K) const { + return Mask & K; +} + void SanitizerSet::set(SanitizerMask K, bool Value) { assert(llvm::countPopulation(K) == 1); Mask = Value ? (Mask | K) : (Mask & ~K); diff --git a/lib/Basic/Targets.cpp b/lib/Basic/Targets.cpp index c0c692484588..076b04bf342c 100644 --- a/lib/Basic/Targets.cpp +++ b/lib/Basic/Targets.cpp @@ -992,6 +992,12 @@ public: bool hasSjLjLowering() const override { return true; } + + bool useFloat128ManglingForLongDouble() const override { + return LongDoubleWidth == 128 && + LongDoubleFormat == &llvm::APFloat::PPCDoubleDouble && + getTriple().isOSBinFormatELF(); + } }; const Builtin::Info PPCTargetInfo::BuiltinInfo[] = { @@ -1661,7 +1667,7 @@ public: } }; -static const unsigned R600AddrSpaceMap[] = { +static const unsigned AMDGPUAddrSpaceMap[] = { 1, // opencl_global 3, // opencl_local 2, // opencl_constant @@ -1687,11 +1693,11 @@ static const char *DescriptionStringSI = "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128" "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64"; -class R600TargetInfo : public TargetInfo { +class AMDGPUTargetInfo : public TargetInfo { static const Builtin::Info BuiltinInfo[]; static const char * const GCCRegNames[]; - /// \brief The GPU profiles supported by the R600 target. + /// \brief The GPU profiles supported by the AMDGPU target. enum GPUKind { GK_NONE, GK_R600, @@ -1703,7 +1709,8 @@ class R600TargetInfo : public TargetInfo { GK_NORTHERN_ISLANDS, GK_CAYMAN, GK_SOUTHERN_ISLANDS, - GK_SEA_ISLANDS + GK_SEA_ISLANDS, + GK_VOLCANIC_ISLANDS } GPU; bool hasFP64:1; @@ -1711,8 +1718,8 @@ class R600TargetInfo : public TargetInfo { bool hasLDEXPF:1; public: - R600TargetInfo(const llvm::Triple &Triple) - : TargetInfo(Triple) { + AMDGPUTargetInfo(const llvm::Triple &Triple) + : TargetInfo(Triple) { if (Triple.getArch() == llvm::Triple::amdgcn) { DescriptionString = DescriptionStringSI; @@ -1727,7 +1734,7 @@ public: hasFMAF = false; hasLDEXPF = false; } - AddrSpaceMap = &R600AddrSpaceMap; + AddrSpaceMap = &AMDGPUAddrSpaceMap; UseAddrSpaceMapMangling = true; } @@ -1766,7 +1773,7 @@ public: void getTargetBuiltins(const Builtin::Info *&Records, unsigned &NumRecords) const override { Records = BuiltinInfo; - NumRecords = clang::R600::LastTSBuiltin - Builtin::FirstTSBuiltin; + NumRecords = clang::AMDGPU::LastTSBuiltin - Builtin::FirstTSBuiltin; } void getTargetDefines(const LangOptions &Opts, @@ -1822,6 +1829,9 @@ public: .Case("kaveri", GK_SEA_ISLANDS) .Case("hawaii", GK_SEA_ISLANDS) .Case("mullins", GK_SEA_ISLANDS) + .Case("tonga", GK_VOLCANIC_ISLANDS) + .Case("iceland", GK_VOLCANIC_ISLANDS) + .Case("carrizo", GK_VOLCANIC_ISLANDS) .Default(GK_NONE); if (GPU == GK_NONE) { @@ -1851,6 +1861,7 @@ public: break; case GK_SOUTHERN_ISLANDS: case GK_SEA_ISLANDS: + case GK_VOLCANIC_ISLANDS: DescriptionString = DescriptionStringSI; hasFP64 = true; hasFMAF = true; @@ -1862,12 +1873,12 @@ public: } }; -const Builtin::Info R600TargetInfo::BuiltinInfo[] = { +const Builtin::Info AMDGPUTargetInfo::BuiltinInfo[] = { #define BUILTIN(ID, TYPE, ATTRS) \ { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, -#include "clang/Basic/BuiltinsR600.def" +#include "clang/Basic/BuiltinsAMDGPU.def" }; -const char * const R600TargetInfo::GCCRegNames[] = { +const char * const AMDGPUTargetInfo::GCCRegNames[] = { "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", @@ -1920,8 +1931,8 @@ const char * const R600TargetInfo::GCCRegNames[] = { "vcc_lo", "vcc_hi", "flat_scr_lo", "flat_scr_hi" }; -void R600TargetInfo::getGCCRegNames(const char * const *&Names, - unsigned &NumNames) const { +void AMDGPUTargetInfo::getGCCRegNames(const char * const *&Names, + unsigned &NumNames) const { Names = GCCRegNames; NumNames = llvm::array_lengthof(GCCRegNames); } @@ -5688,6 +5699,10 @@ public: return "vector"; return ""; } + + bool useFloat128ManglingForLongDouble() const override { + return true; + } }; const Builtin::Info SystemZTargetInfo::BuiltinInfo[] = { @@ -5890,6 +5905,60 @@ validateAsmConstraint(const char *&Name, unsigned &NumAliases) const override {} }; +class BPFTargetInfo : public TargetInfo { +public: + BPFTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) { + LongWidth = LongAlign = PointerWidth = PointerAlign = 64; + SizeType = UnsignedLong; + PtrDiffType = SignedLong; + IntPtrType = SignedLong; + IntMaxType = SignedLong; + Int64Type = SignedLong; + RegParmMax = 5; + if (Triple.getArch() == llvm::Triple::bpfeb) { + BigEndian = true; + DescriptionString = "E-m:e-p:64:64-i64:64-n32:64-S128"; + } else { + BigEndian = false; + DescriptionString = "e-m:e-p:64:64-i64:64-n32:64-S128"; + } + MaxAtomicPromoteWidth = 64; + MaxAtomicInlineWidth = 64; + TLSSupported = false; + } + void getTargetDefines(const LangOptions &Opts, + MacroBuilder &Builder) const override { + DefineStd(Builder, "bpf", Opts); + Builder.defineMacro("__BPF__"); + } + bool hasFeature(StringRef Feature) const override { + return Feature == "bpf"; + } + + void getTargetBuiltins(const Builtin::Info *&Records, + unsigned &NumRecords) const override {} + const char *getClobbers() const override { + return ""; + } + BuiltinVaListKind getBuiltinVaListKind() const override { + return TargetInfo::VoidPtrBuiltinVaList; + } + void getGCCRegNames(const char * const *&Names, + unsigned &NumNames) const override { + Names = nullptr; + NumNames = 0; + } + bool validateAsmConstraint(const char *&Name, + TargetInfo::ConstraintInfo &info) const override { + return true; + } + void getGCCRegAliases(const GCCRegAlias *&Aliases, + unsigned &NumAliases) const override { + Aliases = nullptr; + NumAliases = 0; + } +}; + class MipsTargetInfoBase : public TargetInfo { virtual void setDescriptionString() = 0; @@ -6888,6 +6957,10 @@ static TargetInfo *AllocateTarget(const llvm::Triple &Triple) { return new ARMbeTargetInfo(Triple); } + case llvm::Triple::bpfeb: + case llvm::Triple::bpfel: + return new BPFTargetInfo(Triple); + case llvm::Triple::msp430: return new MSP430TargetInfo(Triple); @@ -7015,7 +7088,7 @@ static TargetInfo *AllocateTarget(const llvm::Triple &Triple) { case llvm::Triple::amdgcn: case llvm::Triple::r600: - return new R600TargetInfo(Triple); + return new AMDGPUTargetInfo(Triple); case llvm::Triple::sparc: switch (os) { @@ -7080,6 +7153,8 @@ static TargetInfo *AllocateTarget(const llvm::Triple &Triple) { return new DarwinI386TargetInfo(Triple); switch (os) { + case llvm::Triple::CloudABI: + return new CloudABITargetInfo<X86_32TargetInfo>(Triple); case llvm::Triple::Linux: { switch (Triple.getEnvironment()) { default: diff --git a/lib/CodeGen/BackendUtil.cpp b/lib/CodeGen/BackendUtil.cpp index 8cece0d126f5..f5edea7810ab 100644 --- a/lib/CodeGen/BackendUtil.cpp +++ b/lib/CodeGen/BackendUtil.cpp @@ -201,8 +201,14 @@ static void addSanitizerCoveragePass(const PassManagerBuilder &Builder, static void addAddressSanitizerPasses(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM) { - PM.add(createAddressSanitizerFunctionPass()); - PM.add(createAddressSanitizerModulePass()); + PM.add(createAddressSanitizerFunctionPass(/*CompileKernel*/false)); + PM.add(createAddressSanitizerModulePass(/*CompileKernel*/false)); +} + +static void addKernelAddressSanitizerPasses(const PassManagerBuilder &Builder, + legacy::PassManagerBase &PM) { + PM.add(createAddressSanitizerFunctionPass(/*CompileKernel*/true)); + PM.add(createAddressSanitizerModulePass(/*CompileKernel*/true)); } static void addMemorySanitizerPass(const PassManagerBuilder &Builder, @@ -283,7 +289,6 @@ void EmitAssemblyHelper::CreatePasses() { PMBuilder.SLPVectorize = CodeGenOpts.VectorizeSLP; PMBuilder.LoopVectorize = CodeGenOpts.VectorizeLoop; - PMBuilder.DisableTailCalls = CodeGenOpts.DisableTailCalls; PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime; PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops; PMBuilder.MergeFunctions = CodeGenOpts.MergeFunctions; @@ -329,6 +334,13 @@ void EmitAssemblyHelper::CreatePasses() { addAddressSanitizerPasses); } + if (LangOpts.Sanitize.has(SanitizerKind::KernelAddress)) { + PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast, + addKernelAddressSanitizerPasses); + PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0, + addKernelAddressSanitizerPasses); + } + if (LangOpts.Sanitize.has(SanitizerKind::Memory)) { PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast, addMemorySanitizerPass); @@ -478,6 +490,9 @@ TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) { llvm::TargetOptions Options; + if (!TargetOpts.Reciprocals.empty()) + Options.Reciprocals = TargetRecip(TargetOpts.Reciprocals); + Options.ThreadModel = llvm::StringSwitch<llvm::ThreadModel::Model>(CodeGenOpts.ThreadModel) .Case("posix", llvm::ThreadModel::POSIX) @@ -521,7 +536,6 @@ TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) { Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS; Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath; Options.StackAlignmentOverride = CodeGenOpts.StackAlignment; - Options.DisableTailCalls = CodeGenOpts.DisableTailCalls; Options.TrapFuncName = CodeGenOpts.TrapFuncName; Options.PositionIndependentExecutable = LangOpts.PIELevel != 0; Options.FunctionSections = CodeGenOpts.FunctionSections; diff --git a/lib/CodeGen/CGBuiltin.cpp b/lib/CodeGen/CGBuiltin.cpp index d86534d5f8d4..a14daac596f5 100644 --- a/lib/CodeGen/CGBuiltin.cpp +++ b/lib/CodeGen/CGBuiltin.cpp @@ -1877,7 +1877,7 @@ Value *CodeGenFunction::EmitTargetBuiltinExpr(unsigned BuiltinID, return EmitPPCBuiltinExpr(BuiltinID, E); case llvm::Triple::r600: case llvm::Triple::amdgcn: - return EmitR600BuiltinExpr(BuiltinID, E); + return EmitAMDGPUBuiltinExpr(BuiltinID, E); case llvm::Triple::systemz: return EmitSystemZBuiltinExpr(BuiltinID, E); default: @@ -3279,6 +3279,66 @@ Value *CodeGenFunction::GetValueForARMHint(unsigned BuiltinID) { } } +// Generates the IR for the read/write special register builtin, +// ValueType is the type of the value that is to be written or read, +// RegisterType is the type of the register being written to or read from. +static Value *EmitSpecialRegisterBuiltin(CodeGenFunction &CGF, + const CallExpr *E, + llvm::Type *RegisterType, + llvm::Type *ValueType, bool IsRead) { + // write and register intrinsics only support 32 and 64 bit operations. + assert((RegisterType->isIntegerTy(32) || RegisterType->isIntegerTy(64)) + && "Unsupported size for register."); + + CodeGen::CGBuilderTy &Builder = CGF.Builder; + CodeGen::CodeGenModule &CGM = CGF.CGM; + LLVMContext &Context = CGM.getLLVMContext(); + + const Expr *SysRegStrExpr = E->getArg(0)->IgnoreParenCasts(); + StringRef SysReg = cast<StringLiteral>(SysRegStrExpr)->getString(); + + llvm::Metadata *Ops[] = { llvm::MDString::get(Context, SysReg) }; + llvm::MDNode *RegName = llvm::MDNode::get(Context, Ops); + llvm::Value *Metadata = llvm::MetadataAsValue::get(Context, RegName); + + llvm::Type *Types[] = { RegisterType }; + + bool MixedTypes = RegisterType->isIntegerTy(64) && ValueType->isIntegerTy(32); + assert(!(RegisterType->isIntegerTy(32) && ValueType->isIntegerTy(64)) + && "Can't fit 64-bit value in 32-bit register"); + + if (IsRead) { + llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::read_register, Types); + llvm::Value *Call = Builder.CreateCall(F, Metadata); + + if (MixedTypes) + // Read into 64 bit register and then truncate result to 32 bit. + return Builder.CreateTrunc(Call, ValueType); + + if (ValueType->isPointerTy()) + // Have i32/i64 result (Call) but want to return a VoidPtrTy (i8*). + return Builder.CreateIntToPtr(Call, ValueType); + + return Call; + } + + llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::write_register, Types); + llvm::Value *ArgValue = CGF.EmitScalarExpr(E->getArg(1)); + if (MixedTypes) { + // Extend 32 bit write value to 64 bit to pass to write. + ArgValue = Builder.CreateZExt(ArgValue, RegisterType); + return Builder.CreateCall(F, { Metadata, ArgValue }); + } + + if (ValueType->isPointerTy()) { + // Have VoidPtrTy ArgValue but want to return an i32/i64. + ArgValue = Builder.CreatePtrToInt(ArgValue, RegisterType); + return Builder.CreateCall(F, { Metadata, ArgValue }); + } + + return Builder.CreateCall(F, { Metadata, ArgValue }); +} + Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E) { if (auto Hint = GetValueForARMHint(BuiltinID)) @@ -3491,6 +3551,37 @@ Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID, } } + if (BuiltinID == ARM::BI__builtin_arm_rsr || + BuiltinID == ARM::BI__builtin_arm_rsr64 || + BuiltinID == ARM::BI__builtin_arm_rsrp || + BuiltinID == ARM::BI__builtin_arm_wsr || + BuiltinID == ARM::BI__builtin_arm_wsr64 || + BuiltinID == ARM::BI__builtin_arm_wsrp) { + + bool IsRead = BuiltinID == ARM::BI__builtin_arm_rsr || + BuiltinID == ARM::BI__builtin_arm_rsr64 || + BuiltinID == ARM::BI__builtin_arm_rsrp; + + bool IsPointerBuiltin = BuiltinID == ARM::BI__builtin_arm_rsrp || + BuiltinID == ARM::BI__builtin_arm_wsrp; + + bool Is64Bit = BuiltinID == ARM::BI__builtin_arm_rsr64 || + BuiltinID == ARM::BI__builtin_arm_wsr64; + + llvm::Type *ValueType; + llvm::Type *RegisterType; + if (IsPointerBuiltin) { + ValueType = VoidPtrTy; + RegisterType = Int32Ty; + } else if (Is64Bit) { + ValueType = RegisterType = Int64Ty; + } else { + ValueType = RegisterType = Int32Ty; + } + + return EmitSpecialRegisterBuiltin(*this, E, RegisterType, ValueType, IsRead); + } + // Find out if any arguments are required to be integer constant // expressions. unsigned ICEArguments = 0; @@ -4239,6 +4330,36 @@ Value *CodeGenFunction::EmitAArch64BuiltinExpr(unsigned BuiltinID, return Builder.CreateCall(F, {Arg0, Arg1}); } + if (BuiltinID == AArch64::BI__builtin_arm_rsr || + BuiltinID == AArch64::BI__builtin_arm_rsr64 || + BuiltinID == AArch64::BI__builtin_arm_rsrp || + BuiltinID == AArch64::BI__builtin_arm_wsr || + BuiltinID == AArch64::BI__builtin_arm_wsr64 || + BuiltinID == AArch64::BI__builtin_arm_wsrp) { + + bool IsRead = BuiltinID == AArch64::BI__builtin_arm_rsr || + BuiltinID == AArch64::BI__builtin_arm_rsr64 || + BuiltinID == AArch64::BI__builtin_arm_rsrp; + + bool IsPointerBuiltin = BuiltinID == AArch64::BI__builtin_arm_rsrp || + BuiltinID == AArch64::BI__builtin_arm_wsrp; + + bool Is64Bit = BuiltinID != AArch64::BI__builtin_arm_rsr && + BuiltinID != AArch64::BI__builtin_arm_wsr; + + llvm::Type *ValueType; + llvm::Type *RegisterType = Int64Ty; + if (IsPointerBuiltin) { + ValueType = VoidPtrTy; + } else if (Is64Bit) { + ValueType = Int64Ty; + } else { + ValueType = Int32Ty; + } + + return EmitSpecialRegisterBuiltin(*this, E, RegisterType, ValueType, IsRead); + } + // Find out if any arguments are required to be integer constant // expressions. unsigned ICEArguments = 0; @@ -6427,11 +6548,11 @@ static Value *emitFPIntBuiltin(CodeGenFunction &CGF, return CGF.Builder.CreateCall(F, {Src0, Src1}); } -Value *CodeGenFunction::EmitR600BuiltinExpr(unsigned BuiltinID, - const CallExpr *E) { +Value *CodeGenFunction::EmitAMDGPUBuiltinExpr(unsigned BuiltinID, + const CallExpr *E) { switch (BuiltinID) { - case R600::BI__builtin_amdgpu_div_scale: - case R600::BI__builtin_amdgpu_div_scalef: { + case AMDGPU::BI__builtin_amdgpu_div_scale: + case AMDGPU::BI__builtin_amdgpu_div_scalef: { // Translate from the intrinsics's struct return to the builtin's out // argument. @@ -6458,8 +6579,8 @@ Value *CodeGenFunction::EmitR600BuiltinExpr(unsigned BuiltinID, FlagStore->setAlignment(FlagOutPtr.second); return Result; } - case R600::BI__builtin_amdgpu_div_fmas: - case R600::BI__builtin_amdgpu_div_fmasf: { + case AMDGPU::BI__builtin_amdgpu_div_fmas: + case AMDGPU::BI__builtin_amdgpu_div_fmasf: { llvm::Value *Src0 = EmitScalarExpr(E->getArg(0)); llvm::Value *Src1 = EmitScalarExpr(E->getArg(1)); llvm::Value *Src2 = EmitScalarExpr(E->getArg(2)); @@ -6470,26 +6591,26 @@ Value *CodeGenFunction::EmitR600BuiltinExpr(unsigned BuiltinID, llvm::Value *Src3ToBool = Builder.CreateIsNotNull(Src3); return Builder.CreateCall(F, {Src0, Src1, Src2, Src3ToBool}); } - case R600::BI__builtin_amdgpu_div_fixup: - case R600::BI__builtin_amdgpu_div_fixupf: + case AMDGPU::BI__builtin_amdgpu_div_fixup: + case AMDGPU::BI__builtin_amdgpu_div_fixupf: return emitTernaryFPBuiltin(*this, E, Intrinsic::AMDGPU_div_fixup); - case R600::BI__builtin_amdgpu_trig_preop: - case R600::BI__builtin_amdgpu_trig_preopf: + case AMDGPU::BI__builtin_amdgpu_trig_preop: + case AMDGPU::BI__builtin_amdgpu_trig_preopf: return emitFPIntBuiltin(*this, E, Intrinsic::AMDGPU_trig_preop); - case R600::BI__builtin_amdgpu_rcp: - case R600::BI__builtin_amdgpu_rcpf: + case AMDGPU::BI__builtin_amdgpu_rcp: + case AMDGPU::BI__builtin_amdgpu_rcpf: return emitUnaryFPBuiltin(*this, E, Intrinsic::AMDGPU_rcp); - case R600::BI__builtin_amdgpu_rsq: - case R600::BI__builtin_amdgpu_rsqf: + case AMDGPU::BI__builtin_amdgpu_rsq: + case AMDGPU::BI__builtin_amdgpu_rsqf: return emitUnaryFPBuiltin(*this, E, Intrinsic::AMDGPU_rsq); - case R600::BI__builtin_amdgpu_rsq_clamped: - case R600::BI__builtin_amdgpu_rsq_clampedf: + case AMDGPU::BI__builtin_amdgpu_rsq_clamped: + case AMDGPU::BI__builtin_amdgpu_rsq_clampedf: return emitUnaryFPBuiltin(*this, E, Intrinsic::AMDGPU_rsq_clamped); - case R600::BI__builtin_amdgpu_ldexp: - case R600::BI__builtin_amdgpu_ldexpf: + case AMDGPU::BI__builtin_amdgpu_ldexp: + case AMDGPU::BI__builtin_amdgpu_ldexpf: return emitFPIntBuiltin(*this, E, Intrinsic::AMDGPU_ldexp); - case R600::BI__builtin_amdgpu_class: - case R600::BI__builtin_amdgpu_classf: + case AMDGPU::BI__builtin_amdgpu_class: + case AMDGPU::BI__builtin_amdgpu_classf: return emitFPIntBuiltin(*this, E, Intrinsic::AMDGPU_class); default: return nullptr; diff --git a/lib/CodeGen/CGCXXABI.h b/lib/CodeGen/CGCXXABI.h index 2c7392188f78..b6b4ee6850ac 100644 --- a/lib/CodeGen/CGCXXABI.h +++ b/lib/CodeGen/CGCXXABI.h @@ -366,7 +366,8 @@ public: virtual llvm::Value *getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This, - llvm::Type *Ty) = 0; + llvm::Type *Ty, + SourceLocation Loc) = 0; /// Emit the ABI-specific virtual destructor call. virtual llvm::Value * diff --git a/lib/CodeGen/CGCall.cpp b/lib/CodeGen/CGCall.cpp index e77539c63236..58ef171df0d7 100644 --- a/lib/CodeGen/CGCall.cpp +++ b/lib/CodeGen/CGCall.cpp @@ -1465,6 +1465,8 @@ void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI, FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf"); } + FuncAttrs.addAttribute("disable-tail-calls", + llvm::toStringRef(CodeGenOpts.DisableTailCalls)); FuncAttrs.addAttribute("less-precise-fpmad", llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD)); FuncAttrs.addAttribute("no-infs-fp-math", @@ -1481,24 +1483,62 @@ void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI, if (!CodeGenOpts.StackRealignment) FuncAttrs.addAttribute("no-realign-stack"); - // Add target-cpu and target-features work if they differ from the defaults. - std::string &CPU = getTarget().getTargetOpts().CPU; - if (CPU != "") - FuncAttrs.addAttribute("target-cpu", CPU); + // Add target-cpu and target-features attributes to functions. If + // we have a decl for the function and it has a target attribute then + // parse that and add it to the feature set. + StringRef TargetCPU = getTarget().getTargetOpts().CPU; // TODO: Features gets us the features on the command line including // feature dependencies. For canonicalization purposes we might want to - // avoid putting features in the target-features set if we know it'll be one - // of the default features in the backend, e.g. corei7-avx and +avx or figure - // out non-explicit dependencies. - std::vector<std::string> &Features = getTarget().getTargetOpts().Features; + // avoid putting features in the target-features set if we know it'll be + // one of the default features in the backend, e.g. corei7-avx and +avx or + // figure out non-explicit dependencies. + std::vector<std::string> Features(getTarget().getTargetOpts().Features); + + // TODO: The target attribute complicates this further by allowing multiple + // additional features to be tacked on to the feature string for a + // particular function. For now we simply append to the set of features and + // let backend resolution fix them up. + const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl); + if (FD) { + if (const TargetAttr *TD = FD->getAttr<TargetAttr>()) { + StringRef FeaturesStr = TD->getFeatures(); + SmallVector<StringRef, 1> AttrFeatures; + FeaturesStr.split(AttrFeatures, ","); + + // Grab the various features and prepend a "+" to turn on the feature to + // the backend and add them to our existing set of Features. + for (auto &Feature : AttrFeatures) { + // While we're here iterating check for a different target cpu. + if (Feature.startswith("arch=")) + TargetCPU = Feature.split("=").second; + else if (Feature.startswith("tune=")) + // We don't support cpu tuning this way currently. + ; + else if (Feature.startswith("fpmath=")) + // TODO: Support the fpmath option this way. It will require checking + // overall feature validity for the function with the rest of the + // attributes on the function. + ; + else if (Feature.startswith("mno-")) + Features.push_back("-" + Feature.split("-").second.str()); + else + Features.push_back("+" + Feature.str()); + } + } + } + + // Now add the target-cpu and target-features to the function. + if (TargetCPU != "") + FuncAttrs.addAttribute("target-cpu", TargetCPU); if (!Features.empty()) { - std::stringstream S; + std::stringstream TargetFeatures; std::copy(Features.begin(), Features.end(), - std::ostream_iterator<std::string>(S, ",")); + std::ostream_iterator<std::string>(TargetFeatures, ",")); + // The drop_back gets rid of the trailing space. FuncAttrs.addAttribute("target-features", - StringRef(S.str()).drop_back(1)); + StringRef(TargetFeatures.str()).drop_back(1)); } } @@ -2231,11 +2271,10 @@ static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) { if (Intrinsic->getIntrinsicID() == llvm::Intrinsic::lifetime_end) { const llvm::Value *CastAddr = Intrinsic->getArgOperand(1); ++II; - if (isa<llvm::BitCastInst>(&*II)) { - if (CastAddr == &*II) { - continue; - } - } + if (II == IE) + break; + if (isa<llvm::BitCastInst>(&*II) && (CastAddr == &*II)) + continue; } } I = &*II; @@ -2571,7 +2610,7 @@ static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args, LValue srcLV; // Make an optimistic effort to emit the address as an l-value. - // This can fail if the the argument expression is more complicated. + // This can fail if the argument expression is more complicated. if (const Expr *lvExpr = maybeGetUnaryAddrOfOperand(CRE->getSubExpr())) { srcLV = CGF.EmitLValue(lvExpr); diff --git a/lib/CodeGen/CGClass.cpp b/lib/CodeGen/CGClass.cpp index cd75da276287..1d2b7875d8f7 100644 --- a/lib/CodeGen/CGClass.cpp +++ b/lib/CodeGen/CGClass.cpp @@ -370,25 +370,25 @@ namespace { /// A visitor which checks whether an initializer uses 'this' in a /// way which requires the vtable to be properly set. - struct DynamicThisUseChecker : EvaluatedExprVisitor<DynamicThisUseChecker> { - typedef EvaluatedExprVisitor<DynamicThisUseChecker> super; + struct DynamicThisUseChecker : ConstEvaluatedExprVisitor<DynamicThisUseChecker> { + typedef ConstEvaluatedExprVisitor<DynamicThisUseChecker> super; bool UsesThis; - DynamicThisUseChecker(ASTContext &C) : super(C), UsesThis(false) {} + DynamicThisUseChecker(const ASTContext &C) : super(C), UsesThis(false) {} // Black-list all explicit and implicit references to 'this'. // // Do we need to worry about external references to 'this' derived // from arbitrary code? If so, then anything which runs arbitrary // external code might potentially access the vtable. - void VisitCXXThisExpr(CXXThisExpr *E) { UsesThis = true; } + void VisitCXXThisExpr(const CXXThisExpr *E) { UsesThis = true; } }; } static bool BaseInitializerUsesThis(ASTContext &C, const Expr *Init) { DynamicThisUseChecker Checker(C); - Checker.Visit(const_cast<Expr*>(Init)); + Checker.Visit(Init); return Checker.UsesThis; } @@ -2134,17 +2134,21 @@ LeastDerivedClassWithSameLayout(const CXXRecordDecl *RD) { } void CodeGenFunction::EmitVTablePtrCheckForCall(const CXXMethodDecl *MD, - llvm::Value *VTable) { + llvm::Value *VTable, + CFITypeCheckKind TCK, + SourceLocation Loc) { const CXXRecordDecl *ClassDecl = MD->getParent(); if (!SanOpts.has(SanitizerKind::CFICastStrict)) ClassDecl = LeastDerivedClassWithSameLayout(ClassDecl); - EmitVTablePtrCheck(ClassDecl, VTable); + EmitVTablePtrCheck(ClassDecl, VTable, TCK, Loc); } void CodeGenFunction::EmitVTablePtrCheckForCast(QualType T, llvm::Value *Derived, - bool MayBeNull) { + bool MayBeNull, + CFITypeCheckKind TCK, + SourceLocation Loc) { if (!getLangOpts().CPlusPlus) return; @@ -2184,7 +2188,7 @@ void CodeGenFunction::EmitVTablePtrCheckForCast(QualType T, } llvm::Value *VTable = GetVTablePtr(Derived, Int8PtrTy); - EmitVTablePtrCheck(ClassDecl, VTable); + EmitVTablePtrCheck(ClassDecl, VTable, TCK, Loc); if (MayBeNull) { Builder.CreateBr(ContBlock); @@ -2193,11 +2197,15 @@ void CodeGenFunction::EmitVTablePtrCheckForCast(QualType T, } void CodeGenFunction::EmitVTablePtrCheck(const CXXRecordDecl *RD, - llvm::Value *VTable) { + llvm::Value *VTable, + CFITypeCheckKind TCK, + SourceLocation Loc) { // FIXME: Add blacklisting scheme. if (RD->isInStdNamespace()) return; + SanitizerScope SanScope(this); + std::string OutName; llvm::raw_string_ostream Out(OutName); CGM.getCXXABI().getMangleContext().mangleCXXVTableBitSet(RD, Out); @@ -2205,20 +2213,34 @@ void CodeGenFunction::EmitVTablePtrCheck(const CXXRecordDecl *RD, llvm::Value *BitSetName = llvm::MetadataAsValue::get( getLLVMContext(), llvm::MDString::get(getLLVMContext(), Out.str())); - llvm::Value *BitSetTest = Builder.CreateCall( - CGM.getIntrinsic(llvm::Intrinsic::bitset_test), - {Builder.CreateBitCast(VTable, CGM.Int8PtrTy), BitSetName}); + llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy); + llvm::Value *BitSetTest = + Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::bitset_test), + {CastedVTable, BitSetName}); - llvm::BasicBlock *ContBlock = createBasicBlock("vtable.check.cont"); - llvm::BasicBlock *TrapBlock = createBasicBlock("vtable.check.trap"); - - Builder.CreateCondBr(BitSetTest, ContBlock, TrapBlock); - - EmitBlock(TrapBlock); - Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::trap), {}); - Builder.CreateUnreachable(); + SanitizerMask M; + switch (TCK) { + case CFITCK_VCall: + M = SanitizerKind::CFIVCall; + break; + case CFITCK_NVCall: + M = SanitizerKind::CFINVCall; + break; + case CFITCK_DerivedCast: + M = SanitizerKind::CFIDerivedCast; + break; + case CFITCK_UnrelatedCast: + M = SanitizerKind::CFIUnrelatedCast; + break; + } - EmitBlock(ContBlock); + llvm::Constant *StaticData[] = { + EmitCheckSourceLocation(Loc), + EmitCheckTypeDescriptor(QualType(RD->getTypeForDecl(), 0)), + llvm::ConstantInt::get(Int8Ty, TCK), + }; + EmitCheck(std::make_pair(BitSetTest, M), "cfi_bad_type", StaticData, + CastedVTable); } // FIXME: Ideally Expr::IgnoreParenNoopCasts should do this, but it doesn't do diff --git a/lib/CodeGen/CGDebugInfo.cpp b/lib/CodeGen/CGDebugInfo.cpp index 48458dbd6003..a20e39f3fc00 100644 --- a/lib/CodeGen/CGDebugInfo.cpp +++ b/lib/CodeGen/CGDebugInfo.cpp @@ -590,18 +590,29 @@ llvm::DIType *CGDebugInfo::CreateType(const PointerType *Ty, Ty->getPointeeType(), Unit); } +/// \return whether a C++ mangling exists for the type defined by TD. +static bool hasCXXMangling(const TagDecl *TD, llvm::DICompileUnit *TheCU) { + switch (TheCU->getSourceLanguage()) { + case llvm::dwarf::DW_LANG_C_plus_plus: + return true; + case llvm::dwarf::DW_LANG_ObjC_plus_plus: + return isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD); + default: + return false; + } +} + /// In C++ mode, types have linkage, so we can rely on the ODR and /// on their mangled names, if they're external. static SmallString<256> getUniqueTagTypeName(const TagType *Ty, CodeGenModule &CGM, llvm::DICompileUnit *TheCU) { SmallString<256> FullName; - // FIXME: ODR should apply to ObjC++ exactly the same wasy it does to C++. - // For now, only apply ODR with C++. const TagDecl *TD = Ty->getDecl(); - if (TheCU->getSourceLanguage() != llvm::dwarf::DW_LANG_C_plus_plus || - !TD->isExternallyVisible()) + + if (!hasCXXMangling(TD, TheCU) || !TD->isExternallyVisible()) return FullName; + // Microsoft Mangler does not have support for mangleCXXRTTIName yet. if (CGM.getTarget().getCXXABI().isMicrosoft()) return FullName; diff --git a/lib/CodeGen/CGDecl.cpp b/lib/CodeGen/CGDecl.cpp index 579a04145567..07dbce4252fe 100644 --- a/lib/CodeGen/CGDecl.cpp +++ b/lib/CodeGen/CGDecl.cpp @@ -864,20 +864,17 @@ llvm::Value *CodeGenFunction::EmitLifetimeStart(uint64_t Size, return nullptr; llvm::Value *SizeV = llvm::ConstantInt::get(Int64Ty, Size); - llvm::Value *Args[] = { - SizeV, - new llvm::BitCastInst(Addr, Int8PtrTy, "", Builder.GetInsertBlock())}; - llvm::CallInst *C = llvm::CallInst::Create(CGM.getLLVMLifetimeStartFn(), Args, - "", Builder.GetInsertBlock()); + Addr = Builder.CreateBitCast(Addr, Int8PtrTy); + llvm::CallInst *C = + Builder.CreateCall(CGM.getLLVMLifetimeStartFn(), {SizeV, Addr}); C->setDoesNotThrow(); return SizeV; } void CodeGenFunction::EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr) { - llvm::Value *Args[] = {Size, new llvm::BitCastInst(Addr, Int8PtrTy, "", - Builder.GetInsertBlock())}; - llvm::CallInst *C = llvm::CallInst::Create(CGM.getLLVMLifetimeEndFn(), Args, - "", Builder.GetInsertBlock()); + Addr = Builder.CreateBitCast(Addr, Int8PtrTy); + llvm::CallInst *C = + Builder.CreateCall(CGM.getLLVMLifetimeEndFn(), {Size, Addr}); C->setDoesNotThrow(); } diff --git a/lib/CodeGen/CGDeclCXX.cpp b/lib/CodeGen/CGDeclCXX.cpp index 06d157bd82e7..00d6d5cee749 100644 --- a/lib/CodeGen/CGDeclCXX.cpp +++ b/lib/CodeGen/CGDeclCXX.cpp @@ -267,12 +267,15 @@ llvm::Function *CodeGenModule::CreateGlobalInitOrDestructFunction( Fn->setDoesNotThrow(); if (!isInSanitizerBlacklist(Fn, Loc)) { - if (getLangOpts().Sanitize.has(SanitizerKind::Address)) + if (getLangOpts().Sanitize.hasOneOf(SanitizerKind::Address | + SanitizerKind::KernelAddress)) Fn->addFnAttr(llvm::Attribute::SanitizeAddress); if (getLangOpts().Sanitize.has(SanitizerKind::Thread)) Fn->addFnAttr(llvm::Attribute::SanitizeThread); if (getLangOpts().Sanitize.has(SanitizerKind::Memory)) Fn->addFnAttr(llvm::Attribute::SanitizeMemory); + if (getLangOpts().Sanitize.has(SanitizerKind::SafeStack)) + Fn->addFnAttr(llvm::Attribute::SafeStack); } return Fn; @@ -421,6 +424,7 @@ CodeGenModule::EmitCXXGlobalInitFunc() { CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, LocalCXXGlobalInits); AddGlobalCtor(Fn, Priority); } + PrioritizedCXXGlobalInits.clear(); } SmallString<128> FileName; @@ -448,7 +452,6 @@ CodeGenModule::EmitCXXGlobalInitFunc() { AddGlobalCtor(Fn); CXXGlobalInits.clear(); - PrioritizedCXXGlobalInits.clear(); } void CodeGenModule::EmitCXXGlobalDtorFunc() { diff --git a/lib/CodeGen/CGException.cpp b/lib/CodeGen/CGException.cpp index d9a3f0b252a5..4c8501724bd8 100644 --- a/lib/CodeGen/CGException.cpp +++ b/lib/CodeGen/CGException.cpp @@ -698,13 +698,15 @@ llvm::BasicBlock *CodeGenFunction::EmitLandingPad() { const EHPersonality &personality = EHPersonality::get(*this); + if (!CurFn->hasPersonalityFn()) + CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, personality)); + // Create and configure the landing pad. llvm::BasicBlock *lpad = createBasicBlock("lpad"); EmitBlock(lpad); - llvm::LandingPadInst *LPadInst = - Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, nullptr), - getOpaquePersonalityFn(CGM, personality), 0); + llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad( + llvm::StructType::get(Int8PtrTy, Int32Ty, nullptr), 0); llvm::Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0); Builder.CreateStore(LPadExn, getExceptionSlot()); @@ -1193,9 +1195,12 @@ llvm::BasicBlock *CodeGenFunction::getTerminateLandingPad() { // Tell the backend that this is a landing pad. const EHPersonality &Personality = EHPersonality::get(*this); - llvm::LandingPadInst *LPadInst = - Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, nullptr), - getOpaquePersonalityFn(CGM, Personality), 0); + + if (!CurFn->hasPersonalityFn()) + CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality)); + + llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad( + llvm::StructType::get(Int8PtrTy, Int32Ty, nullptr), 0); LPadInst->addClause(getCatchAllValue(*this)); llvm::Value *Exn = 0; diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp index 1ed45a33d0fd..1a76afaf1158 100644 --- a/lib/CodeGen/CGExpr.cpp +++ b/lib/CodeGen/CGExpr.cpp @@ -2300,15 +2300,24 @@ void CodeGenFunction::EmitCheck( llvm::Value *FatalCond = nullptr; llvm::Value *RecoverableCond = nullptr; + llvm::Value *TrapCond = nullptr; for (int i = 0, n = Checked.size(); i < n; ++i) { llvm::Value *Check = Checked[i].first; + // -fsanitize-trap= overrides -fsanitize-recover=. llvm::Value *&Cond = - CGM.getCodeGenOpts().SanitizeRecover.has(Checked[i].second) - ? RecoverableCond - : FatalCond; + CGM.getCodeGenOpts().SanitizeTrap.has(Checked[i].second) + ? TrapCond + : CGM.getCodeGenOpts().SanitizeRecover.has(Checked[i].second) + ? RecoverableCond + : FatalCond; Cond = Cond ? Builder.CreateAnd(Cond, Check) : Check; } + if (TrapCond) + EmitTrapCheck(TrapCond); + if (!FatalCond && !RecoverableCond) + return; + llvm::Value *JointCond; if (FatalCond && RecoverableCond) JointCond = Builder.CreateAnd(FatalCond, RecoverableCond); @@ -2326,15 +2335,6 @@ void CodeGenFunction::EmitCheck( } #endif - if (CGM.getCodeGenOpts().SanitizeUndefinedTrapOnError) { - assert(RecoverKind != CheckRecoverableKind::AlwaysRecoverable && - "Runtime call required for AlwaysRecoverable kind!"); - // Assume that -fsanitize-undefined-trap-on-error overrides - // -fsanitize-recover= options, as we can only print meaningful error - // message and recover if we have a runtime support. - return EmitTrapCheck(JointCond); - } - llvm::BasicBlock *Cont = createBasicBlock("cont"); llvm::BasicBlock *Handlers = createBasicBlock("handler." + CheckName); llvm::Instruction *Branch = Builder.CreateCondBr(JointCond, Cont, Handlers); @@ -3035,7 +3035,8 @@ LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { Derived, E->getType()); if (SanOpts.has(SanitizerKind::CFIDerivedCast)) - EmitVTablePtrCheckForCast(E->getType(), Derived, /*MayBeNull=*/false); + EmitVTablePtrCheckForCast(E->getType(), Derived, /*MayBeNull=*/false, + CFITCK_DerivedCast, E->getLocStart()); return MakeAddrLValue(Derived, E->getType()); } @@ -3048,7 +3049,8 @@ LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { ConvertType(CE->getTypeAsWritten())); if (SanOpts.has(SanitizerKind::CFIUnrelatedCast)) - EmitVTablePtrCheckForCast(E->getType(), V, /*MayBeNull=*/false); + EmitVTablePtrCheckForCast(E->getType(), V, /*MayBeNull=*/false, + CFITCK_UnrelatedCast, E->getLocStart()); return MakeAddrLValue(V, E->getType()); } diff --git a/lib/CodeGen/CGExprAgg.cpp b/lib/CodeGen/CGExprAgg.cpp index 8b1bc69352b3..883b76bcfab0 100644 --- a/lib/CodeGen/CGExprAgg.cpp +++ b/lib/CodeGen/CGExprAgg.cpp @@ -160,10 +160,12 @@ public: EmitAggLoadOfLValue(E); } + void VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E); void VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO); void VisitChooseExpr(const ChooseExpr *CE); void VisitInitListExpr(InitListExpr *E); void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E); + void VisitNoInitExpr(NoInitExpr *E) { } // Do nothing. void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { Visit(DAE->getExpr()); } @@ -1056,6 +1058,9 @@ AggExprEmitter::EmitInitializationToLValue(Expr *E, LValue LV) { return; } else if (isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) { return EmitNullInitializationToLValue(LV); + } else if (isa<NoInitExpr>(E)) { + // Do nothing. + return; } else if (type->isReferenceType()) { RValue RV = CGF.EmitReferenceBindingToExpr(E); return CGF.EmitStoreThroughLValue(RV, LV); @@ -1276,6 +1281,15 @@ void AggExprEmitter::VisitInitListExpr(InitListExpr *E) { cleanupDominator->eraseFromParent(); } +void AggExprEmitter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { + AggValueSlot Dest = EnsureSlot(E->getType()); + + LValue DestLV = CGF.MakeAddrLValue(Dest.getAddr(), E->getType(), + Dest.getAlignment()); + EmitInitializationToLValue(E->getBase(), DestLV); + VisitInitListExpr(E->getUpdater()); +} + //===----------------------------------------------------------------------===// // Entry Points into this File //===----------------------------------------------------------------------===// diff --git a/lib/CodeGen/CGExprCXX.cpp b/lib/CodeGen/CGExprCXX.cpp index 13dfbb38816f..f0f706d7b957 100644 --- a/lib/CodeGen/CGExprCXX.cpp +++ b/lib/CodeGen/CGExprCXX.cpp @@ -254,12 +254,13 @@ RValue CodeGenFunction::EmitCXXMemberOrOperatorMemberCallExpr( if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) { Callee = CGM.GetAddrOfFunction(GlobalDecl(Ctor, Ctor_Complete), Ty); } else if (UseVirtualCall) { - Callee = CGM.getCXXABI().getVirtualFunctionPointer(*this, MD, This, Ty); + Callee = CGM.getCXXABI().getVirtualFunctionPointer(*this, MD, This, Ty, + CE->getLocStart()); } else { if (SanOpts.has(SanitizerKind::CFINVCall) && MD->getParent()->isDynamicClass()) { llvm::Value *VTable = GetVTablePtr(This, Int8PtrTy); - EmitVTablePtrCheckForCall(MD, VTable); + EmitVTablePtrCheckForCall(MD, VTable, CFITCK_NVCall, CE->getLocStart()); } if (getLangOpts().AppleKext && MD->isVirtual() && HasQualifier) @@ -958,6 +959,25 @@ void CodeGenFunction::EmitNewArrayInitializer( if (ILE->getNumInits() == 0 && TryMemsetInitialization()) return; + // If we have a struct whose every field is value-initialized, we can + // usually use memset. + if (auto *ILE = dyn_cast<InitListExpr>(Init)) { + if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) { + if (RType->getDecl()->isStruct()) { + unsigned NumFields = 0; + for (auto *Field : RType->getDecl()->fields()) + if (!Field->isUnnamedBitfield()) + ++NumFields; + if (ILE->getNumInits() == NumFields) + for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i) + if (!isa<ImplicitValueInitExpr>(ILE->getInit(i))) + --NumFields; + if (ILE->getNumInits() == NumFields && TryMemsetInitialization()) + return; + } + } + } + // Create the loop blocks. llvm::BasicBlock *EntryBB = Builder.GetInsertBlock(); llvm::BasicBlock *LoopBB = createBasicBlock("new.loop"); diff --git a/lib/CodeGen/CGExprConstant.cpp b/lib/CodeGen/CGExprConstant.cpp index b90b3ab61d8e..acfb9b6dbb25 100644 --- a/lib/CodeGen/CGExprConstant.cpp +++ b/lib/CodeGen/CGExprConstant.cpp @@ -33,6 +33,7 @@ using namespace CodeGen; //===----------------------------------------------------------------------===// namespace { +class ConstExprEmitter; class ConstStructBuilder { CodeGenModule &CGM; CodeGenFunction *CGF; @@ -42,6 +43,10 @@ class ConstStructBuilder { CharUnits LLVMStructAlignment; SmallVector<llvm::Constant *, 32> Elements; public: + static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CFG, + ConstExprEmitter *Emitter, + llvm::ConstantStruct *Base, + InitListExpr *Updater); static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, InitListExpr *ILE); static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, @@ -68,6 +73,8 @@ private: void ConvertStructToPacked(); bool Build(InitListExpr *ILE); + bool Build(ConstExprEmitter *Emitter, llvm::ConstantStruct *Base, + InitListExpr *Updater); void Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase, const CXXRecordDecl *VTableClass, CharUnits BaseOffset); llvm::Constant *Finalize(QualType Ty); @@ -547,6 +554,17 @@ llvm::Constant *ConstStructBuilder::Finalize(QualType Ty) { llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, + ConstExprEmitter *Emitter, + llvm::ConstantStruct *Base, + InitListExpr *Updater) { + ConstStructBuilder Builder(CGM, CGF); + if (!Builder.Build(Emitter, Base, Updater)) + return nullptr; + return Builder.Finalize(Updater->getType()); +} + +llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM, + CodeGenFunction *CGF, InitListExpr *ILE) { ConstStructBuilder Builder(CGM, CGF); @@ -818,6 +836,82 @@ public: return nullptr; } + llvm::Constant *EmitDesignatedInitUpdater(llvm::Constant *Base, + InitListExpr *Updater) { + QualType ExprType = Updater->getType(); + + if (ExprType->isArrayType()) { + llvm::ArrayType *AType = cast<llvm::ArrayType>(ConvertType(ExprType)); + llvm::Type *ElemType = AType->getElementType(); + + unsigned NumInitElements = Updater->getNumInits(); + unsigned NumElements = AType->getNumElements(); + + std::vector<llvm::Constant *> Elts; + Elts.reserve(NumElements); + + if (llvm::ConstantDataArray *DataArray = + dyn_cast<llvm::ConstantDataArray>(Base)) + for (unsigned i = 0; i != NumElements; ++i) + Elts.push_back(DataArray->getElementAsConstant(i)); + else if (llvm::ConstantArray *Array = + dyn_cast<llvm::ConstantArray>(Base)) + for (unsigned i = 0; i != NumElements; ++i) + Elts.push_back(Array->getOperand(i)); + else + return nullptr; // FIXME: other array types not implemented + + llvm::Constant *fillC = nullptr; + if (Expr *filler = Updater->getArrayFiller()) + if (!isa<NoInitExpr>(filler)) + fillC = CGM.EmitConstantExpr(filler, filler->getType(), CGF); + bool RewriteType = (fillC && fillC->getType() != ElemType); + + for (unsigned i = 0; i != NumElements; ++i) { + Expr *Init = nullptr; + if (i < NumInitElements) + Init = Updater->getInit(i); + + if (!Init && fillC) + Elts[i] = fillC; + else if (!Init || isa<NoInitExpr>(Init)) + ; // Do nothing. + else if (InitListExpr *ChildILE = dyn_cast<InitListExpr>(Init)) + Elts[i] = EmitDesignatedInitUpdater(Elts[i], ChildILE); + else + Elts[i] = CGM.EmitConstantExpr(Init, Init->getType(), CGF); + + if (!Elts[i]) + return nullptr; + RewriteType |= (Elts[i]->getType() != ElemType); + } + + if (RewriteType) { + std::vector<llvm::Type *> Types; + Types.reserve(NumElements); + for (unsigned i = 0; i != NumElements; ++i) + Types.push_back(Elts[i]->getType()); + llvm::StructType *SType = llvm::StructType::get(AType->getContext(), + Types, true); + return llvm::ConstantStruct::get(SType, Elts); + } + + return llvm::ConstantArray::get(AType, Elts); + } + + if (ExprType->isRecordType()) + return ConstStructBuilder::BuildStruct(CGM, CGF, this, + dyn_cast<llvm::ConstantStruct>(Base), Updater); + + return nullptr; + } + + llvm::Constant *VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { + return EmitDesignatedInitUpdater( + CGM.EmitConstantExpr(E->getBase(), E->getType(), CGF), + E->getUpdater()); + } + llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E) { if (!E->getConstructor()->isTrivial()) return nullptr; @@ -1003,6 +1097,68 @@ public: } // end anonymous namespace. +bool ConstStructBuilder::Build(ConstExprEmitter *Emitter, + llvm::ConstantStruct *Base, + InitListExpr *Updater) { + assert(Base && "base expression should not be empty"); + + QualType ExprType = Updater->getType(); + RecordDecl *RD = ExprType->getAs<RecordType>()->getDecl(); + const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); + const llvm::StructLayout *BaseLayout = CGM.getDataLayout().getStructLayout( + Base->getType()); + unsigned FieldNo = -1; + unsigned ElementNo = 0; + + for (FieldDecl *Field : RD->fields()) { + ++FieldNo; + + if (RD->isUnion() && Updater->getInitializedFieldInUnion() != Field) + continue; + + // Skip anonymous bitfields. + if (Field->isUnnamedBitfield()) + continue; + + llvm::Constant *EltInit = Base->getOperand(ElementNo); + + // Bail out if the type of the ConstantStruct does not have the same layout + // as the type of the InitListExpr. + if (CGM.getTypes().ConvertType(Field->getType()) != EltInit->getType() || + Layout.getFieldOffset(ElementNo) != + BaseLayout->getElementOffsetInBits(ElementNo)) + return false; + + // Get the initializer. If we encounter an empty field or a NoInitExpr, + // we use values from the base expression. + Expr *Init = nullptr; + if (ElementNo < Updater->getNumInits()) + Init = Updater->getInit(ElementNo); + + if (!Init || isa<NoInitExpr>(Init)) + ; // Do nothing. + else if (InitListExpr *ChildILE = dyn_cast<InitListExpr>(Init)) + EltInit = Emitter->EmitDesignatedInitUpdater(EltInit, ChildILE); + else + EltInit = CGM.EmitConstantExpr(Init, Field->getType(), CGF); + + ++ElementNo; + + if (!EltInit) + return false; + + if (!Field->isBitField()) + AppendField(Field, Layout.getFieldOffset(FieldNo), EltInit); + else if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(EltInit)) + AppendBitField(Field, Layout.getFieldOffset(FieldNo), CI); + else + // Initializing a bitfield with a non-trivial constant? + return false; + } + + return true; +} + llvm::Constant *CodeGenModule::EmitConstantInit(const VarDecl &D, CodeGenFunction *CGF) { // Make a quick check if variable can be default NULL initialized diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp index 08c81c012c76..330a0dffb244 100644 --- a/lib/CodeGen/CGExprScalar.cpp +++ b/lib/CodeGen/CGExprScalar.cpp @@ -1386,7 +1386,9 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { if (CGF.SanOpts.has(SanitizerKind::CFIUnrelatedCast)) { if (auto PT = DestTy->getAs<PointerType>()) CGF.EmitVTablePtrCheckForCast(PT->getPointeeType(), Src, - /*MayBeNull=*/true); + /*MayBeNull=*/true, + CodeGenFunction::CFITCK_UnrelatedCast, + CE->getLocStart()); } return Builder.CreateBitCast(Src, DstTy); @@ -1420,7 +1422,9 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { if (CGF.SanOpts.has(SanitizerKind::CFIDerivedCast)) CGF.EmitVTablePtrCheckForCast(DestTy->getPointeeType(), Derived, - /*MayBeNull=*/true); + /*MayBeNull=*/true, + CodeGenFunction::CFITCK_DerivedCast, + CE->getLocStart()); return Derived; } diff --git a/lib/CodeGen/CGLoopInfo.cpp b/lib/CodeGen/CGLoopInfo.cpp index 0675544bedf0..1163d63b4a20 100644 --- a/lib/CodeGen/CGLoopInfo.cpp +++ b/lib/CodeGen/CGLoopInfo.cpp @@ -8,6 +8,8 @@ //===----------------------------------------------------------------------===// #include "CGLoopInfo.h" +#include "clang/AST/Attr.h" +#include "clang/Sema/LoopHint.h" #include "llvm/IR/BasicBlock.h" #include "llvm/IR/Constants.h" #include "llvm/IR/InstrTypes.h" @@ -76,7 +78,34 @@ LoopInfo::LoopInfo(BasicBlock *Header, const LoopAttributes &Attrs) LoopID = createMetadata(Header->getContext(), Attrs); } -void LoopInfoStack::push(BasicBlock *Header) { +void LoopInfoStack::push(BasicBlock *Header, + ArrayRef<const clang::Attr *> Attrs) { + for (const auto *Attr : Attrs) { + const LoopHintAttr *LH = dyn_cast<LoopHintAttr>(Attr); + + // Skip non loop hint attributes + if (!LH) + continue; + + LoopHintAttr::OptionType Option = LH->getOption(); + LoopHintAttr::LoopHintState State = LH->getState(); + switch (Option) { + case LoopHintAttr::Vectorize: + case LoopHintAttr::Interleave: + if (State == LoopHintAttr::AssumeSafety) { + // Apply "llvm.mem.parallel_loop_access" metadata to load/stores. + setParallel(true); + } + break; + case LoopHintAttr::VectorizeWidth: + case LoopHintAttr::InterleaveCount: + case LoopHintAttr::Unroll: + case LoopHintAttr::UnrollCount: + // Nothing to do here for these loop hints. + break; + } + } + Active.push_back(LoopInfo(Header, StagedAttrs)); // Clear the attributes so nested loops do not inherit them. StagedAttrs.clear(); diff --git a/lib/CodeGen/CGLoopInfo.h b/lib/CodeGen/CGLoopInfo.h index aee162118a2f..2249937cd0d0 100644 --- a/lib/CodeGen/CGLoopInfo.h +++ b/lib/CodeGen/CGLoopInfo.h @@ -15,6 +15,7 @@ #ifndef LLVM_CLANG_LIB_CODEGEN_CGLOOPINFO_H #define LLVM_CLANG_LIB_CODEGEN_CGLOOPINFO_H +#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallVector.h" #include "llvm/IR/Value.h" @@ -27,6 +28,7 @@ class MDNode; } // end namespace llvm namespace clang { +class Attr; namespace CodeGen { /// \brief Attributes that may be specified on loops. @@ -86,7 +88,8 @@ public: /// \brief Begin a new structured loop. The set of staged attributes will be /// applied to the loop and then cleared. - void push(llvm::BasicBlock *Header); + void push(llvm::BasicBlock *Header, + llvm::ArrayRef<const Attr *> Attrs = llvm::None); /// \brief End the current loop. void pop(); diff --git a/lib/CodeGen/CGObjC.cpp b/lib/CodeGen/CGObjC.cpp index ef9a92dfc35b..9981fccb3e9d 100644 --- a/lib/CodeGen/CGObjC.cpp +++ b/lib/CodeGen/CGObjC.cpp @@ -2996,13 +2996,9 @@ CodeGenFunction::GenerateObjCAtomicGetterCopyHelperFunction( SmallVector<Expr*, 4> ConstructorArgs; ConstructorArgs.push_back(&SRC); - CXXConstructExpr::arg_iterator A = CXXConstExpr->arg_begin(); - ++A; - - for (CXXConstructExpr::arg_iterator AEnd = CXXConstExpr->arg_end(); - A != AEnd; ++A) - ConstructorArgs.push_back(*A); - + ConstructorArgs.append(std::next(CXXConstExpr->arg_begin()), + CXXConstExpr->arg_end()); + CXXConstructExpr *TheCXXConstructExpr = CXXConstructExpr::Create(C, Ty, SourceLocation(), CXXConstExpr->getConstructor(), diff --git a/lib/CodeGen/CGOpenMPRuntime.cpp b/lib/CodeGen/CGOpenMPRuntime.cpp index 1238accf42d7..3161af36c23e 100644 --- a/lib/CodeGen/CGOpenMPRuntime.cpp +++ b/lib/CodeGen/CGOpenMPRuntime.cpp @@ -741,7 +741,7 @@ CGOpenMPRuntime::createRuntimeFunction(OpenMPRTLFunction Function) { break; } case OMPRTL__kmpc_end_ordered: { - // Build void __kmpc_ordered(ident_t *loc, kmp_int32 global_tid); + // Build void __kmpc_end_ordered(ident_t *loc, kmp_int32 global_tid); llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty}; llvm::FunctionType *FnTy = llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false); @@ -756,6 +756,31 @@ CGOpenMPRuntime::createRuntimeFunction(OpenMPRTLFunction Function) { RTLFn = CGM.CreateRuntimeFunction(FnTy, "__kmpc_omp_taskwait"); break; } + case OMPRTL__kmpc_taskgroup: { + // Build void __kmpc_taskgroup(ident_t *loc, kmp_int32 global_tid); + llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty}; + llvm::FunctionType *FnTy = + llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false); + RTLFn = CGM.CreateRuntimeFunction(FnTy, "__kmpc_taskgroup"); + break; + } + case OMPRTL__kmpc_end_taskgroup: { + // Build void __kmpc_end_taskgroup(ident_t *loc, kmp_int32 global_tid); + llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty}; + llvm::FunctionType *FnTy = + llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false); + RTLFn = CGM.CreateRuntimeFunction(FnTy, "__kmpc_end_taskgroup"); + break; + } + case OMPRTL__kmpc_push_proc_bind: { + // Build void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid, + // int proc_bind) + llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty, CGM.IntTy}; + llvm::FunctionType *FnTy = + llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false); + RTLFn = CGM.CreateRuntimeFunction(FnTy, "__kmpc_push_proc_bind"); + break; + } } return RTLFn; } @@ -1240,6 +1265,25 @@ void CGOpenMPRuntime::emitTaskyieldCall(CodeGenFunction &CGF, CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_omp_taskyield), Args); } +void CGOpenMPRuntime::emitTaskgroupRegion(CodeGenFunction &CGF, + const RegionCodeGenTy &TaskgroupOpGen, + SourceLocation Loc) { + // __kmpc_taskgroup(ident_t *, gtid); + // TaskgroupOpGen(); + // __kmpc_end_taskgroup(ident_t *, gtid); + // Prepare arguments and build a call to __kmpc_taskgroup + { + CodeGenFunction::RunCleanupsScope Scope(CGF); + llvm::Value *Args[] = {emitUpdateLocation(CGF, Loc), getThreadID(CGF, Loc)}; + CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_taskgroup), Args); + // Build a call to __kmpc_end_taskgroup + CGF.EHStack.pushCleanup<CallEndCleanup<std::extent<decltype(Args)>::value>>( + NormalAndEHCleanup, createRuntimeFunction(OMPRTL__kmpc_end_taskgroup), + llvm::makeArrayRef(Args)); + emitInlinedDirective(CGF, TaskgroupOpGen); + } +} + static llvm::Value *emitCopyprivateCopyFunction( CodeGenModule &CGM, llvm::Type *ArgsType, ArrayRef<const Expr *> CopyprivateVars, ArrayRef<const Expr *> DestExprs, @@ -1600,6 +1644,39 @@ void CGOpenMPRuntime::emitNumThreadsClause(CodeGenFunction &CGF, Args); } +void CGOpenMPRuntime::emitProcBindClause(CodeGenFunction &CGF, + OpenMPProcBindClauseKind ProcBind, + SourceLocation Loc) { + // Constants for proc bind value accepted by the runtime. + enum ProcBindTy { + ProcBindFalse = 0, + ProcBindTrue, + ProcBindMaster, + ProcBindClose, + ProcBindSpread, + ProcBindIntel, + ProcBindDefault + } RuntimeProcBind; + switch (ProcBind) { + case OMPC_PROC_BIND_master: + RuntimeProcBind = ProcBindMaster; + break; + case OMPC_PROC_BIND_close: + RuntimeProcBind = ProcBindClose; + break; + case OMPC_PROC_BIND_spread: + RuntimeProcBind = ProcBindSpread; + break; + case OMPC_PROC_BIND_unknown: + llvm_unreachable("Unsupported proc_bind value."); + } + // Build call __kmpc_push_proc_bind(&loc, global_tid, proc_bind) + llvm::Value *Args[] = { + emitUpdateLocation(CGF, Loc), getThreadID(CGF, Loc), + llvm::ConstantInt::get(CGM.IntTy, RuntimeProcBind, /*isSigned=*/true)}; + CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_push_proc_bind), Args); +} + void CGOpenMPRuntime::emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *>, SourceLocation Loc) { // Build call void __kmpc_flush(ident_t *loc) @@ -2242,7 +2319,7 @@ void CGOpenMPRuntime::emitReduction(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef<const Expr *> LHSExprs, ArrayRef<const Expr *> RHSExprs, ArrayRef<const Expr *> ReductionOps, - bool WithNowait) { + bool WithNowait, bool SimpleReduction) { // Next code should be emitted for reduction: // // static kmp_critical_name lock = { 0 }; @@ -2272,9 +2349,22 @@ void CGOpenMPRuntime::emitReduction(CodeGenFunction &CGF, SourceLocation Loc, // break; // default:; // } + // + // if SimpleReduction is true, only the next code is generated: + // ... + // <LHSExprs>[i] = RedOp<i>(*<LHSExprs>[i], *<RHSExprs>[i]); + // ... auto &C = CGM.getContext(); + if (SimpleReduction) { + CodeGenFunction::RunCleanupsScope Scope(CGF); + for (auto *E : ReductionOps) { + CGF.EmitIgnoredExpr(E); + } + return; + } + // 1. Build a list of reduction variables. // void *RedList[<n>] = {<ReductionVars>[0], ..., <ReductionVars>[<n>-1]}; llvm::APInt ArraySize(/*unsigned int numBits=*/32, RHSExprs.size()); diff --git a/lib/CodeGen/CGOpenMPRuntime.h b/lib/CodeGen/CGOpenMPRuntime.h index f5aa4a51df93..d1efde25d096 100644 --- a/lib/CodeGen/CGOpenMPRuntime.h +++ b/lib/CodeGen/CGOpenMPRuntime.h @@ -131,6 +131,13 @@ private: // Call to kmp_int32 __kmpc_omp_taskwait(ident_t *loc, kmp_int32 // global_tid); OMPRTL__kmpc_omp_taskwait, + // Call to void __kmpc_taskgroup(ident_t *loc, kmp_int32 global_tid); + OMPRTL__kmpc_taskgroup, + // Call to void __kmpc_end_taskgroup(ident_t *loc, kmp_int32 global_tid); + OMPRTL__kmpc_end_taskgroup, + // Call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid, + // int proc_bind); + OMPRTL__kmpc_push_proc_bind, }; /// \brief Values for bit flags used in the ident_t to describe the fields. @@ -388,6 +395,13 @@ public: /// \brief Emits code for a taskyield directive. virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc); + /// \brief Emit a taskgroup region. + /// \param TaskgroupOpGen Generator for the statement associated with the + /// given taskgroup region. + virtual void emitTaskgroupRegion(CodeGenFunction &CGF, + const RegionCodeGenTy &TaskgroupOpGen, + SourceLocation Loc); + /// \brief Emits a single region. /// \param SingleOpGen Generator for the statement associated with the given /// single region. @@ -401,7 +415,7 @@ public: /// \brief Emit an ordered region. /// \param OrderedOpGen Generator for the statement associated with the given - /// critical region. + /// ordered region. virtual void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc); @@ -504,6 +518,12 @@ public: llvm::Value *NumThreads, SourceLocation Loc); + /// \brief Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 + /// global_tid, int proc_bind) to generate code for 'proc_bind' clause. + virtual void emitProcBindClause(CodeGenFunction &CGF, + OpenMPProcBindClauseKind ProcBind, + SourceLocation Loc); + /// \brief Returns address of the threadprivate variable for the current /// thread. /// \param VD Threadprivate variable. @@ -632,7 +652,7 @@ public: ArrayRef<const Expr *> LHSExprs, ArrayRef<const Expr *> RHSExprs, ArrayRef<const Expr *> ReductionOps, - bool WithNowait); + bool WithNowait, bool SimpleReduction); /// \brief Emit code for 'taskwait' directive. virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc); diff --git a/lib/CodeGen/CGStmt.cpp b/lib/CodeGen/CGStmt.cpp index c879750015bf..9286f0358926 100644 --- a/lib/CodeGen/CGStmt.cpp +++ b/lib/CodeGen/CGStmt.cpp @@ -222,6 +222,9 @@ void CodeGenFunction::EmitStmt(const Stmt *S) { case Stmt::OMPTaskwaitDirectiveClass: EmitOMPTaskwaitDirective(cast<OMPTaskwaitDirective>(*S)); break; + case Stmt::OMPTaskgroupDirectiveClass: + EmitOMPTaskgroupDirective(cast<OMPTaskgroupDirective>(*S)); + break; case Stmt::OMPFlushDirectiveClass: EmitOMPFlushDirective(cast<OMPFlushDirective>(*S)); break; @@ -682,7 +685,7 @@ void CodeGenFunction::EmitWhileStmt(const WhileStmt &S, JumpDest LoopHeader = getJumpDestInCurrentScope("while.cond"); EmitBlock(LoopHeader.getBlock()); - LoopStack.push(LoopHeader.getBlock()); + LoopStack.push(LoopHeader.getBlock(), WhileAttrs); // Create an exit block for when the condition fails, which will // also become the break target. @@ -776,7 +779,7 @@ void CodeGenFunction::EmitDoStmt(const DoStmt &S, // Emit the body of the loop. llvm::BasicBlock *LoopBody = createBasicBlock("do.body"); - LoopStack.push(LoopBody); + LoopStack.push(LoopBody, DoAttrs); EmitBlockWithFallThrough(LoopBody, &S); { @@ -842,7 +845,7 @@ void CodeGenFunction::EmitForStmt(const ForStmt &S, llvm::BasicBlock *CondBlock = Continue.getBlock(); EmitBlock(CondBlock); - LoopStack.push(CondBlock); + LoopStack.push(CondBlock, ForAttrs); // If the for loop doesn't have an increment we can just use the // condition as the continue block. Otherwise we'll need to create @@ -940,7 +943,7 @@ CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S, llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); EmitBlock(CondBlock); - LoopStack.push(CondBlock); + LoopStack.push(CondBlock, ForAttrs); // If there are any cleanups between here and the loop-exit scope, // create a block to stage a loop exit along. @@ -1750,6 +1753,16 @@ llvm::Value* CodeGenFunction::EmitAsmInput( const TargetInfo::ConstraintInfo &Info, const Expr *InputExpr, std::string &ConstraintStr) { + // If this can't be a register or memory, i.e., has to be a constant + // (immediate or symbolic), try to emit it as such. + if (!Info.allowsRegister() && !Info.allowsMemory()) { + llvm::APSInt Result; + if (InputExpr->EvaluateAsInt(Result, getContext())) + return llvm::ConstantInt::get(getLLVMContext(), Result); + assert(!Info.requiresImmediateConstant() && + "Required-immediate inlineasm arg isn't constant?"); + } + if (Info.allowsRegister() || !Info.allowsMemory()) if (CodeGenFunction::hasScalarEvaluationKind(InputExpr->getType())) return EmitScalarExpr(InputExpr); diff --git a/lib/CodeGen/CGStmtOpenMP.cpp b/lib/CodeGen/CGStmtOpenMP.cpp index 07fc6e966af6..5e94d56feb5f 100644 --- a/lib/CodeGen/CGStmtOpenMP.cpp +++ b/lib/CodeGen/CGStmtOpenMP.cpp @@ -316,26 +316,32 @@ void CodeGenFunction::EmitOMPLastprivateClauseFinal( // ... // orig_varn = private_orig_varn; // } - auto *ThenBB = createBasicBlock(".omp.lastprivate.then"); - auto *DoneBB = createBasicBlock(".omp.lastprivate.done"); - Builder.CreateCondBr(IsLastIterCond, ThenBB, DoneBB); - EmitBlock(ThenBB); + llvm::BasicBlock *ThenBB = nullptr; + llvm::BasicBlock *DoneBB = nullptr; + if (IsLastIterCond) { + ThenBB = createBasicBlock(".omp.lastprivate.then"); + DoneBB = createBasicBlock(".omp.lastprivate.done"); + Builder.CreateCondBr(IsLastIterCond, ThenBB, DoneBB); + EmitBlock(ThenBB); + } llvm::DenseMap<const Decl *, const Expr *> LoopCountersAndUpdates; const Expr *LastIterVal = nullptr; const Expr *IVExpr = nullptr; const Expr *IncExpr = nullptr; if (auto *LoopDirective = dyn_cast<OMPLoopDirective>(&D)) { - LastIterVal = - cast<VarDecl>(cast<DeclRefExpr>(LoopDirective->getUpperBoundVariable()) - ->getDecl()) - ->getAnyInitializer(); - IVExpr = LoopDirective->getIterationVariable(); - IncExpr = LoopDirective->getInc(); - auto IUpdate = LoopDirective->updates().begin(); - for (auto *E : LoopDirective->counters()) { - auto *D = cast<DeclRefExpr>(E)->getDecl()->getCanonicalDecl(); - LoopCountersAndUpdates[D] = *IUpdate; - ++IUpdate; + if (isOpenMPWorksharingDirective(D.getDirectiveKind())) { + LastIterVal = cast<VarDecl>(cast<DeclRefExpr>( + LoopDirective->getUpperBoundVariable()) + ->getDecl()) + ->getAnyInitializer(); + IVExpr = LoopDirective->getIterationVariable(); + IncExpr = LoopDirective->getInc(); + auto IUpdate = LoopDirective->updates().begin(); + for (auto *E : LoopDirective->counters()) { + auto *D = cast<DeclRefExpr>(E)->getDecl()->getCanonicalDecl(); + LoopCountersAndUpdates[D] = *IUpdate; + ++IUpdate; + } } } { @@ -355,7 +361,7 @@ void CodeGenFunction::EmitOMPLastprivateClauseFinal( // directive, update its value before copyin back to original // variable. if (auto *UpExpr = LoopCountersAndUpdates.lookup(CanonicalVD)) { - if (FirstLCV) { + if (FirstLCV && LastIterVal) { EmitAnyExprToMem(LastIterVal, EmitLValue(IVExpr).getAddress(), IVExpr->getType().getQualifiers(), /*IsInitializer=*/false); @@ -379,7 +385,9 @@ void CodeGenFunction::EmitOMPLastprivateClauseFinal( } } } - EmitBlock(DoneBB, /*IsFinished=*/true); + if (IsLastIterCond) { + EmitBlock(DoneBB, /*IsFinished=*/true); + } } void CodeGenFunction::EmitOMPReductionClauseInit( @@ -435,7 +443,9 @@ void CodeGenFunction::EmitOMPReductionClauseFinal( CGM.getOpenMPRuntime().emitReduction( *this, D.getLocEnd(), LHSExprs, RHSExprs, ReductionOps, D.getSingleClause(OMPC_nowait) || - isOpenMPParallelDirective(D.getDirectiveKind())); + isOpenMPParallelDirective(D.getDirectiveKind()) || + D.getDirectiveKind() == OMPD_simd, + D.getDirectiveKind() == OMPD_simd); } } @@ -454,6 +464,12 @@ static void emitCommonOMPParallelDirective(CodeGenFunction &CGF, CGF.CGM.getOpenMPRuntime().emitNumThreadsClause( CGF, NumThreads, NumThreadsClause->getLocStart()); } + if (auto *C = S.getSingleClause(OMPC_proc_bind)) { + CodeGenFunction::RunCleanupsScope NumThreadsScope(CGF); + auto *ProcBindClause = cast<OMPProcBindClause>(C); + CGF.CGM.getOpenMPRuntime().emitProcBindClause( + CGF, ProcBindClause->getProcBindKind(), ProcBindClause->getLocStart()); + } const Expr *IfCond = nullptr; if (auto C = S.getSingleClause(OMPC_if)) { IfCond = cast<OMPIfClause>(C)->getCondition(); @@ -489,15 +505,14 @@ void CodeGenFunction::EmitOMPParallelDirective(const OMPParallelDirective &S) { emitCommonOMPParallelDirective(*this, S, CodeGen); } -void CodeGenFunction::EmitOMPLoopBody(const OMPLoopDirective &S, - bool SeparateIter) { +void CodeGenFunction::EmitOMPLoopBody(const OMPLoopDirective &D) { RunCleanupsScope BodyScope(*this); // Update counters values on current iteration. - for (auto I : S.updates()) { + for (auto I : D.updates()) { EmitIgnoredExpr(I); } // Update the linear variables. - for (auto &&I = S.getClausesOfKind(OMPC_linear); I; ++I) { + for (auto &&I = D.getClausesOfKind(OMPC_linear); I; ++I) { auto *C = cast<OMPLinearClause>(*I); for (auto U : C->updates()) { EmitIgnoredExpr(U); @@ -508,16 +523,14 @@ void CodeGenFunction::EmitOMPLoopBody(const OMPLoopDirective &S, auto Continue = getJumpDestInCurrentScope("omp.body.continue"); BreakContinueStack.push_back(BreakContinue(JumpDest(), Continue)); // Emit loop body. - EmitStmt(S.getBody()); + EmitStmt(D.getBody()); // The end (updates/cleanups). EmitBlock(Continue.getBlock()); BreakContinueStack.pop_back(); - if (SeparateIter) { // TODO: Update lastprivates if the SeparateIter flag is true. // This will be implemented in a follow-up OMPLastprivateClause patch, but // result should be still correct without it, as we do not make these // variables private yet. - } } void CodeGenFunction::EmitOMPInnerLoop( @@ -567,70 +580,89 @@ void CodeGenFunction::EmitOMPInnerLoop( EmitBlock(LoopExit.getBlock()); } -void CodeGenFunction::EmitOMPSimdFinal(const OMPLoopDirective &S) { - auto IC = S.counters().begin(); - for (auto F : S.finals()) { - auto *OrigVD = cast<VarDecl>(cast<DeclRefExpr>((*IC))->getDecl()); - if (LocalDeclMap.lookup(OrigVD)) { +void CodeGenFunction::EmitOMPLinearClauseInit(const OMPLoopDirective &D) { + // Emit inits for the linear variables. + for (auto &&I = D.getClausesOfKind(OMPC_linear); I; ++I) { + auto *C = cast<OMPLinearClause>(*I); + for (auto Init : C->inits()) { + auto *VD = cast<VarDecl>(cast<DeclRefExpr>(Init)->getDecl()); + auto *OrigVD = cast<VarDecl>( + cast<DeclRefExpr>(VD->getInit()->IgnoreImpCasts())->getDecl()); DeclRefExpr DRE(const_cast<VarDecl *>(OrigVD), CapturedStmtInfo->lookup(OrigVD) != nullptr, - (*IC)->getType(), VK_LValue, (*IC)->getExprLoc()); - auto *OrigAddr = EmitLValue(&DRE).getAddress(); - OMPPrivateScope VarScope(*this); - VarScope.addPrivate(OrigVD, - [OrigAddr]() -> llvm::Value *{ return OrigAddr; }); - (void)VarScope.Privatize(); - EmitIgnoredExpr(F); + VD->getInit()->getType(), VK_LValue, + VD->getInit()->getExprLoc()); + AutoVarEmission Emission = EmitAutoVarAlloca(*VD); + EmitExprAsInit(&DRE, VD, + MakeAddrLValue(Emission.getAllocatedAddress(), + VD->getType(), Emission.Alignment), + /*capturedByInit=*/false); + EmitAutoVarCleanups(Emission); } - ++IC; + // Emit the linear steps for the linear clauses. + // If a step is not constant, it is pre-calculated before the loop. + if (auto CS = cast_or_null<BinaryOperator>(C->getCalcStep())) + if (auto SaveRef = cast<DeclRefExpr>(CS->getLHS())) { + EmitVarDecl(*cast<VarDecl>(SaveRef->getDecl())); + // Emit calculation of the linear step. + EmitIgnoredExpr(CS); + } } +} + +static void emitLinearClauseFinal(CodeGenFunction &CGF, + const OMPLoopDirective &D) { // Emit the final values of the linear variables. - for (auto &&I = S.getClausesOfKind(OMPC_linear); I; ++I) { + for (auto &&I = D.getClausesOfKind(OMPC_linear); I; ++I) { auto *C = cast<OMPLinearClause>(*I); auto IC = C->varlist_begin(); for (auto F : C->finals()) { auto *OrigVD = cast<VarDecl>(cast<DeclRefExpr>(*IC)->getDecl()); DeclRefExpr DRE(const_cast<VarDecl *>(OrigVD), - CapturedStmtInfo->lookup(OrigVD) != nullptr, + CGF.CapturedStmtInfo->lookup(OrigVD) != nullptr, (*IC)->getType(), VK_LValue, (*IC)->getExprLoc()); - auto *OrigAddr = EmitLValue(&DRE).getAddress(); - OMPPrivateScope VarScope(*this); + auto *OrigAddr = CGF.EmitLValue(&DRE).getAddress(); + CodeGenFunction::OMPPrivateScope VarScope(CGF); VarScope.addPrivate(OrigVD, [OrigAddr]() -> llvm::Value *{ return OrigAddr; }); (void)VarScope.Privatize(); - EmitIgnoredExpr(F); + CGF.EmitIgnoredExpr(F); ++IC; } } } -static void EmitOMPAlignedClause(CodeGenFunction &CGF, CodeGenModule &CGM, - const OMPAlignedClause &Clause) { - unsigned ClauseAlignment = 0; - if (auto AlignmentExpr = Clause.getAlignment()) { - auto AlignmentCI = - cast<llvm::ConstantInt>(CGF.EmitScalarExpr(AlignmentExpr)); - ClauseAlignment = static_cast<unsigned>(AlignmentCI->getZExtValue()); - } - for (auto E : Clause.varlists()) { - unsigned Alignment = ClauseAlignment; - if (Alignment == 0) { - // OpenMP [2.8.1, Description] - // If no optional parameter is specified, implementation-defined default - // alignments for SIMD instructions on the target platforms are assumed. - Alignment = CGM.getTargetCodeGenInfo().getOpenMPSimdDefaultAlignment( - E->getType()); +static void emitAlignedClause(CodeGenFunction &CGF, + const OMPExecutableDirective &D) { + for (auto &&I = D.getClausesOfKind(OMPC_aligned); I; ++I) { + auto *Clause = cast<OMPAlignedClause>(*I); + unsigned ClauseAlignment = 0; + if (auto AlignmentExpr = Clause->getAlignment()) { + auto AlignmentCI = + cast<llvm::ConstantInt>(CGF.EmitScalarExpr(AlignmentExpr)); + ClauseAlignment = static_cast<unsigned>(AlignmentCI->getZExtValue()); } - assert((Alignment == 0 || llvm::isPowerOf2_32(Alignment)) && - "alignment is not power of 2"); - if (Alignment != 0) { - llvm::Value *PtrValue = CGF.EmitScalarExpr(E); - CGF.EmitAlignmentAssumption(PtrValue, Alignment); + for (auto E : Clause->varlists()) { + unsigned Alignment = ClauseAlignment; + if (Alignment == 0) { + // OpenMP [2.8.1, Description] + // If no optional parameter is specified, implementation-defined default + // alignments for SIMD instructions on the target platforms are assumed. + Alignment = + CGF.CGM.getTargetCodeGenInfo().getOpenMPSimdDefaultAlignment( + E->getType()); + } + assert((Alignment == 0 || llvm::isPowerOf2_32(Alignment)) && + "alignment is not power of 2"); + if (Alignment != 0) { + llvm::Value *PtrValue = CGF.EmitScalarExpr(E); + CGF.EmitAlignmentAssumption(PtrValue, Alignment); + } } } } -static void EmitPrivateLoopCounters(CodeGenFunction &CGF, +static void emitPrivateLoopCounters(CodeGenFunction &CGF, CodeGenFunction::OMPPrivateScope &LoopScope, ArrayRef<Expr *> Counters) { for (auto *E : Counters) { @@ -647,37 +679,39 @@ static void EmitPrivateLoopCounters(CodeGenFunction &CGF, static void emitPreCond(CodeGenFunction &CGF, const OMPLoopDirective &S, const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount) { - CodeGenFunction::OMPPrivateScope PreCondScope(CGF); - EmitPrivateLoopCounters(CGF, PreCondScope, S.counters()); - const VarDecl *IVDecl = - cast<VarDecl>(cast<DeclRefExpr>(S.getIterationVariable())->getDecl()); - bool IsRegistered = PreCondScope.addPrivate(IVDecl, [&]() -> llvm::Value *{ - // Emit var without initialization. - auto VarEmission = CGF.EmitAutoVarAlloca(*IVDecl); - CGF.EmitAutoVarCleanups(VarEmission); - return VarEmission.getAllocatedAddress(); - }); - assert(IsRegistered && "counter already registered as private"); - // Silence the warning about unused variable. - (void)IsRegistered; - (void)PreCondScope.Privatize(); - // Initialize internal counter to 0 to calculate initial values of real - // counters. - LValue IV = CGF.EmitLValue(S.getIterationVariable()); - CGF.EmitStoreOfScalar( - llvm::ConstantInt::getNullValue( - IV.getAddress()->getType()->getPointerElementType()), - CGF.EmitLValue(S.getIterationVariable()), /*isInit=*/true); - // Get initial values of real counters. - for (auto I : S.updates()) { - CGF.EmitIgnoredExpr(I); + { + CodeGenFunction::OMPPrivateScope PreCondScope(CGF); + emitPrivateLoopCounters(CGF, PreCondScope, S.counters()); + const VarDecl *IVDecl = + cast<VarDecl>(cast<DeclRefExpr>(S.getIterationVariable())->getDecl()); + bool IsRegistered = PreCondScope.addPrivate(IVDecl, [&]() -> llvm::Value *{ + // Emit var without initialization. + auto VarEmission = CGF.EmitAutoVarAlloca(*IVDecl); + CGF.EmitAutoVarCleanups(VarEmission); + return VarEmission.getAllocatedAddress(); + }); + assert(IsRegistered && "counter already registered as private"); + // Silence the warning about unused variable. + (void)IsRegistered; + (void)PreCondScope.Privatize(); + // Initialize internal counter to 0 to calculate initial values of real + // counters. + LValue IV = CGF.EmitLValue(S.getIterationVariable()); + CGF.EmitStoreOfScalar( + llvm::ConstantInt::getNullValue( + IV.getAddress()->getType()->getPointerElementType()), + CGF.EmitLValue(S.getIterationVariable()), /*isInit=*/true); + // Get initial values of real counters. + for (auto I : S.updates()) { + CGF.EmitIgnoredExpr(I); + } } // Check that loop is executed at least one time. CGF.EmitBranchOnBoolExpr(Cond, TrueBlock, FalseBlock, TrueCount); } static void -EmitPrivateLinearVars(CodeGenFunction &CGF, const OMPExecutableDirective &D, +emitPrivateLinearVars(CodeGenFunction &CGF, const OMPExecutableDirective &D, CodeGenFunction::OMPPrivateScope &PrivateScope) { for (auto &&I = D.getClausesOfKind(OMPC_linear); I; ++I) { auto *C = cast<OMPLinearClause>(*I); @@ -696,19 +730,50 @@ EmitPrivateLinearVars(CodeGenFunction &CGF, const OMPExecutableDirective &D, } } +static void emitSafelenClause(CodeGenFunction &CGF, + const OMPExecutableDirective &D) { + if (auto *C = + cast_or_null<OMPSafelenClause>(D.getSingleClause(OMPC_safelen))) { + RValue Len = CGF.EmitAnyExpr(C->getSafelen(), AggValueSlot::ignored(), + /*ignoreResult=*/true); + llvm::ConstantInt *Val = cast<llvm::ConstantInt>(Len.getScalarVal()); + CGF.LoopStack.setVectorizerWidth(Val->getZExtValue()); + // In presence of finite 'safelen', it may be unsafe to mark all + // the memory instructions parallel, because loop-carried + // dependences of 'safelen' iterations are possible. + CGF.LoopStack.setParallel(false); + } +} + +void CodeGenFunction::EmitOMPSimdInit(const OMPLoopDirective &D) { + // Walk clauses and process safelen/lastprivate. + LoopStack.setParallel(); + LoopStack.setVectorizerEnable(true); + emitSafelenClause(*this, D); +} + +void CodeGenFunction::EmitOMPSimdFinal(const OMPLoopDirective &D) { + auto IC = D.counters().begin(); + for (auto F : D.finals()) { + auto *OrigVD = cast<VarDecl>(cast<DeclRefExpr>((*IC))->getDecl()); + if (LocalDeclMap.lookup(OrigVD) || CapturedStmtInfo->lookup(OrigVD)) { + DeclRefExpr DRE(const_cast<VarDecl *>(OrigVD), + CapturedStmtInfo->lookup(OrigVD) != nullptr, + (*IC)->getType(), VK_LValue, (*IC)->getExprLoc()); + auto *OrigAddr = EmitLValue(&DRE).getAddress(); + OMPPrivateScope VarScope(*this); + VarScope.addPrivate(OrigVD, + [OrigAddr]() -> llvm::Value *{ return OrigAddr; }); + (void)VarScope.Privatize(); + EmitIgnoredExpr(F); + } + ++IC; + } + emitLinearClauseFinal(*this, D); +} + void CodeGenFunction::EmitOMPSimdDirective(const OMPSimdDirective &S) { auto &&CodeGen = [&S](CodeGenFunction &CGF) { - // Pragma 'simd' code depends on presence of 'lastprivate'. - // If present, we have to separate last iteration of the loop: - // - // if (PreCond) { - // for (IV in 0..LastIteration-1) BODY; - // BODY with updates of lastprivate vars; - // <Final counter/linear vars updates>; - // } - // - // otherwise (when there's no lastprivate): - // // if (PreCond) { // for (IV in 0..LastIteration) BODY; // <Final counter/linear vars updates>; @@ -731,43 +796,6 @@ void CodeGenFunction::EmitOMPSimdDirective(const OMPSimdDirective &S) { CGF.EmitBlock(ThenBlock); CGF.incrementProfileCounter(&S); } - // Walk clauses and process safelen/lastprivate. - bool SeparateIter = false; - CGF.LoopStack.setParallel(); - CGF.LoopStack.setVectorizerEnable(true); - for (auto C : S.clauses()) { - switch (C->getClauseKind()) { - case OMPC_safelen: { - RValue Len = CGF.EmitAnyExpr(cast<OMPSafelenClause>(C)->getSafelen(), - AggValueSlot::ignored(), true); - llvm::ConstantInt *Val = cast<llvm::ConstantInt>(Len.getScalarVal()); - CGF.LoopStack.setVectorizerWidth(Val->getZExtValue()); - // In presence of finite 'safelen', it may be unsafe to mark all - // the memory instructions parallel, because loop-carried - // dependences of 'safelen' iterations are possible. - CGF.LoopStack.setParallel(false); - break; - } - case OMPC_aligned: - EmitOMPAlignedClause(CGF, CGF.CGM, cast<OMPAlignedClause>(*C)); - break; - case OMPC_lastprivate: - SeparateIter = true; - break; - default: - // Not handled yet - ; - } - } - - // Emit inits for the linear variables. - for (auto &&I = S.getClausesOfKind(OMPC_linear); I; ++I) { - auto *C = cast<OMPLinearClause>(*I); - for (auto Init : C->inits()) { - auto *D = cast<VarDecl>(cast<DeclRefExpr>(Init)->getDecl()); - CGF.EmitVarDecl(*D); - } - } // Emit the loop iteration variable. const Expr *IVExpr = S.getIterationVariable(); @@ -784,34 +812,31 @@ void CodeGenFunction::EmitOMPSimdDirective(const OMPSimdDirective &S) { CGF.EmitIgnoredExpr(S.getCalcLastIteration()); } - // Emit the linear steps for the linear clauses. - // If a step is not constant, it is pre-calculated before the loop. - for (auto &&I = S.getClausesOfKind(OMPC_linear); I; ++I) { - auto *C = cast<OMPLinearClause>(*I); - if (auto CS = cast_or_null<BinaryOperator>(C->getCalcStep())) - if (auto SaveRef = cast<DeclRefExpr>(CS->getLHS())) { - CGF.EmitVarDecl(*cast<VarDecl>(SaveRef->getDecl())); - // Emit calculation of the linear step. - CGF.EmitIgnoredExpr(CS); - } - } + CGF.EmitOMPSimdInit(S); + emitAlignedClause(CGF, S); + CGF.EmitOMPLinearClauseInit(S); + bool HasLastprivateClause; { OMPPrivateScope LoopScope(CGF); - EmitPrivateLoopCounters(CGF, LoopScope, S.counters()); - EmitPrivateLinearVars(CGF, S, LoopScope); + emitPrivateLoopCounters(CGF, LoopScope, S.counters()); + emitPrivateLinearVars(CGF, S, LoopScope); CGF.EmitOMPPrivateClause(S, LoopScope); + CGF.EmitOMPReductionClauseInit(S, LoopScope); + HasLastprivateClause = CGF.EmitOMPLastprivateClauseInit(S, LoopScope); (void)LoopScope.Privatize(); CGF.EmitOMPInnerLoop(S, LoopScope.requiresCleanups(), - S.getCond(SeparateIter), S.getInc(), + S.getCond(), S.getInc(), [&S](CodeGenFunction &CGF) { CGF.EmitOMPLoopBody(S); CGF.EmitStopPoint(&S); }, [](CodeGenFunction &) {}); - if (SeparateIter) { - CGF.EmitOMPLoopBody(S, /*SeparateIter=*/true); + // Emit final copy of the lastprivate variables at the end of loops. + if (HasLastprivateClause) { + CGF.EmitOMPLastprivateClauseFinal(S); } + CGF.EmitOMPReductionClauseFinal(S); } CGF.EmitOMPSimdFinal(S); // Emit: if (PreCond) - end. @@ -912,7 +937,7 @@ void CodeGenFunction::EmitOMPForOuterLoop(OpenMPScheduleClauseKind ScheduleKind, // IV = LB EmitIgnoredExpr(S.getInit()); // IV < UB - BoolCondVal = EvaluateExprAsBool(S.getCond(false)); + BoolCondVal = EvaluateExprAsBool(S.getCond()); } else { BoolCondVal = RT.emitForNext(*this, S.getLocStart(), IVSize, IVSigned, IL, LB, UB, ST); @@ -941,14 +966,19 @@ void CodeGenFunction::EmitOMPForOuterLoop(OpenMPScheduleClauseKind ScheduleKind, auto Continue = getJumpDestInCurrentScope("omp.dispatch.inc"); BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); + // Generate !llvm.loop.parallel metadata for loads and stores for loops + // with dynamic/guided scheduling and without ordered clause. + if (!isOpenMPSimdDirective(S.getDirectiveKind())) { + LoopStack.setParallel((ScheduleKind == OMPC_SCHEDULE_dynamic || + ScheduleKind == OMPC_SCHEDULE_guided) && + !Ordered); + } else { + EmitOMPSimdInit(S); + } + SourceLocation Loc = S.getLocStart(); - // Generate !llvm.loop.parallel metadata for loads and stores for loops with - // dynamic/guided scheduling and without ordered clause. - LoopStack.setParallel((ScheduleKind == OMPC_SCHEDULE_dynamic || - ScheduleKind == OMPC_SCHEDULE_guided) && - !Ordered); EmitOMPInnerLoop( - S, LoopScope.requiresCleanups(), S.getCond(/*SeparateIter=*/false), + S, LoopScope.requiresCleanups(), S.getCond(), S.getInc(), [&S](CodeGenFunction &CGF) { CGF.EmitOMPLoopBody(S); @@ -1055,6 +1085,9 @@ bool CodeGenFunction::EmitOMPWorksharingLoop(const OMPLoopDirective &S) { EmitBlock(ThenBlock); incrementProfileCounter(&S); } + + emitAlignedClause(*this, S); + EmitOMPLinearClauseInit(S); // Emit 'then' code. { // Emit helper vars inits. @@ -1077,7 +1110,8 @@ bool CodeGenFunction::EmitOMPWorksharingLoop(const OMPLoopDirective &S) { EmitOMPPrivateClause(S, LoopScope); HasLastprivateClause = EmitOMPLastprivateClauseInit(S, LoopScope); EmitOMPReductionClauseInit(S, LoopScope); - EmitPrivateLoopCounters(*this, LoopScope, S.counters()); + emitPrivateLoopCounters(*this, LoopScope, S.counters()); + emitPrivateLinearVars(*this, S, LoopScope); (void)LoopScope.Privatize(); // Detect the loop schedule kind and chunk. @@ -1093,6 +1127,9 @@ bool CodeGenFunction::EmitOMPWorksharingLoop(const OMPLoopDirective &S) { if (RT.isStaticNonchunked(ScheduleKind, /* Chunked */ Chunk != nullptr) && !Ordered) { + if (isOpenMPSimdDirective(S.getDirectiveKind())) { + EmitOMPSimdInit(S); + } // OpenMP [2.7.1, Loop Construct, Description, table 2-1] // When no chunk_size is specified, the iteration space is divided into // chunks that are approximately equal in size, and at most one chunk is @@ -1106,8 +1143,8 @@ bool CodeGenFunction::EmitOMPWorksharingLoop(const OMPLoopDirective &S) { // IV = LB; EmitIgnoredExpr(S.getInit()); // while (idx <= UB) { BODY; ++idx; } - EmitOMPInnerLoop(S, LoopScope.requiresCleanups(), - S.getCond(/*SeparateIter=*/false), S.getInc(), + EmitOMPInnerLoop(S, LoopScope.requiresCleanups(), S.getCond(), + S.getInc(), [&S](CodeGenFunction &CGF) { CGF.EmitOMPLoopBody(S); CGF.EmitStopPoint(&S); @@ -1128,6 +1165,9 @@ bool CodeGenFunction::EmitOMPWorksharingLoop(const OMPLoopDirective &S) { EmitOMPLastprivateClauseFinal( S, Builder.CreateIsNotNull(EmitLoadOfScalar(IL, S.getLocStart()))); } + if (isOpenMPSimdDirective(S.getDirectiveKind())) { + EmitOMPSimdFinal(S); + } // We're now done with the loop, so jump to the continuation block. if (ContBlock) { EmitBranch(ContBlock); @@ -1151,8 +1191,18 @@ void CodeGenFunction::EmitOMPForDirective(const OMPForDirective &S) { } } -void CodeGenFunction::EmitOMPForSimdDirective(const OMPForSimdDirective &) { - llvm_unreachable("CodeGen for 'omp for simd' is not supported yet."); +void CodeGenFunction::EmitOMPForSimdDirective(const OMPForSimdDirective &S) { + LexicalScope Scope(*this, S.getSourceRange()); + bool HasLastprivates = false; + auto &&CodeGen = [&S, &HasLastprivates](CodeGenFunction &CGF) { + HasLastprivates = CGF.EmitOMPWorksharingLoop(S); + }; + CGM.getOpenMPRuntime().emitInlinedDirective(*this, CodeGen); + + // Emit an implicit barrier at the end. + if (!S.getSingleClause(OMPC_nowait) || HasLastprivates) { + CGM.getOpenMPRuntime().emitBarrierCall(*this, S.getLocStart(), OMPD_for); + } } static LValue createSectionLVal(CodeGenFunction &CGF, QualType Ty, @@ -1407,8 +1457,20 @@ void CodeGenFunction::EmitOMPParallelForDirective( } void CodeGenFunction::EmitOMPParallelForSimdDirective( - const OMPParallelForSimdDirective &) { - llvm_unreachable("CodeGen for 'omp parallel for simd' is not supported yet."); + const OMPParallelForSimdDirective &S) { + // Emit directive as a combined directive that consists of two implicit + // directives: 'parallel' with 'for' directive. + LexicalScope Scope(*this, S.getSourceRange()); + (void)emitScheduleClause(*this, S, /*OuterRegion=*/true); + auto &&CodeGen = [&S](CodeGenFunction &CGF) { + CGF.EmitOMPWorksharingLoop(S); + // Emit implicit barrier at the end of parallel region, but this barrier + // is at the end of 'for' directive, so emit it as the implicit barrier for + // this 'for' directive. + CGF.CGM.getOpenMPRuntime().emitBarrierCall(CGF, S.getLocStart(), + OMPD_parallel); + }; + emitCommonOMPParallelDirective(*this, S, CodeGen); } void CodeGenFunction::EmitOMPParallelSectionsDirective( @@ -1556,6 +1618,16 @@ void CodeGenFunction::EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S) { CGM.getOpenMPRuntime().emitTaskwaitCall(*this, S.getLocStart()); } +void CodeGenFunction::EmitOMPTaskgroupDirective( + const OMPTaskgroupDirective &S) { + LexicalScope Scope(*this, S.getSourceRange()); + auto &&CodeGen = [&S](CodeGenFunction &CGF) { + CGF.EmitStmt(cast<CapturedStmt>(S.getAssociatedStmt())->getCapturedStmt()); + CGF.EnsureInsertPoint(); + }; + CGM.getOpenMPRuntime().emitTaskgroupRegion(*this, CodeGen, S.getLocStart()); +} + void CodeGenFunction::EmitOMPFlushDirective(const OMPFlushDirective &S) { CGM.getOpenMPRuntime().emitFlush(*this, [&]() -> ArrayRef<const Expr *> { if (auto C = S.getSingleClause(/*K*/ OMPC_flush)) { diff --git a/lib/CodeGen/CGVTables.cpp b/lib/CodeGen/CGVTables.cpp index 57370a6faa2c..17db40138296 100644 --- a/lib/CodeGen/CGVTables.cpp +++ b/lib/CodeGen/CGVTables.cpp @@ -848,7 +848,8 @@ void CodeGenModule::EmitVTableBitSetEntries(llvm::GlobalVariable *VTable, !LangOpts.Sanitize.has(SanitizerKind::CFIUnrelatedCast)) return; - llvm::Metadata *VTableMD = llvm::ConstantAsMetadata::get(VTable); + CharUnits PointerWidth = + Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0)); std::vector<llvm::MDTuple *> BitsetEntries; // Create a bit set entry for each address point. @@ -857,23 +858,8 @@ void CodeGenModule::EmitVTableBitSetEntries(llvm::GlobalVariable *VTable, if (AP.first.getBase()->isInStdNamespace()) continue; - std::string OutName; - llvm::raw_string_ostream Out(OutName); - getCXXABI().getMangleContext().mangleCXXVTableBitSet(AP.first.getBase(), - Out); - - CharUnits PointerWidth = - Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0)); - uint64_t AddrPointOffset = AP.second * PointerWidth.getQuantity(); - - llvm::Metadata *BitsetOps[] = { - llvm::MDString::get(getLLVMContext(), Out.str()), - VTableMD, - llvm::ConstantAsMetadata::get( - llvm::ConstantInt::get(Int64Ty, AddrPointOffset))}; - llvm::MDTuple *BitsetEntry = - llvm::MDTuple::get(getLLVMContext(), BitsetOps); - BitsetEntries.push_back(BitsetEntry); + BitsetEntries.push_back(CreateVTableBitSetEntry( + VTable, PointerWidth * AP.second, AP.first.getBase())); } // Sort the bit set entries for determinism. diff --git a/lib/CodeGen/CodeGenAction.cpp b/lib/CodeGen/CodeGenAction.cpp index 7e82fcc4b22a..54e6b73b3020 100644 --- a/lib/CodeGen/CodeGenAction.cpp +++ b/lib/CodeGen/CodeGenAction.cpp @@ -649,14 +649,14 @@ CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { return nullptr; } - ErrorOr<llvm::Module *> ModuleOrErr = + ErrorOr<std::unique_ptr<llvm::Module>> ModuleOrErr = getLazyBitcodeModule(std::move(*BCBuf), *VMContext); if (std::error_code EC = ModuleOrErr.getError()) { CI.getDiagnostics().Report(diag::err_cannot_open_file) << LinkBCFile << EC.message(); return nullptr; } - LinkModuleToUse = ModuleOrErr.get(); + LinkModuleToUse = ModuleOrErr.get().release(); } CoverageSourceInfo *CoverageInfo = nullptr; diff --git a/lib/CodeGen/CodeGenFunction.cpp b/lib/CodeGen/CodeGenFunction.cpp index 01da75005610..bece41e9ecb2 100644 --- a/lib/CodeGen/CodeGenFunction.cpp +++ b/lib/CodeGen/CodeGenFunction.cpp @@ -615,12 +615,14 @@ void CodeGenFunction::StartFunction(GlobalDecl GD, } // Apply sanitizer attributes to the function. - if (SanOpts.has(SanitizerKind::Address)) + if (SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress)) Fn->addFnAttr(llvm::Attribute::SanitizeAddress); if (SanOpts.has(SanitizerKind::Thread)) Fn->addFnAttr(llvm::Attribute::SanitizeThread); if (SanOpts.has(SanitizerKind::Memory)) Fn->addFnAttr(llvm::Attribute::SanitizeMemory); + if (SanOpts.has(SanitizerKind::SafeStack)) + Fn->addFnAttr(llvm::Attribute::SafeStack); // Pass inline keyword to optimizer if it appears explicitly on any // declaration. Also, in the case of -fno-inline attach NoInline diff --git a/lib/CodeGen/CodeGenFunction.h b/lib/CodeGen/CodeGenFunction.h index 469022dc62ed..45475d1af1c4 100644 --- a/lib/CodeGen/CodeGenFunction.h +++ b/lib/CodeGen/CodeGenFunction.h @@ -1311,19 +1311,29 @@ public: /// to by This. llvm::Value *GetVTablePtr(llvm::Value *This, llvm::Type *Ty); + enum CFITypeCheckKind { + CFITCK_VCall, + CFITCK_NVCall, + CFITCK_DerivedCast, + CFITCK_UnrelatedCast, + }; + /// \brief Derived is the presumed address of an object of type T after a /// cast. If T is a polymorphic class type, emit a check that the virtual /// table for Derived belongs to a class derived from T. void EmitVTablePtrCheckForCast(QualType T, llvm::Value *Derived, - bool MayBeNull); + bool MayBeNull, CFITypeCheckKind TCK, + SourceLocation Loc); /// EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable. /// If vptr CFI is enabled, emit a check that VTable is valid. - void EmitVTablePtrCheckForCall(const CXXMethodDecl *MD, llvm::Value *VTable); + void EmitVTablePtrCheckForCall(const CXXMethodDecl *MD, llvm::Value *VTable, + CFITypeCheckKind TCK, SourceLocation Loc); /// EmitVTablePtrCheck - Emit a check that VTable is a valid virtual table for /// RD using llvm.bitset.test. - void EmitVTablePtrCheck(const CXXRecordDecl *RD, llvm::Value *VTable); + void EmitVTablePtrCheck(const CXXRecordDecl *RD, llvm::Value *VTable, + CFITypeCheckKind TCK, SourceLocation Loc); /// CanDevirtualizeMemberFunctionCalls - Checks whether virtual calls on given /// expr can be devirtualized. @@ -2130,9 +2140,9 @@ public: /// \param D Directive that has at least one 'lastprivate' directives. /// \param IsLastIterCond Boolean condition that must be set to 'i1 true' if /// it is the last iteration of the loop code in associated directive, or to - /// 'i1 false' otherwise. + /// 'i1 false' otherwise. If this item is nullptr, no final check is required. void EmitOMPLastprivateClauseFinal(const OMPExecutableDirective &D, - llvm::Value *IsLastIterCond); + llvm::Value *IsLastIterCond = nullptr); /// \brief Emit initial code for reduction variables. Creates reduction copies /// and initializes them with the values according to OpenMP standard. /// @@ -2147,6 +2157,11 @@ public: /// /// \param D Directive that has at least one 'reduction' directives. void EmitOMPReductionClauseFinal(const OMPExecutableDirective &D); + /// \brief Emit initial code for linear variables. Creates private copies + /// and initializes them with the values according to OpenMP standard. + /// + /// \param D Directive (possibly) with the 'linear' clause. + void EmitOMPLinearClauseInit(const OMPLoopDirective &D); void EmitOMPParallelDirective(const OMPParallelDirective &S); void EmitOMPSimdDirective(const OMPSimdDirective &S); @@ -2164,6 +2179,7 @@ public: void EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &S); void EmitOMPBarrierDirective(const OMPBarrierDirective &S); void EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S); + void EmitOMPTaskgroupDirective(const OMPTaskgroupDirective &S); void EmitOMPFlushDirective(const OMPFlushDirective &S); void EmitOMPOrderedDirective(const OMPOrderedDirective &S); void EmitOMPAtomicDirective(const OMPAtomicDirective &S); @@ -2189,9 +2205,9 @@ public: private: /// Helpers for the OpenMP loop directives. - void EmitOMPLoopBody(const OMPLoopDirective &Directive, - bool SeparateIter = false); - void EmitOMPSimdFinal(const OMPLoopDirective &S); + void EmitOMPLoopBody(const OMPLoopDirective &D); + void EmitOMPSimdInit(const OMPLoopDirective &D); + void EmitOMPSimdFinal(const OMPLoopDirective &D); /// \brief Emit code for the worksharing loop-based directive. /// \return true, if this construct has any lastprivate clause, false - /// otherwise. @@ -2568,7 +2584,7 @@ public: llvm::Value *BuildVector(ArrayRef<llvm::Value*> Ops); llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E); llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E); - llvm::Value *EmitR600BuiltinExpr(unsigned BuiltinID, const CallExpr *E); + llvm::Value *EmitAMDGPUBuiltinExpr(unsigned BuiltinID, const CallExpr *E); llvm::Value *EmitSystemZBuiltinExpr(unsigned BuiltinID, const CallExpr *E); llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E); diff --git a/lib/CodeGen/CodeGenModule.cpp b/lib/CodeGen/CodeGenModule.cpp index 9496831ea8c8..2dd5414795e7 100644 --- a/lib/CodeGen/CodeGenModule.cpp +++ b/lib/CodeGen/CodeGenModule.cpp @@ -205,11 +205,9 @@ void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) { } void CodeGenModule::applyReplacements() { - for (ReplacementsTy::iterator I = Replacements.begin(), - E = Replacements.end(); - I != E; ++I) { - StringRef MangledName = I->first(); - llvm::Constant *Replacement = I->second; + for (auto &I : Replacements) { + StringRef MangledName = I.first(); + llvm::Constant *Replacement = I.second; llvm::GlobalValue *Entry = GetGlobalValue(MangledName); if (!Entry) continue; @@ -261,9 +259,7 @@ void CodeGenModule::checkAliases() { // and aliases during codegen. bool Error = false; DiagnosticsEngine &Diags = getDiags(); - for (std::vector<GlobalDecl>::iterator I = Aliases.begin(), - E = Aliases.end(); I != E; ++I) { - const GlobalDecl &GD = *I; + for (const GlobalDecl &GD : Aliases) { const auto *D = cast<ValueDecl>(GD.getDecl()); const AliasAttr *AA = D->getAttr<AliasAttr>(); StringRef MangledName = getMangledName(GD); @@ -310,9 +306,7 @@ void CodeGenModule::checkAliases() { if (!Error) return; - for (std::vector<GlobalDecl>::iterator I = Aliases.begin(), - E = Aliases.end(); I != E; ++I) { - const GlobalDecl &GD = *I; + for (const GlobalDecl &GD : Aliases) { StringRef MangledName = getMangledName(GD); llvm::GlobalValue *Entry = GetGlobalValue(MangledName); auto *Alias = cast<llvm::GlobalAlias>(Entry); @@ -637,15 +631,14 @@ void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { Int32Ty, llvm::PointerType::getUnqual(CtorFTy), VoidPtrTy, nullptr); // Construct the constructor and destructor arrays. - SmallVector<llvm::Constant*, 8> Ctors; - for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) { + SmallVector<llvm::Constant *, 8> Ctors; + for (const auto &I : Fns) { llvm::Constant *S[] = { - llvm::ConstantInt::get(Int32Ty, I->Priority, false), - llvm::ConstantExpr::getBitCast(I->Initializer, CtorPFTy), - (I->AssociatedData - ? llvm::ConstantExpr::getBitCast(I->AssociatedData, VoidPtrTy) - : llvm::Constant::getNullValue(VoidPtrTy)) - }; + llvm::ConstantInt::get(Int32Ty, I.Priority, false), + llvm::ConstantExpr::getBitCast(I.Initializer, CtorPFTy), + (I.AssociatedData + ? llvm::ConstantExpr::getBitCast(I.AssociatedData, VoidPtrTy) + : llvm::Constant::getNullValue(VoidPtrTy))}; Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S)); } @@ -1029,12 +1022,9 @@ void CodeGenModule::EmitModuleLinkOptions() { SmallVector<clang::Module *, 16> Stack; // Seed the stack with imported modules. - for (llvm::SetVector<clang::Module *>::iterator M = ImportedModules.begin(), - MEnd = ImportedModules.end(); - M != MEnd; ++M) { - if (Visited.insert(*M).second) - Stack.push_back(*M); - } + for (Module *M : ImportedModules) + if (Visited.insert(M).second) + Stack.push_back(M); // Find all of the modules to import, making a little effort to prune // non-leaf modules. @@ -1070,12 +1060,9 @@ void CodeGenModule::EmitModuleLinkOptions() { // to linker options inserted by things like #pragma comment(). SmallVector<llvm::Metadata *, 16> MetadataArgs; Visited.clear(); - for (llvm::SetVector<clang::Module *>::iterator M = LinkModules.begin(), - MEnd = LinkModules.end(); - M != MEnd; ++M) { - if (Visited.insert(*M).second) - addLinkOptionsPostorder(*this, *M, MetadataArgs, Visited); - } + for (Module *M : LinkModules) + if (Visited.insert(M).second) + addLinkOptionsPostorder(*this, M, MetadataArgs, Visited); std::reverse(MetadataArgs.begin(), MetadataArgs.end()); LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end()); @@ -1231,8 +1218,9 @@ bool CodeGenModule::isInSanitizerBlacklist(llvm::Function *Fn, bool CodeGenModule::isInSanitizerBlacklist(llvm::GlobalVariable *GV, SourceLocation Loc, QualType Ty, StringRef Category) const { - // For now globals can be blacklisted only in ASan. - if (!LangOpts.Sanitize.has(SanitizerKind::Address)) + // For now globals can be blacklisted only in ASan and KASan. + if (!LangOpts.Sanitize.hasOneOf( + SanitizerKind::Address | SanitizerKind::KernelAddress)) return false; const auto &SanitizerBL = getContext().getSanitizerBlacklist(); if (SanitizerBL.isBlacklistedGlobal(GV->getName(), Category)) @@ -3510,11 +3498,9 @@ static void EmitGlobalDeclMetadata(CodeGenModule &CGM, /// to such functions with an unmangled name from inline assembly within the /// same translation unit. void CodeGenModule::EmitStaticExternCAliases() { - for (StaticExternCMap::iterator I = StaticExternCValues.begin(), - E = StaticExternCValues.end(); - I != E; ++I) { - IdentifierInfo *Name = I->first; - llvm::GlobalValue *Val = I->second; + for (auto &I : StaticExternCValues) { + IdentifierInfo *Name = I.first; + llvm::GlobalValue *Val = I.second; if (Val && !getModule().getNamedValue(Name->getName())) addUsedGlobal(llvm::GlobalAlias::create(Name->getName(), Val)); } @@ -3674,3 +3660,17 @@ void CodeGenModule::EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) { CXXGlobalInits.push_back(InitFunction); } } + +llvm::MDTuple *CodeGenModule::CreateVTableBitSetEntry( + llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD) { + std::string OutName; + llvm::raw_string_ostream Out(OutName); + getCXXABI().getMangleContext().mangleCXXVTableBitSet(RD, Out); + + llvm::Metadata *BitsetOps[] = { + llvm::MDString::get(getLLVMContext(), Out.str()), + llvm::ConstantAsMetadata::get(VTable), + llvm::ConstantAsMetadata::get( + llvm::ConstantInt::get(Int64Ty, Offset.getQuantity()))}; + return llvm::MDTuple::get(getLLVMContext(), BitsetOps); +} diff --git a/lib/CodeGen/CodeGenModule.h b/lib/CodeGen/CodeGenModule.h index edde426e9230..8e671fa7878c 100644 --- a/lib/CodeGen/CodeGenModule.h +++ b/lib/CodeGen/CodeGenModule.h @@ -1115,6 +1115,11 @@ public: void EmitVTableBitSetEntries(llvm::GlobalVariable *VTable, const VTableLayout &VTLayout); + /// Create a bitset entry for the given vtable. + llvm::MDTuple *CreateVTableBitSetEntry(llvm::GlobalVariable *VTable, + CharUnits Offset, + const CXXRecordDecl *RD); + /// \breif Get the declaration of std::terminate for the platform. llvm::Constant *getTerminateFn(); diff --git a/lib/CodeGen/CoverageMappingGen.cpp b/lib/CodeGen/CoverageMappingGen.cpp index 024a45dba2b7..9ad5d14edfdc 100644 --- a/lib/CodeGen/CoverageMappingGen.cpp +++ b/lib/CodeGen/CoverageMappingGen.cpp @@ -806,6 +806,9 @@ struct CounterCoverageMappingBuilder void VisitIfStmt(const IfStmt *S) { extendRegion(S); + // Extend into the condition before we propagate through it below - this is + // needed to handle macros that generate the "if" but not the condition. + extendRegion(S->getCond()); Counter ParentCount = getRegion().getCounter(); Counter ThenCount = getRegionCounter(S); diff --git a/lib/CodeGen/ItaniumCXXABI.cpp b/lib/CodeGen/ItaniumCXXABI.cpp index 0a1a4ceea3ef..3f5ad5db01b5 100644 --- a/lib/CodeGen/ItaniumCXXABI.cpp +++ b/lib/CodeGen/ItaniumCXXABI.cpp @@ -204,7 +204,8 @@ public: llvm::Value *getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This, - llvm::Type *Ty) override; + llvm::Type *Ty, + SourceLocation Loc) override; llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, @@ -1439,13 +1440,15 @@ llvm::GlobalVariable *ItaniumCXXABI::getAddrOfVTable(const CXXRecordDecl *RD, llvm::Value *ItaniumCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This, - llvm::Type *Ty) { + llvm::Type *Ty, + SourceLocation Loc) { GD = GD.getCanonicalDecl(); Ty = Ty->getPointerTo()->getPointerTo(); llvm::Value *VTable = CGF.GetVTablePtr(This, Ty); if (CGF.SanOpts.has(SanitizerKind::CFIVCall)) - CGF.EmitVTablePtrCheckForCall(cast<CXXMethodDecl>(GD.getDecl()), VTable); + CGF.EmitVTablePtrCheckForCall(cast<CXXMethodDecl>(GD.getDecl()), VTable, + CodeGenFunction::CFITCK_VCall, Loc); uint64_t VTableIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(GD); llvm::Value *VFuncPtr = @@ -1463,7 +1466,8 @@ llvm::Value *ItaniumCXXABI::EmitVirtualDestructorCall( Dtor, getFromDtorType(DtorType)); llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo); llvm::Value *Callee = - getVirtualFunctionPointer(CGF, GlobalDecl(Dtor, DtorType), This, Ty); + getVirtualFunctionPointer(CGF, GlobalDecl(Dtor, DtorType), This, Ty, + CE ? CE->getLocStart() : SourceLocation()); CGF.EmitCXXMemberOrOperatorCall(Dtor, Callee, ReturnValueSlot(), This, /*ImplicitParam=*/nullptr, QualType(), CE); diff --git a/lib/CodeGen/MicrosoftCXXABI.cpp b/lib/CodeGen/MicrosoftCXXABI.cpp index de30883c545f..679516bfa89a 100644 --- a/lib/CodeGen/MicrosoftCXXABI.cpp +++ b/lib/CodeGen/MicrosoftCXXABI.cpp @@ -205,6 +205,9 @@ public: CXXDtorType Type, bool ForVirtualBase, bool Delegating, llvm::Value *This) override; + void emitVTableBitSetEntries(VPtrInfo *Info, const CXXRecordDecl *RD, + llvm::GlobalVariable *VTable); + void emitVTableDefinitions(CodeGenVTables &CGVT, const CXXRecordDecl *RD) override; @@ -221,8 +224,8 @@ public: CharUnits VPtrOffset) override; llvm::Value *getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD, - llvm::Value *This, - llvm::Type *Ty) override; + llvm::Value *This, llvm::Type *Ty, + SourceLocation Loc) override; llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, @@ -1401,6 +1404,58 @@ void MicrosoftCXXABI::EmitDestructorCall(CodeGenFunction &CGF, getFromDtorType(Type)); } +void MicrosoftCXXABI::emitVTableBitSetEntries(VPtrInfo *Info, + const CXXRecordDecl *RD, + llvm::GlobalVariable *VTable) { + if (!getContext().getLangOpts().Sanitize.has(SanitizerKind::CFIVCall) && + !getContext().getLangOpts().Sanitize.has(SanitizerKind::CFINVCall) && + !getContext().getLangOpts().Sanitize.has(SanitizerKind::CFIDerivedCast) && + !getContext().getLangOpts().Sanitize.has(SanitizerKind::CFIUnrelatedCast)) + return; + + llvm::NamedMDNode *BitsetsMD = + CGM.getModule().getOrInsertNamedMetadata("llvm.bitsets"); + CharUnits PointerWidth = getContext().toCharUnitsFromBits( + getContext().getTargetInfo().getPointerWidth(0)); + + // FIXME: Add blacklisting scheme. + + if (Info->PathToBaseWithVPtr.empty()) { + BitsetsMD->addOperand( + CGM.CreateVTableBitSetEntry(VTable, PointerWidth, RD)); + return; + } + + // Add a bitset entry for the least derived base belonging to this vftable. + BitsetsMD->addOperand(CGM.CreateVTableBitSetEntry( + VTable, PointerWidth, Info->PathToBaseWithVPtr.back())); + + // Add a bitset entry for each derived class that is laid out at the same + // offset as the least derived base. + for (unsigned I = Info->PathToBaseWithVPtr.size() - 1; I != 0; --I) { + const CXXRecordDecl *DerivedRD = Info->PathToBaseWithVPtr[I - 1]; + const CXXRecordDecl *BaseRD = Info->PathToBaseWithVPtr[I]; + + const ASTRecordLayout &Layout = + getContext().getASTRecordLayout(DerivedRD); + CharUnits Offset; + auto VBI = Layout.getVBaseOffsetsMap().find(BaseRD); + if (VBI == Layout.getVBaseOffsetsMap().end()) + Offset = Layout.getBaseClassOffset(BaseRD); + else + Offset = VBI->second.VBaseOffset; + if (!Offset.isZero()) + return; + BitsetsMD->addOperand( + CGM.CreateVTableBitSetEntry(VTable, PointerWidth, DerivedRD)); + } + + // Finally do the same for the most derived class. + if (Info->FullOffsetInMDC.isZero()) + BitsetsMD->addOperand( + CGM.CreateVTableBitSetEntry(VTable, PointerWidth, RD)); +} + void MicrosoftCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT, const CXXRecordDecl *RD) { MicrosoftVTableContext &VFTContext = CGM.getMicrosoftVTableContext(); @@ -1423,6 +1478,8 @@ void MicrosoftCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT, VTLayout.getNumVTableThunks(), RTTI); VTable->setInitializer(Init); + + emitVTableBitSetEntries(Info, RD, VTable); } } @@ -1585,10 +1642,54 @@ llvm::GlobalVariable *MicrosoftCXXABI::getAddrOfVTable(const CXXRecordDecl *RD, return VTable; } +// Compute the identity of the most derived class whose virtual table is located +// at the given offset into RD. +static const CXXRecordDecl *getClassAtVTableLocation(ASTContext &Ctx, + const CXXRecordDecl *RD, + CharUnits Offset) { + if (Offset.isZero()) + return RD; + + const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD); + const CXXRecordDecl *MaxBase = nullptr; + CharUnits MaxBaseOffset; + for (auto &&B : RD->bases()) { + const CXXRecordDecl *Base = B.getType()->getAsCXXRecordDecl(); + CharUnits BaseOffset = Layout.getBaseClassOffset(Base); + if (BaseOffset <= Offset && BaseOffset > MaxBaseOffset) { + MaxBase = Base; + MaxBaseOffset = BaseOffset; + } + } + for (auto &&B : RD->vbases()) { + const CXXRecordDecl *Base = B.getType()->getAsCXXRecordDecl(); + CharUnits BaseOffset = Layout.getVBaseClassOffset(Base); + if (BaseOffset <= Offset && BaseOffset > MaxBaseOffset) { + MaxBase = Base; + MaxBaseOffset = BaseOffset; + } + } + assert(MaxBase); + return getClassAtVTableLocation(Ctx, MaxBase, Offset - MaxBaseOffset); +} + +// Compute the identity of the most derived class whose virtual table is located +// at the MethodVFTableLocation ML. +static const CXXRecordDecl * +getClassAtVTableLocation(ASTContext &Ctx, GlobalDecl GD, + MicrosoftVTableContext::MethodVFTableLocation &ML) { + const CXXRecordDecl *RD = ML.VBase; + if (!RD) + RD = cast<CXXMethodDecl>(GD.getDecl())->getParent(); + + return getClassAtVTableLocation(Ctx, RD, ML.VFPtrOffset); +} + llvm::Value *MicrosoftCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This, - llvm::Type *Ty) { + llvm::Type *Ty, + SourceLocation Loc) { GD = GD.getCanonicalDecl(); CGBuilderTy &Builder = CGF.Builder; @@ -1599,6 +1700,10 @@ llvm::Value *MicrosoftCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF, MicrosoftVTableContext::MethodVFTableLocation ML = CGM.getMicrosoftVTableContext().getMethodVFTableLocation(GD); + if (CGF.SanOpts.has(SanitizerKind::CFIVCall)) + CGF.EmitVTablePtrCheck(getClassAtVTableLocation(getContext(), GD, ML), + VTable, CodeGenFunction::CFITCK_VCall, Loc); + llvm::Value *VFuncPtr = Builder.CreateConstInBoundsGEP1_64(VTable, ML.Index, "vfn"); return Builder.CreateLoad(VFuncPtr); @@ -1616,7 +1721,8 @@ llvm::Value *MicrosoftCXXABI::EmitVirtualDestructorCall( const CGFunctionInfo *FInfo = &CGM.getTypes().arrangeCXXStructorDeclaration( Dtor, StructorType::Deleting); llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo); - llvm::Value *Callee = getVirtualFunctionPointer(CGF, GD, This, Ty); + llvm::Value *Callee = getVirtualFunctionPointer( + CGF, GD, This, Ty, CE ? CE->getLocStart() : SourceLocation()); ASTContext &Context = getContext(); llvm::Value *ImplicitParam = llvm::ConstantInt::get( @@ -2351,7 +2457,7 @@ MicrosoftCXXABI::EmitFullMemberPointer(llvm::Constant *FirstField, if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance)) { CharUnits Offs = CharUnits::Zero(); - if (RD->getNumVBases()) + if (VBTableIndex && RD->getNumVBases()) Offs = getContext().getASTRecordLayout(RD).getVBPtrOffset(); fields.push_back(llvm::ConstantInt::get(CGM.IntTy, Offs.getQuantity())); } @@ -2423,25 +2529,15 @@ MicrosoftCXXABI::BuildMemberPointer(const CXXRecordDecl *RD, FirstField = CGM.GetAddrOfFunction(MD, Ty); FirstField = llvm::ConstantExpr::getBitCast(FirstField, CGM.VoidPtrTy); } else { - if (!CGM.getTypes().isFuncTypeConvertible( - MD->getType()->castAs<FunctionType>())) { - CGM.ErrorUnsupported(MD, "pointer to virtual member function with " - "incomplete return or parameter type"); - FirstField = llvm::Constant::getNullValue(CGM.VoidPtrTy); - } else if (FPT->getCallConv() == CC_X86FastCall) { - CGM.ErrorUnsupported(MD, "pointer to fastcall virtual member function"); - FirstField = llvm::Constant::getNullValue(CGM.VoidPtrTy); - } else { - auto &VTableContext = CGM.getMicrosoftVTableContext(); - MicrosoftVTableContext::MethodVFTableLocation ML = - VTableContext.getMethodVFTableLocation(MD); - llvm::Function *Thunk = EmitVirtualMemPtrThunk(MD, ML); - FirstField = llvm::ConstantExpr::getBitCast(Thunk, CGM.VoidPtrTy); - // Include the vfptr adjustment if the method is in a non-primary vftable. - NonVirtualBaseAdjustment += ML.VFPtrOffset; - if (ML.VBase) - VBTableIndex = VTableContext.getVBTableIndex(RD, ML.VBase) * 4; - } + auto &VTableContext = CGM.getMicrosoftVTableContext(); + MicrosoftVTableContext::MethodVFTableLocation ML = + VTableContext.getMethodVFTableLocation(MD); + llvm::Function *Thunk = EmitVirtualMemPtrThunk(MD, ML); + FirstField = llvm::ConstantExpr::getBitCast(Thunk, CGM.VoidPtrTy); + // Include the vfptr adjustment if the method is in a non-primary vftable. + NonVirtualBaseAdjustment += ML.VFPtrOffset; + if (ML.VBase) + VBTableIndex = VTableContext.getVBTableIndex(RD, ML.VBase) * 4; } // The rest of the fields are common with data member pointers. diff --git a/lib/CodeGen/SanitizerMetadata.cpp b/lib/CodeGen/SanitizerMetadata.cpp index 7c38b2807e95..2a338bac4b41 100644 --- a/lib/CodeGen/SanitizerMetadata.cpp +++ b/lib/CodeGen/SanitizerMetadata.cpp @@ -25,7 +25,8 @@ void SanitizerMetadata::reportGlobalToASan(llvm::GlobalVariable *GV, SourceLocation Loc, StringRef Name, QualType Ty, bool IsDynInit, bool IsBlacklisted) { - if (!CGM.getLangOpts().Sanitize.has(SanitizerKind::Address)) + if (!CGM.getLangOpts().Sanitize.hasOneOf(SanitizerKind::Address | + SanitizerKind::KernelAddress)) return; IsDynInit &= !CGM.isInSanitizerBlacklist(GV, Loc, Ty, "init"); IsBlacklisted |= CGM.isInSanitizerBlacklist(GV, Loc, Ty); @@ -56,7 +57,8 @@ void SanitizerMetadata::reportGlobalToASan(llvm::GlobalVariable *GV, void SanitizerMetadata::reportGlobalToASan(llvm::GlobalVariable *GV, const VarDecl &D, bool IsDynInit) { - if (!CGM.getLangOpts().Sanitize.has(SanitizerKind::Address)) + if (!CGM.getLangOpts().Sanitize.hasOneOf(SanitizerKind::Address | + SanitizerKind::KernelAddress)) return; std::string QualName; llvm::raw_string_ostream OS(QualName); @@ -67,7 +69,8 @@ void SanitizerMetadata::reportGlobalToASan(llvm::GlobalVariable *GV, void SanitizerMetadata::disableSanitizerForGlobal(llvm::GlobalVariable *GV) { // For now, just make sure the global is not modified by the ASan // instrumentation. - if (CGM.getLangOpts().Sanitize.has(SanitizerKind::Address)) + if (CGM.getLangOpts().Sanitize.hasOneOf(SanitizerKind::Address | + SanitizerKind::KernelAddress)) reportGlobalToASan(GV, SourceLocation(), "", QualType(), false, true); } diff --git a/lib/Driver/Driver.cpp b/lib/Driver/Driver.cpp index 8cca1de0fb2b..0f3ebef2cf2f 100644 --- a/lib/Driver/Driver.cpp +++ b/lib/Driver/Driver.cpp @@ -277,7 +277,8 @@ DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const { // Add a default value of -mlinker-version=, if one was given and the user // didn't specify one. #if defined(HOST_LINK_VERSION) - if (!Args.hasArg(options::OPT_mlinker_version_EQ)) { + if (!Args.hasArg(options::OPT_mlinker_version_EQ) && + strlen(HOST_LINK_VERSION) > 0) { DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ), HOST_LINK_VERSION); DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim(); @@ -814,9 +815,12 @@ bool Driver::HandleImmediateArgs(const Compilation &C) { return true; } +// Display an action graph human-readably. Action A is the "sink" node +// and latest-occuring action. Traversal is in pre-order, visiting the +// inputs to each action before printing the action itself. static unsigned PrintActions1(const Compilation &C, Action *A, std::map<Action*, unsigned> &Ids) { - if (Ids.count(A)) + if (Ids.count(A)) // A was already visited. return Ids[A]; std::string str; @@ -847,6 +851,8 @@ static unsigned PrintActions1(const Compilation &C, Action *A, return Id; } +// Print the action graphs in a compilation C. +// For example "clang -c file1.c file2.c" is composed of two subgraphs. void Driver::PrintActions(const Compilation &C) const { std::map<Action*, unsigned> Ids; for (ActionList::const_iterator it = C.getActions().begin(), @@ -1356,7 +1362,7 @@ Driver::ConstructPhaseAction(const ToolChain &TC, const ArgList &Args, types::TY_LLVM_BC); } case phases::Backend: { - if (IsUsingLTO(TC, Args)) { + if (IsUsingLTO(Args)) { types::ID Output = Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC; return llvm::make_unique<BackendJobAction>(std::move(Input), Output); @@ -1377,14 +1383,8 @@ Driver::ConstructPhaseAction(const ToolChain &TC, const ArgList &Args, llvm_unreachable("invalid phase in ConstructPhaseAction"); } -bool Driver::IsUsingLTO(const ToolChain &TC, const ArgList &Args) const { - if (TC.getSanitizerArgs().needsLTO()) - return true; - - if (Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false)) - return true; - - return false; +bool Driver::IsUsingLTO(const ArgList &Args) const { + return Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false); } void Driver::BuildJobs(Compilation &C) const { @@ -1563,8 +1563,9 @@ void Driver::BuildJobsForAction(Compilation &C, if (Input.getOption().matches(options::OPT_INPUT)) { const char *Name = Input.getValue(); Result = InputInfo(Name, A->getType(), Name); - } else + } else { Result = InputInfo(&Input, A->getType(), ""); + } return; } @@ -1738,7 +1739,7 @@ const char *Driver::GetNamedOutputPath(Compilation &C, // Determine what the derived output name should be. const char *NamedOutput; - if ((JA.getType() == types::TY_Object || JA.getType() == types::TY_LTO_BC) && + if (JA.getType() == types::TY_Object && C.getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) { // The /Fo or /o flag decides the object filename. StringRef Val = C.getArgs().getLastArg(options::OPT__SLASH_Fo, @@ -2099,6 +2100,8 @@ const ToolChain &Driver::getToolChain(const ArgList &Args, TC = new toolchains::Hexagon_TC(*this, Target, Args); else if (Target.getArch() == llvm::Triple::xcore) TC = new toolchains::XCore(*this, Target, Args); + else if (Target.getArch() == llvm::Triple::shave) + TC = new toolchains::SHAVEToolChain(*this, Target, Args); else if (Target.isOSBinFormatELF()) TC = new toolchains::Generic_ELF(*this, Target, Args); else if (Target.isOSBinFormatMachO()) @@ -2112,13 +2115,12 @@ const ToolChain &Driver::getToolChain(const ArgList &Args, } bool Driver::ShouldUseClangCompiler(const JobAction &JA) const { - // Check if user requested no clang, or clang doesn't understand this type (we - // only handle single inputs for now). + // Say "no" if there is not exactly one input of a type clang understands. if (JA.size() != 1 || !types::isAcceptedByClang((*JA.begin())->getType())) return false; - // Otherwise make sure this is an action clang understands. + // And say "no" if this is not a kind of action clang understands. if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA)) return false; diff --git a/lib/Driver/MSVCToolChain.cpp b/lib/Driver/MSVCToolChain.cpp index d824fe4c1083..72161213db05 100644 --- a/lib/Driver/MSVCToolChain.cpp +++ b/lib/Driver/MSVCToolChain.cpp @@ -522,3 +522,12 @@ MSVCToolChain::ComputeEffectiveClangTriple(const ArgList &Args, } return Triple.getTriple(); } + +SanitizerMask MSVCToolChain::getSupportedSanitizers() const { + SanitizerMask Res = ToolChain::getSupportedSanitizers(); + Res |= SanitizerKind::Address; + // CFI checks are not implemented for MSVC ABI for now. + Res &= ~SanitizerKind::CFI; + Res &= ~SanitizerKind::CFICastStrict; + return Res; +} diff --git a/lib/Driver/SanitizerArgs.cpp b/lib/Driver/SanitizerArgs.cpp index 72530b442f52..14c37025eb39 100644 --- a/lib/Driver/SanitizerArgs.cpp +++ b/lib/Driver/SanitizerArgs.cpp @@ -25,7 +25,7 @@ using namespace clang::driver; using namespace llvm::opt; enum : SanitizerMask { - NeedsUbsanRt = Undefined | Integer, + NeedsUbsanRt = Undefined | Integer | CFI, NotAllowedWithTrap = Vptr, RequiresPIE = Memory | DataFlow, NeedsUnwindTables = Address | Thread | Memory | DataFlow, @@ -34,6 +34,9 @@ enum : SanitizerMask { Unrecoverable = Address | Unreachable | Return, LegacyFsanitizeRecoverMask = Undefined | Integer, NeedsLTO = CFI, + TrappingSupported = + (Undefined & ~Vptr) | UnsignedIntegerOverflow | LocalBounds | CFI, + TrappingDefault = CFI, }; enum CoverageFeature { @@ -74,27 +77,6 @@ static std::string describeSanitizeArg(const llvm::opt::Arg *A, /// Sanitizers set. static std::string toString(const clang::SanitizerSet &Sanitizers); -static SanitizerMask getToolchainUnsupportedKinds(const ToolChain &TC) { - bool IsFreeBSD = TC.getTriple().getOS() == llvm::Triple::FreeBSD; - bool IsLinux = TC.getTriple().getOS() == llvm::Triple::Linux; - bool IsX86 = TC.getTriple().getArch() == llvm::Triple::x86; - bool IsX86_64 = TC.getTriple().getArch() == llvm::Triple::x86_64; - bool IsMIPS64 = TC.getTriple().getArch() == llvm::Triple::mips64 || - TC.getTriple().getArch() == llvm::Triple::mips64el; - - SanitizerMask Unsupported = 0; - if (!(IsLinux && (IsX86_64 || IsMIPS64))) { - Unsupported |= Memory | DataFlow; - } - if (!((IsLinux || IsFreeBSD) && (IsX86_64 || IsMIPS64))) { - Unsupported |= Thread; - } - if (!(IsLinux && (IsX86 || IsX86_64))) { - Unsupported |= Function; - } - return Unsupported; -} - static bool getDefaultBlacklist(const Driver &D, SanitizerMask Kinds, std::string &BLPath) { const char *BlacklistFile = nullptr; @@ -116,8 +98,62 @@ static bool getDefaultBlacklist(const Driver &D, SanitizerMask Kinds, return false; } +/// Sets group bits for every group that has at least one representative already +/// enabled in \p Kinds. +static SanitizerMask setGroupBits(SanitizerMask Kinds) { +#define SANITIZER(NAME, ID) +#define SANITIZER_GROUP(NAME, ID, ALIAS) \ + if (Kinds & SanitizerKind::ID) \ + Kinds |= SanitizerKind::ID##Group; +#include "clang/Basic/Sanitizers.def" + return Kinds; +} + +static SanitizerMask parseSanitizeTrapArgs(const Driver &D, + const llvm::opt::ArgList &Args) { + SanitizerMask TrapRemove = 0; // During the loop below, the accumulated set of + // sanitizers disabled by the current sanitizer + // argument or any argument after it. + SanitizerMask TrappingKinds = 0; + SanitizerMask TrappingSupportedWithGroups = setGroupBits(TrappingSupported); + + for (ArgList::const_reverse_iterator I = Args.rbegin(), E = Args.rend(); + I != E; ++I) { + const auto *Arg = *I; + if (Arg->getOption().matches(options::OPT_fsanitize_trap_EQ)) { + Arg->claim(); + SanitizerMask Add = parseArgValues(D, Arg, true); + Add &= ~TrapRemove; + if (SanitizerMask InvalidValues = Add & ~TrappingSupportedWithGroups) { + SanitizerSet S; + S.Mask = InvalidValues; + D.Diag(diag::err_drv_unsupported_option_argument) << "-fsanitize-trap" + << toString(S); + } + TrappingKinds |= expandSanitizerGroups(Add) & ~TrapRemove; + } else if (Arg->getOption().matches(options::OPT_fno_sanitize_trap_EQ)) { + Arg->claim(); + TrapRemove |= expandSanitizerGroups(parseArgValues(D, Arg, true)); + } else if (Arg->getOption().matches( + options::OPT_fsanitize_undefined_trap_on_error)) { + Arg->claim(); + TrappingKinds |= + expandSanitizerGroups(UndefinedGroup & ~TrapRemove) & ~TrapRemove; + } else if (Arg->getOption().matches( + options::OPT_fno_sanitize_undefined_trap_on_error)) { + Arg->claim(); + TrapRemove |= expandSanitizerGroups(UndefinedGroup); + } + } + + // Apply default trapping behavior. + TrappingKinds |= TrappingDefault & ~TrapRemove; + + return TrappingKinds; +} + bool SanitizerArgs::needsUbsanRt() const { - return !UbsanTrapOnError && (Sanitizers.Mask & NeedsUbsanRt) && + return (Sanitizers.Mask & NeedsUbsanRt & ~TrapSanitizers.Mask) && !Sanitizers.has(Address) && !Sanitizers.has(Memory) && !Sanitizers.has(Thread); @@ -131,19 +167,15 @@ bool SanitizerArgs::needsUnwindTables() const { return Sanitizers.Mask & NeedsUnwindTables; } -bool SanitizerArgs::needsLTO() const { - return Sanitizers.Mask & NeedsLTO; -} - void SanitizerArgs::clear() { Sanitizers.clear(); RecoverableSanitizers.clear(); + TrapSanitizers.clear(); BlacklistFiles.clear(); CoverageFeatures = 0; MsanTrackOrigins = 0; AsanFieldPadding = 0; AsanZeroBaseShadow = false; - UbsanTrapOnError = false; AsanSharedRuntime = false; LinkCXXRuntimes = false; } @@ -162,10 +194,13 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, SanitizerMask DiagnosedKinds = 0; // All Kinds we have diagnosed up to now. // Used to deduplicate diagnostics. SanitizerMask Kinds = 0; - SanitizerMask NotSupported = getToolchainUnsupportedKinds(TC); + SanitizerMask Supported = setGroupBits(TC.getSupportedSanitizers()); ToolChain::RTTIMode RTTIMode = TC.getRTTIMode(); const Driver &D = TC.getDriver(); + SanitizerMask TrappingKinds = parseSanitizeTrapArgs(D, Args); + SanitizerMask InvalidTrappingKinds = TrappingKinds & NotAllowedWithTrap; + for (ArgList::const_reverse_iterator I = Args.rbegin(), E = Args.rend(); I != E; ++I) { const auto *Arg = *I; @@ -180,14 +215,20 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, // sanitizers in Add are those which have been explicitly enabled. // Diagnose them. if (SanitizerMask KindsToDiagnose = - Add & NotSupported & ~DiagnosedKinds) { - // Only diagnose the new kinds. + Add & InvalidTrappingKinds & ~DiagnosedKinds) { + std::string Desc = describeSanitizeArg(*I, KindsToDiagnose); + D.Diag(diag::err_drv_argument_not_allowed_with) + << Desc << "-fsanitize-trap=undefined"; + DiagnosedKinds |= KindsToDiagnose; + } + Add &= ~InvalidTrappingKinds; + if (SanitizerMask KindsToDiagnose = Add & ~Supported & ~DiagnosedKinds) { std::string Desc = describeSanitizeArg(*I, KindsToDiagnose); D.Diag(diag::err_drv_unsupported_opt_for_target) << Desc << TC.getTriple().str(); DiagnosedKinds |= KindsToDiagnose; } - Add &= ~NotSupported; + Add &= Supported; // Test for -fno-rtti + explicit -fsanitizer=vptr before expanding groups // so we don't error out if -fno-rtti and -fsanitize=undefined were @@ -216,7 +257,8 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, Add &= ~AllRemove; // Silently discard any unsupported sanitizers implicitly enabled through // group expansion. - Add &= ~NotSupported; + Add &= ~InvalidTrappingKinds; + Add &= Supported; Kinds |= Add; } else if (Arg->getOption().matches(options::OPT_fno_sanitize_EQ)) { @@ -234,22 +276,20 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, Kinds &= ~Vptr; } - // Warn about undefined sanitizer options that require runtime support. - UbsanTrapOnError = - Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error, - options::OPT_fno_sanitize_undefined_trap_on_error, false); - if (UbsanTrapOnError && (Kinds & NotAllowedWithTrap)) { - D.Diag(clang::diag::err_drv_argument_not_allowed_with) - << lastArgumentForMask(D, Args, NotAllowedWithTrap) - << "-fsanitize-undefined-trap-on-error"; - Kinds &= ~NotAllowedWithTrap; + // Check that LTO is enabled if we need it. + if ((Kinds & NeedsLTO) && !D.IsUsingLTO(Args)) { + D.Diag(diag::err_drv_argument_only_allowed_with) + << lastArgumentForMask(D, Args, Kinds & NeedsLTO) << "-flto"; } // Warn about incompatible groups of sanitizers. std::pair<SanitizerMask, SanitizerMask> IncompatibleGroups[] = { std::make_pair(Address, Thread), std::make_pair(Address, Memory), std::make_pair(Thread, Memory), std::make_pair(Leak, Thread), - std::make_pair(Leak, Memory)}; + std::make_pair(Leak, Memory), std::make_pair(KernelAddress, Address), + std::make_pair(KernelAddress, Leak), + std::make_pair(KernelAddress, Thread), + std::make_pair(KernelAddress, Memory)}; for (auto G : IncompatibleGroups) { SanitizerMask Group = G.first; if (Kinds & Group) { @@ -305,6 +345,8 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, RecoverableKinds &= Kinds; RecoverableKinds &= ~Unrecoverable; + TrappingKinds &= Kinds; + // Setup blacklist files. // Add default blacklist from resource directory. { @@ -460,6 +502,7 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, // Finally, initialize the set of available and recoverable sanitizers. Sanitizers.Mask |= Kinds; RecoverableSanitizers.Mask |= RecoverableKinds; + TrapSanitizers.Mask |= TrappingKinds; } static std::string toString(const clang::SanitizerSet &Sanitizers) { @@ -484,8 +527,9 @@ void SanitizerArgs::addArgs(const llvm::opt::ArgList &Args, CmdArgs.push_back(Args.MakeArgString("-fsanitize-recover=" + toString(RecoverableSanitizers))); - if (UbsanTrapOnError) - CmdArgs.push_back("-fsanitize-undefined-trap-on-error"); + if (!TrapSanitizers.empty()) + CmdArgs.push_back( + Args.MakeArgString("-fsanitize-trap=" + toString(TrapSanitizers))); for (const auto &BLPath : BlacklistFiles) { SmallString<64> BlacklistOpt("-fsanitize-blacklist="); @@ -528,7 +572,9 @@ SanitizerMask parseArgValues(const Driver &D, const llvm::opt::Arg *A, assert((A->getOption().matches(options::OPT_fsanitize_EQ) || A->getOption().matches(options::OPT_fno_sanitize_EQ) || A->getOption().matches(options::OPT_fsanitize_recover_EQ) || - A->getOption().matches(options::OPT_fno_sanitize_recover_EQ)) && + A->getOption().matches(options::OPT_fno_sanitize_recover_EQ) || + A->getOption().matches(options::OPT_fsanitize_trap_EQ) || + A->getOption().matches(options::OPT_fno_sanitize_trap_EQ)) && "Invalid argument in parseArgValues!"); SanitizerMask Kinds = 0; for (int i = 0, n = A->getNumValues(); i != n; ++i) { diff --git a/lib/Driver/ToolChain.cpp b/lib/Driver/ToolChain.cpp index 82eb85411510..da020a2b8c9d 100644 --- a/lib/Driver/ToolChain.cpp +++ b/lib/Driver/ToolChain.cpp @@ -481,3 +481,12 @@ bool ToolChain::AddFastMathRuntimeIfAvailable(const ArgList &Args, CmdArgs.push_back(Args.MakeArgString(Path)); return true; } + +SanitizerMask ToolChain::getSupportedSanitizers() const { + // Return sanitizers which don't require runtime support and are not + // platform or architecture-dependent. + using namespace SanitizerKind; + return (Undefined & ~Vptr & ~Function) | CFI | CFICastStrict | + UnsignedIntegerOverflow | LocalBounds; +} + diff --git a/lib/Driver/ToolChains.cpp b/lib/Driver/ToolChains.cpp index 115a16f7663d..987e063039ca 100644 --- a/lib/Driver/ToolChains.cpp +++ b/lib/Driver/ToolChains.cpp @@ -42,10 +42,6 @@ using namespace llvm::opt; MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) : ToolChain(D, Triple, Args) { - getProgramPaths().push_back(getDriver().getInstalledDir()); - if (getDriver().getInstalledDir() != getDriver().Dir) - getProgramPaths().push_back(getDriver().Dir); - // We expect 'as', 'ld', etc. to be adjacent to our install dir. getProgramPaths().push_back(getDriver().getInstalledDir()); if (getDriver().getInstalledDir() != getDriver().Dir) @@ -53,28 +49,8 @@ MachO::MachO(const Driver &D, const llvm::Triple &Triple, } /// Darwin - Darwin tool chain for i386 and x86_64. -Darwin::Darwin(const Driver & D, const llvm::Triple & Triple, - const ArgList & Args) - : MachO(D, Triple, Args), TargetInitialized(false) { - // Compute the initial Darwin version from the triple - unsigned Major, Minor, Micro; - if (!Triple.getMacOSXVersion(Major, Minor, Micro)) - getDriver().Diag(diag::err_drv_invalid_darwin_version) << - Triple.getOSName(); - llvm::raw_string_ostream(MacosxVersionMin) - << Major << '.' << Minor << '.' << Micro; - - // FIXME: DarwinVersion is only used to find GCC's libexec directory. - // It should be removed when we stop supporting that. - DarwinVersion[0] = Minor + 4; - DarwinVersion[1] = Micro; - DarwinVersion[2] = 0; - - // Compute the initial iOS version from the triple - Triple.getiOSVersion(Major, Minor, Micro); - llvm::raw_string_ostream(iOSVersionMin) - << Major << '.' << Minor << '.' << Micro; -} +Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) + : MachO(D, Triple, Args), TargetInitialized(false) {} types::ID MachO::LookupTypeForExtension(const char *Ext) const { types::ID Ty = types::lookupTypeForExtension(Ext); @@ -403,26 +379,10 @@ void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args, const SanitizerArgs &Sanitize = getSanitizerArgs(); - - if (Sanitize.needsAsanRt()) { - if (!isTargetMacOS() && !isTargetIOSSimulator()) { - // FIXME: Move this check to SanitizerArgs::filterUnsupportedKinds. - getDriver().Diag(diag::err_drv_clang_unsupported_per_platform) - << "-fsanitize=address"; - } else { - AddLinkSanitizerLibArgs(Args, CmdArgs, "asan"); - } - } - - if (Sanitize.needsUbsanRt()) { - if (!isTargetMacOS() && !isTargetIOSSimulator()) { - // FIXME: Move this check to SanitizerArgs::filterUnsupportedKinds. - getDriver().Diag(diag::err_drv_clang_unsupported_per_platform) - << "-fsanitize=undefined"; - } else { - AddLinkSanitizerLibArgs(Args, CmdArgs, "ubsan"); - } - } + if (Sanitize.needsAsanRt()) + AddLinkSanitizerLibArgs(Args, CmdArgs, "asan"); + if (Sanitize.needsUbsanRt()) + AddLinkSanitizerLibArgs(Args, CmdArgs, "ubsan"); // Otherwise link libSystem, then the dynamic runtime library, and finally any // target specific static runtime library. @@ -499,8 +459,8 @@ void Darwin::AddDeploymentTarget(DerivedArgList &Args) const { } else if (!OSXVersion && !iOSVersion) { // If no deployment target was specified on the command line, check for // environment defines. - StringRef OSXTarget; - StringRef iOSTarget; + std::string OSXTarget; + std::string iOSTarget; if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET")) OSXTarget = env; if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET")) @@ -519,13 +479,26 @@ void Darwin::AddDeploymentTarget(DerivedArgList &Args) const { } } - // If no OSX or iOS target has been specified and we're compiling for armv7, - // go ahead as assume we're targeting iOS. - StringRef MachOArchName = getMachOArchName(Args); - if (OSXTarget.empty() && iOSTarget.empty() && - (MachOArchName == "armv7" || MachOArchName == "armv7s" || - MachOArchName == "arm64")) - iOSTarget = iOSVersionMin; + // If no OSX or iOS target has been specified, try to guess platform + // from arch name and compute the version from the triple. + if (OSXTarget.empty() && iOSTarget.empty()) { + StringRef MachOArchName = getMachOArchName(Args); + unsigned Major, Minor, Micro; + if (MachOArchName == "armv7" || MachOArchName == "armv7s" || + MachOArchName == "arm64") { + getTriple().getiOSVersion(Major, Minor, Micro); + llvm::raw_string_ostream(iOSTarget) << Major << '.' << Minor << '.' + << Micro; + } else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" && + MachOArchName != "armv7em") { + if (!getTriple().getMacOSXVersion(Major, Minor, Micro)) { + getDriver().Diag(diag::err_drv_invalid_darwin_version) + << getTriple().getOSName(); + } + llvm::raw_string_ostream(OSXTarget) << Major << '.' << Minor << '.' + << Micro; + } + } // Allow conflicts among OSX and iOS for historical reasons, but choose the // default platform. @@ -546,12 +519,6 @@ void Darwin::AddDeploymentTarget(DerivedArgList &Args) const { const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ); iOSVersion = Args.MakeJoinedArg(nullptr, O, iOSTarget); Args.append(iOSVersion); - } else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" && - MachOArchName != "armv7em") { - // Otherwise, assume we are targeting OS X. - const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ); - OSXVersion = Args.MakeJoinedArg(nullptr, O, MacosxVersionMin); - Args.append(OSXVersion); } } @@ -1101,6 +1068,18 @@ void Darwin::CheckObjCARC() const { getDriver().Diag(diag::err_arc_unsupported_on_toolchain); } +SanitizerMask Darwin::getSupportedSanitizers() const { + SanitizerMask Res = ToolChain::getSupportedSanitizers(); + if (isTargetMacOS() || isTargetIOSSimulator()) { + // ASan and UBSan are available on Mac OS and on iOS simulator. + Res |= SanitizerKind::Address; + Res |= SanitizerKind::Vptr; + } + if (isTargetMacOS()) + Res |= SanitizerKind::SafeStack; + return Res; +} + /// Generic_GCC - A tool chain using the 'gcc' command to perform /// all subcommands; this relies on gcc translating the majority of /// command line options. @@ -2084,6 +2063,8 @@ bool Generic_GCC::IsIntegratedAssemblerDefault() const { case llvm::Triple::aarch64_be: case llvm::Triple::arm: case llvm::Triple::armeb: + case llvm::Triple::bpfel: + case llvm::Triple::bpfeb: case llvm::Triple::thumb: case llvm::Triple::thumbeb: case llvm::Triple::ppc: @@ -2739,6 +2720,24 @@ bool FreeBSD::isPIEDefault() const { return getSanitizerArgs().requiresPIE(); } +SanitizerMask FreeBSD::getSupportedSanitizers() const { + const bool IsX86 = getTriple().getArch() == llvm::Triple::x86; + const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64; + const bool IsMIPS64 = getTriple().getArch() == llvm::Triple::mips64 || + getTriple().getArch() == llvm::Triple::mips64el; + SanitizerMask Res = ToolChain::getSupportedSanitizers(); + Res |= SanitizerKind::Address; + Res |= SanitizerKind::Vptr; + if (IsX86_64 || IsMIPS64) { + Res |= SanitizerKind::Leak; + Res |= SanitizerKind::Thread; + } + if (IsX86 || IsX86_64) { + Res |= SanitizerKind::SafeStack; + } + return Res; +} + /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly. NetBSD::NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) @@ -3643,6 +3642,28 @@ bool Linux::isPIEDefault() const { return getSanitizerArgs().requiresPIE(); } +SanitizerMask Linux::getSupportedSanitizers() const { + const bool IsX86 = getTriple().getArch() == llvm::Triple::x86; + const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64; + const bool IsMIPS64 = getTriple().getArch() == llvm::Triple::mips64 || + getTriple().getArch() == llvm::Triple::mips64el; + SanitizerMask Res = ToolChain::getSupportedSanitizers(); + Res |= SanitizerKind::Address; + Res |= SanitizerKind::KernelAddress; + Res |= SanitizerKind::Vptr; + if (IsX86_64 || IsMIPS64) { + Res |= SanitizerKind::DataFlow; + Res |= SanitizerKind::Leak; + Res |= SanitizerKind::Memory; + Res |= SanitizerKind::Thread; + } + if (IsX86 || IsX86_64) { + Res |= SanitizerKind::Function; + Res |= SanitizerKind::SafeStack; + } + return Res; +} + /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly. DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) @@ -3742,3 +3763,46 @@ void XCore::AddCXXStdlibLibArgs(const ArgList &Args, ArgStringList &CmdArgs) const { // We don't output any lib args. This is handled by xcc. } + +// SHAVEToolChain does not call Clang's C compiler. +// We override SelectTool to avoid testing ShouldUseClangCompiler(). +Tool *SHAVEToolChain::SelectTool(const JobAction &JA) const { + switch (JA.getKind()) { + case Action::CompileJobClass: + if (!Compiler) + Compiler.reset(new tools::SHAVE::Compile(*this)); + return Compiler.get(); + case Action::AssembleJobClass: + if (!Assembler) + Assembler.reset(new tools::SHAVE::Assemble(*this)); + return Assembler.get(); + default: + return ToolChain::getTool(JA.getKind()); + } +} + +SHAVEToolChain::SHAVEToolChain(const Driver &D, const llvm::Triple &Triple, + const ArgList &Args) + : Generic_GCC(D, Triple, Args) {} + +SHAVEToolChain::~SHAVEToolChain() {} + +/// Following are methods necessary to avoid having moviClang be an abstract +/// class. + +Tool *SHAVEToolChain::getTool(Action::ActionClass AC) const { + // SelectTool() must find a tool using the method in the superclass. + // There's nothing we can do if that fails. + llvm_unreachable("SHAVEToolChain can't getTool"); +} + +Tool *SHAVEToolChain::buildLinker() const { + // SHAVEToolChain executables can not be linked except by the vendor tools. + llvm_unreachable("SHAVEToolChain can't buildLinker"); +} + +Tool *SHAVEToolChain::buildAssembler() const { + // This one you'd think should be reachable since we expose an + // assembler to the driver, except not the way it expects. + llvm_unreachable("SHAVEToolChain can't buildAssembler"); +} diff --git a/lib/Driver/ToolChains.h b/lib/Driver/ToolChains.h index 0b7073f2ba0b..a48bb5fa5948 100644 --- a/lib/Driver/ToolChains.h +++ b/lib/Driver/ToolChains.h @@ -316,9 +316,6 @@ public: /// Darwin - The base Darwin tool chain. class LLVM_LIBRARY_VISIBILITY Darwin : public MachO { public: - /// The host version. - unsigned DarwinVersion[3]; - /// Whether the information on the target has been initialized. // // FIXME: This should be eliminated. What we want to do is make this part of @@ -338,15 +335,6 @@ public: mutable VersionTuple TargetVersion; private: - /// The default macosx-version-min of this tool chain; empty until - /// initialized. - std::string MacosxVersionMin; - - /// The default ios-version-min of this tool chain; empty until - /// initialized. - std::string iOSVersionMin; - -private: void AddDeploymentTarget(llvm::opt::DerivedArgList &Args) const; public: @@ -412,6 +400,7 @@ protected: } bool isTargetMacOS() const { + assert(TargetInitialized && "Target not initialized!"); return TargetPlatform == MacOS; } @@ -474,6 +463,8 @@ public: void CheckObjCARC() const override; bool UseSjLjExceptions() const override; + + SanitizerMask getSupportedSanitizers() const override; }; /// DarwinClang - The Darwin toolchain used by Clang. @@ -616,6 +607,7 @@ public: bool UseSjLjExceptions() const override; bool isPIEDefault() const override; + SanitizerMask getSupportedSanitizers() const override; protected: Tool *buildAssembler() const override; Tool *buildLinker() const override; @@ -679,6 +671,7 @@ public: AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override; bool isPIEDefault() const override; + SanitizerMask getSupportedSanitizers() const override; std::string Linker; std::vector<std::string> ExtraOpts; @@ -809,6 +802,7 @@ public: std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args, types::ID InputType) const override; + SanitizerMask getSupportedSanitizers() const override; protected: void AddSystemIncludeWithSubfolder(const llvm::opt::ArgList &DriverArgs, @@ -872,6 +866,27 @@ public: llvm::opt::ArgStringList &CmdArgs) const override; }; +/// SHAVEToolChain - A tool chain using the compiler installed by the the +// Movidius SDK into MV_TOOLS_DIR (which we assume will be copied to llvm's +// installation dir) to perform all subcommands. +class LLVM_LIBRARY_VISIBILITY SHAVEToolChain : public Generic_GCC { +public: + SHAVEToolChain(const Driver &D, const llvm::Triple &Triple, + const llvm::opt::ArgList &Args); + ~SHAVEToolChain() override; + + virtual Tool *SelectTool(const JobAction &JA) const override; + +protected: + Tool *getTool(Action::ActionClass AC) const override; + Tool *buildAssembler() const override; + Tool *buildLinker() const override; + +private: + mutable std::unique_ptr<Tool> Compiler; + mutable std::unique_ptr<Tool> Assembler; +}; + } // end namespace toolchains } // end namespace driver } // end namespace clang diff --git a/lib/Driver/Tools.cpp b/lib/Driver/Tools.cpp index 711dee273197..2367914cc0b4 100644 --- a/lib/Driver/Tools.cpp +++ b/lib/Driver/Tools.cpp @@ -679,7 +679,7 @@ static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple, // getARMArch is used here instead of just checking the -march value in order // to handle -march=native correctly. if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { - StringRef Arch = arm::getARMArch(Args, Triple); + std::string Arch = arm::getARMArch(Args, Triple); if (llvm::ARMTargetParser::parseArch(Arch) == llvm::ARM::AK_INVALID) D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); } @@ -689,7 +689,7 @@ static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple, // getLLVMArchSuffixForARM which also needs an architecture. if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { std::string CPU = arm::getARMTargetCPU(Args, Triple); - StringRef Arch = arm::getARMArch(Args, Triple); + std::string Arch = arm::getARMArch(Args, Triple); if (strcmp(arm::getLLVMArchSuffixForARM(CPU, Arch), "") == 0) D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); } @@ -850,7 +850,7 @@ static std::string getAArch64TargetCPU(const ArgList &Args) { CPU = A->getValue(); } else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) { StringRef Mcpu = A->getValue(); - CPU = Mcpu.split("+").first; + CPU = Mcpu.split("+").first.lower(); } // Handle CPU name is 'native'. @@ -1116,7 +1116,7 @@ static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple, Features.push_back(Args.MakeArgString("+nooddspreg")); } else Features.push_back(Args.MakeArgString("+fp64")); - } else if (mips::isFPXXDefault(Triple, CPUName, ABIName)) { + } else if (mips::shouldUseFPXX(Args, Triple, CPUName, ABIName, FloatABI)) { Features.push_back(Args.MakeArgString("+fpxx")); Features.push_back(Args.MakeArgString("+nooddspreg")); } @@ -1334,47 +1334,26 @@ static std::string getR600TargetGPU(const ArgList &Args) { return ""; } -static void getSparcTargetFeatures(const ArgList &Args, - std::vector<const char *> &Features) { - bool SoftFloatABI = true; - if (Arg *A = - Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) { - if (A->getOption().matches(options::OPT_mhard_float)) - SoftFloatABI = false; - } - if (SoftFloatABI) - Features.push_back("+soft-float"); -} - void Clang::AddSparcTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const { const Driver &D = getToolChain().getDriver(); + std::string Triple = getToolChain().ComputeEffectiveClangTriple(Args); - // Select the float ABI as determined by -msoft-float and -mhard-float. - StringRef FloatABI; - if (Arg *A = Args.getLastArg(options::OPT_msoft_float, - options::OPT_mhard_float)) { + bool SoftFloatABI = false; + if (Arg *A = + Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) { if (A->getOption().matches(options::OPT_msoft_float)) - FloatABI = "soft"; - else if (A->getOption().matches(options::OPT_mhard_float)) - FloatABI = "hard"; + SoftFloatABI = true; } - // If unspecified, choose the default based on the platform. - if (FloatABI.empty()) { - // Assume "soft", but warn the user we are guessing. - FloatABI = "soft"; - D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft"; - } - - if (FloatABI == "soft") { - // Floating point operations and argument passing are soft. - // - // FIXME: This changes CPP defines, we need -target-soft-float. - CmdArgs.push_back("-msoft-float"); - } else { - assert(FloatABI == "hard" && "Invalid float abi!"); - CmdArgs.push_back("-mhard-float"); + // Only the hard-float ABI on Sparc is standardized, and it is the + // default. GCC also supports a nonstandard soft-float ABI mode, and + // perhaps LLVM should implement that, too. However, since llvm + // currently does not support Sparc soft-float, at all, display an + // error if it's requested. + if (SoftFloatABI) { + D.Diag(diag::err_drv_unsupported_opt_for_target) + << "-msoft-float" << Triple; } } @@ -1550,6 +1529,137 @@ static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args, CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU)); } +/// This is a helper function for validating the optional refinement step +/// parameter in reciprocal argument strings. Return false if there is an error +/// parsing the refinement step. Otherwise, return true and set the Position +/// of the refinement step in the input string. +static bool getRefinementStep(const StringRef &In, const Driver &D, + const Arg &A, size_t &Position) { + const char RefinementStepToken = ':'; + Position = In.find(RefinementStepToken); + if (Position != StringRef::npos) { + StringRef Option = A.getOption().getName(); + StringRef RefStep = In.substr(Position + 1); + // Allow exactly one numeric character for the additional refinement + // step parameter. This is reasonable for all currently-supported + // operations and architectures because we would expect that a larger value + // of refinement steps would cause the estimate "optimization" to + // under-perform the native operation. Also, if the estimate does not + // converge quickly, it probably will not ever converge, so further + // refinement steps will not produce a better answer. + if (RefStep.size() != 1) { + D.Diag(diag::err_drv_invalid_value) << Option << RefStep; + return false; + } + char RefStepChar = RefStep[0]; + if (RefStepChar < '0' || RefStepChar > '9') { + D.Diag(diag::err_drv_invalid_value) << Option << RefStep; + return false; + } + } + return true; +} + +/// The -mrecip flag requires processing of many optional parameters. +static void ParseMRecip(const Driver &D, const ArgList &Args, + ArgStringList &OutStrings) { + StringRef DisabledPrefixIn = "!"; + StringRef DisabledPrefixOut = "!"; + StringRef EnabledPrefixOut = ""; + StringRef Out = "-mrecip="; + + Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ); + if (!A) + return; + + unsigned NumOptions = A->getNumValues(); + if (NumOptions == 0) { + // No option is the same as "all". + OutStrings.push_back(Args.MakeArgString(Out + "all")); + return; + } + + // Pass through "all", "none", or "default" with an optional refinement step. + if (NumOptions == 1) { + StringRef Val = A->getValue(0); + size_t RefStepLoc; + if (!getRefinementStep(Val, D, *A, RefStepLoc)) + return; + StringRef ValBase = Val.slice(0, RefStepLoc); + if (ValBase == "all" || ValBase == "none" || ValBase == "default") { + OutStrings.push_back(Args.MakeArgString(Out + Val)); + return; + } + } + + // Each reciprocal type may be enabled or disabled individually. + // Check each input value for validity, concatenate them all back together, + // and pass through. + + llvm::StringMap<bool> OptionStrings; + OptionStrings.insert(std::make_pair("divd", false)); + OptionStrings.insert(std::make_pair("divf", false)); + OptionStrings.insert(std::make_pair("vec-divd", false)); + OptionStrings.insert(std::make_pair("vec-divf", false)); + OptionStrings.insert(std::make_pair("sqrtd", false)); + OptionStrings.insert(std::make_pair("sqrtf", false)); + OptionStrings.insert(std::make_pair("vec-sqrtd", false)); + OptionStrings.insert(std::make_pair("vec-sqrtf", false)); + + for (unsigned i = 0; i != NumOptions; ++i) { + StringRef Val = A->getValue(i); + + bool IsDisabled = Val.startswith(DisabledPrefixIn); + // Ignore the disablement token for string matching. + if (IsDisabled) + Val = Val.substr(1); + + size_t RefStep; + if (!getRefinementStep(Val, D, *A, RefStep)) + return; + + StringRef ValBase = Val.slice(0, RefStep); + llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase); + if (OptionIter == OptionStrings.end()) { + // Try again specifying float suffix. + OptionIter = OptionStrings.find(ValBase.str() + 'f'); + if (OptionIter == OptionStrings.end()) { + // The input name did not match any known option string. + D.Diag(diag::err_drv_unknown_argument) << Val; + return; + } + // The option was specified without a float or double suffix. + // Make sure that the double entry was not already specified. + // The float entry will be checked below. + if (OptionStrings[ValBase.str() + 'd']) { + D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val; + return; + } + } + + if (OptionIter->second == true) { + // Duplicate option specified. + D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val; + return; + } + + // Mark the matched option as found. Do not allow duplicate specifiers. + OptionIter->second = true; + + // If the precision was not specified, also mark the double entry as found. + if (ValBase.back() != 'f' && ValBase.back() != 'd') + OptionStrings[ValBase.str() + 'd'] = true; + + // Build the output string. + StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut; + Out = Args.MakeArgString(Out + Prefix + Val); + if (i != NumOptions - 1) + Out = Args.MakeArgString(Out + ","); + } + + OutStrings.push_back(Args.MakeArgString(Out)); +} + static void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple, const ArgList &Args, std::vector<const char *> &Features) { @@ -1738,7 +1848,8 @@ static bool getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March, const ArgList &Args, std::vector<const char *> &Features) { - std::pair<StringRef, StringRef> Split = March.split("+"); + std::string MarchLowerCase = March.lower(); + std::pair<StringRef, StringRef> Split = StringRef(MarchLowerCase).split("+"); if (Split.first == "armv8-a" || Split.first == "armv8a") { @@ -1762,7 +1873,8 @@ getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu, const ArgList &Args, std::vector<const char *> &Features) { StringRef CPU; - if (!DecodeAArch64Mcpu(D, Mcpu, CPU, Features)) + std::string McpuLowerCase = Mcpu.lower(); + if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, Features)) return false; return true; @@ -1788,7 +1900,8 @@ getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu, std::vector<const char *> &Features) { StringRef CPU; std::vector<const char *> DecodedFeature; - if (!DecodeAArch64Mcpu(D, Mcpu, CPU, DecodedFeature)) + std::string McpuLowerCase = Mcpu.lower(); + if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, DecodedFeature)) return false; return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features); @@ -1863,11 +1976,6 @@ static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple, case llvm::Triple::ppc64le: getPPCTargetFeatures(Args, Features); break; - case llvm::Triple::sparc: - case llvm::Triple::sparcel: - case llvm::Triple::sparcv9: - getSparcTargetFeatures(Args, Features); - break; case llvm::Triple::systemz: getSystemZTargetFeatures(Args, Features); break; @@ -2326,6 +2434,8 @@ collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args, if (SanArgs.linkCXXRuntimes()) StaticRuntimes.push_back("ubsan_standalone_cxx"); } + if (SanArgs.needsSafeStackRt()) + StaticRuntimes.push_back("safestack"); } // Should be called before we add system libraries (C++ ABI, libstdc++/libc++, @@ -3151,6 +3261,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast")); } } + + ParseMRecip(getToolChain().getDriver(), Args, CmdArgs); // We separately look for the '-ffast-math' and '-ffinite-math-only' flags, // and if we find them, tell the frontend to provide the appropriate @@ -3892,7 +4004,12 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // -stack-protector=0 is default. unsigned StackProtectorLevel = 0; - if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector, + if (getToolChain().getSanitizerArgs().needsSafeStackRt()) { + Args.ClaimAllArgs(options::OPT_fno_stack_protector); + Args.ClaimAllArgs(options::OPT_fstack_protector_all); + Args.ClaimAllArgs(options::OPT_fstack_protector_strong); + Args.ClaimAllArgs(options::OPT_fstack_protector); + } else if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector, options::OPT_fstack_protector_all, options::OPT_fstack_protector_strong, options::OPT_fstack_protector)) { @@ -4019,9 +4136,9 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-fblocks-runtime-optional"); } - // -fmodules enables modules (off by default). + // -fmodules enables the use of precompiled modules (off by default). // Users can pass -fno-cxx-modules to turn off modules support for - // C++/Objective-C++ programs, which is a little less mature. + // C++/Objective-C++ programs. bool HaveModules = false; if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) { bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules, @@ -4033,11 +4150,11 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, } } - // -fmodule-maps enables module map processing (off by default) for header - // checking. It is implied by -fmodules. - if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps, - false)) { - CmdArgs.push_back("-fmodule-maps"); + // -fmodule-maps enables implicit reading of module map files. By default, + // this is enabled if we are using precompiled modules. + if (Args.hasFlag(options::OPT_fimplicit_module_maps, + options::OPT_fno_implicit_module_maps, HaveModules)) { + CmdArgs.push_back("-fimplicit-module-maps"); } // -fmodules-decluse checks that modules used are declared so (off by @@ -5627,9 +5744,9 @@ void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA, } // Hexagon tools end. -const StringRef arm::getARMArch(const ArgList &Args, - const llvm::Triple &Triple) { - StringRef MArch; +const std::string arm::getARMArch(const ArgList &Args, + const llvm::Triple &Triple) { + std::string MArch; if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) { // Otherwise, if we have -march= choose the base CPU for that arch. MArch = A->getValue(); @@ -5637,6 +5754,7 @@ const StringRef arm::getARMArch(const ArgList &Args, // Otherwise, use the Arch from the triple. MArch = Triple.getArchName(); } + MArch = StringRef(MArch).lower(); // Handle -march=native. if (MArch == "native") { @@ -5658,7 +5776,7 @@ const StringRef arm::getARMArch(const ArgList &Args, /// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting. const char *arm::getARMCPUForMArch(const ArgList &Args, const llvm::Triple &Triple) { - StringRef MArch = getARMArch(Args, Triple); + std::string MArch = getARMArch(Args, Triple); // getARMCPUForArch defaults to the triple if MArch is empty, but empty MArch // here means an -march=native that we can't handle, so instead return no CPU. if (MArch.empty()) @@ -5761,7 +5879,7 @@ bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) { } bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName, - StringRef ABIName) { + StringRef ABIName, StringRef FloatABI) { if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies && Triple.getVendor() != llvm::Triple::MipsTechnologies) return false; @@ -5769,6 +5887,11 @@ bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName, if (ABIName != "32") return false; + // FPXX shouldn't be used if either -msoft-float or -mfloat-abi=soft is + // present. + if (FloatABI == "soft") + return false; + return llvm::StringSwitch<bool>(CPUName) .Cases("mips2", "mips3", "mips4", "mips5", true) .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true) @@ -5776,6 +5899,20 @@ bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName, .Default(false); } +bool mips::shouldUseFPXX(const ArgList &Args, const llvm::Triple &Triple, + StringRef CPUName, StringRef ABIName, + StringRef FloatABI) { + bool UseFPXX = isFPXXDefault(Triple, CPUName, ABIName, FloatABI); + + // FPXX shouldn't be used if -msingle-float is present. + if (Arg *A = Args.getLastArg(options::OPT_msingle_float, + options::OPT_mdouble_float)) + if (A->getOption().matches(options::OPT_msingle_float)) + UseFPXX = false; + + return UseFPXX; +} + llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) { // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for // archs which Darwin doesn't use. @@ -5901,7 +6038,7 @@ void cloudabi::Link::ConstructJob(Compilation &C, const JobAction &JA, Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); Args.AddAllArgs(CmdArgs, options::OPT_r); - if (D.IsUsingLTO(ToolChain, Args)) + if (D.IsUsingLTO(Args)) AddGoldPlugin(ToolChain, Args, CmdArgs); AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs); @@ -6052,8 +6189,7 @@ void darwin::Link::AddLinkArgs(Compilation &C, // If we are using LTO, then automatically create a temporary file path for // the linker to use, so that it's lifetime will extend past a possible // dsymutil step. - if (Version[0] >= 116 && D.IsUsingLTO(getToolChain(), Args) && - NeedsTempPath(Inputs)) { + if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) { const char *TmpPath = C.getArgs().MakeArgString( D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object))); C.addTempFile(TmpPath); @@ -6254,6 +6390,15 @@ void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, !Args.hasArg(options::OPT_nostartfiles)) getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs); + // SafeStack requires its own runtime libraries + // These libraries should be linked first, to make sure the + // __safestack_init constructor executes before everything else + if (getToolChain().getSanitizerArgs().needsSafeStackRt()) { + getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs, + "libclang_rt.safestack_osx.a", + /*AlwaysLink=*/true); + } + Args.AddAllArgs(CmdArgs, options::OPT_L); if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ, @@ -7080,7 +7225,7 @@ void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA, Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); Args.AddAllArgs(CmdArgs, options::OPT_r); - if (D.IsUsingLTO(getToolChain(), Args)) + if (D.IsUsingLTO(Args)) AddGoldPlugin(ToolChain, Args, CmdArgs); bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs); @@ -7577,12 +7722,13 @@ void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA, } // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default. + StringRef MIPSFloatABI = getMipsFloatABI(getToolChain().getDriver(), Args); if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx, options::OPT_mfp64)) { A->claim(); A->render(Args, CmdArgs); - } else if (mips::isFPXXDefault(getToolChain().getTriple(), CPUName, - ABIName)) + } else if (mips::shouldUseFPXX(Args, getToolChain().getTriple(), CPUName, + ABIName, MIPSFloatABI)) CmdArgs.push_back("-mfpxx"); // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of @@ -7613,6 +7759,9 @@ void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA, Args.AddLastArg(CmdArgs, options::OPT_mhard_float, options::OPT_msoft_float); + Args.AddLastArg(CmdArgs, options::OPT_mdouble_float, + options::OPT_msingle_float); + Args.AddLastArg(CmdArgs, options::OPT_modd_spreg, options::OPT_mno_odd_spreg); @@ -7936,7 +8085,7 @@ void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA, for (const auto &Path : Paths) CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path)); - if (D.IsUsingLTO(getToolChain(), Args)) + if (D.IsUsingLTO(Args)) AddGoldPlugin(ToolChain, Args, CmdArgs); if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) @@ -8948,3 +9097,81 @@ void CrossWindows::Link::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } + +void tools::SHAVE::Compile::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { + + ArgStringList CmdArgs; + + assert(Inputs.size() == 1); + const InputInfo &II = Inputs[0]; + assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX); + assert(Output.getType() == types::TY_PP_Asm); // Require preprocessed asm. + + // Append all -I, -iquote, -isystem paths. + Args.AddAllArgs(CmdArgs, options::OPT_clang_i_Group); + // These are spelled the same way in clang and moviCompile. + Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U); + + CmdArgs.push_back("-DMYRIAD2"); + CmdArgs.push_back("-mcpu=myriad2"); + CmdArgs.push_back("-S"); + + // Any -O option passes through without translation. What about -Ofast ? + if (Arg *A = Args.getLastArg(options::OPT_O_Group)) + A->render(Args, CmdArgs); + + if (Args.hasFlag(options::OPT_ffunction_sections, + options::OPT_fno_function_sections)) { + CmdArgs.push_back("-ffunction-sections"); + } + if (Args.hasArg(options::OPT_fno_inline_functions)) + CmdArgs.push_back("-fno-inline-functions"); + + CmdArgs.push_back("-fno-exceptions"); // Always do this even if unspecified. + + CmdArgs.push_back(II.getFilename()); + CmdArgs.push_back("-o"); + CmdArgs.push_back(Output.getFilename()); + + std::string Exec = + Args.MakeArgString(getToolChain().GetProgramPath("moviCompile")); + C.addCommand( + llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec), CmdArgs)); +} + +void tools::SHAVE::Assemble::ConstructJob(Compilation &C, + const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { + ArgStringList CmdArgs; + + assert(Inputs.size() == 1); + const InputInfo &II = Inputs[0]; + assert(II.getType() == types::TY_PP_Asm); // Require preprocessed asm input. + assert(Output.getType() == types::TY_Object); + + CmdArgs.push_back("-no6thSlotCompression"); + CmdArgs.push_back("-cv:myriad2"); // Chip Version ? + CmdArgs.push_back("-noSPrefixing"); + CmdArgs.push_back("-a"); // Mystery option. + for (auto Arg : Args.filtered(options::OPT_I)) { + Arg->claim(); + CmdArgs.push_back( + Args.MakeArgString(std::string("-i:") + Arg->getValue(0))); + } + CmdArgs.push_back("-elf"); // Output format. + CmdArgs.push_back(II.getFilename()); + CmdArgs.push_back( + Args.MakeArgString(std::string("-o:") + Output.getFilename())); + + std::string Exec = + Args.MakeArgString(getToolChain().GetProgramPath("moviAsm")); + C.addCommand( + llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec), CmdArgs)); +} diff --git a/lib/Driver/Tools.h b/lib/Driver/Tools.h index 133a389e5109..753f542622fe 100644 --- a/lib/Driver/Tools.h +++ b/lib/Driver/Tools.h @@ -227,8 +227,8 @@ namespace hexagon { namespace arm { std::string getARMTargetCPU(const llvm::opt::ArgList &Args, const llvm::Triple &Triple); - const StringRef getARMArch(const llvm::opt::ArgList &Args, - const llvm::Triple &Triple); + const std::string getARMArch(const llvm::opt::ArgList &Args, + const llvm::Triple &Triple); const char* getARMCPUForMArch(const llvm::opt::ArgList &Args, const llvm::Triple &Triple); const char* getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch); @@ -249,7 +249,9 @@ namespace mips { bool isUCLibc(const llvm::opt::ArgList &Args); bool isNaN2008(const llvm::opt::ArgList &Args, const llvm::Triple &Triple); bool isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName, - StringRef ABIName); + StringRef ABIName, StringRef FloatABI); + bool shouldUseFPXX(const llvm::opt::ArgList &Args, const llvm::Triple &Triple, + StringRef CPUName, StringRef ABIName, StringRef FloatABI); } namespace ppc { @@ -731,6 +733,33 @@ public: }; } +/// SHAVE tools -- Directly call moviCompile and moviAsm +namespace SHAVE { +class LLVM_LIBRARY_VISIBILITY Compile : public Tool { +public: + Compile(const ToolChain &TC) : Tool("moviCompile", "movicompile", TC) {} + + bool hasIntegratedCPP() const override { return true; } + + void ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, const InputInfoList &Inputs, + const llvm::opt::ArgList &TCArgs, + const char *LinkingOutput) const override; +}; + +class LLVM_LIBRARY_VISIBILITY Assemble : public Tool { +public: + Assemble(const ToolChain &TC) : Tool("moviAsm", "moviAsm", TC) {} + + bool hasIntegratedCPP() const override { return false; } // not sure. + + void ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, const InputInfoList &Inputs, + const llvm::opt::ArgList &TCArgs, + const char *LinkingOutput) const override; +}; +} // end namespace SHAVE + } // end namespace tools } // end namespace driver } // end namespace clang diff --git a/lib/Driver/Types.cpp b/lib/Driver/Types.cpp index 0b0878fdd802..7b281457557b 100644 --- a/lib/Driver/Types.cpp +++ b/lib/Driver/Types.cpp @@ -45,7 +45,7 @@ types::ID types::getPreprocessedType(ID Id) { } const char *types::getTypeTempSuffix(ID Id, bool CLMode) { - if ((Id == TY_Object || Id == TY_LTO_BC) && CLMode) + if (Id == TY_Object && CLMode) return "obj"; if (Id == TY_Image && CLMode) return "exe"; diff --git a/lib/Format/BreakableToken.cpp b/lib/Format/BreakableToken.cpp index e3e162d070f8..36a8c4d8da6d 100644 --- a/lib/Format/BreakableToken.cpp +++ b/lib/Format/BreakableToken.cpp @@ -183,7 +183,7 @@ void BreakableStringLiteral::insertBreak(unsigned LineIndex, } static StringRef getLineCommentIndentPrefix(StringRef Comment) { - static const char *const KnownPrefixes[] = { "///", "//", "//!" }; + static const char *const KnownPrefixes[] = {"///", "//", "//!"}; StringRef LongestPrefix; for (StringRef KnownPrefix : KnownPrefixes) { if (Comment.startswith(KnownPrefix)) { @@ -239,9 +239,8 @@ void BreakableLineComment::replaceWhitespace(unsigned LineIndex, /*Spaces=*/1); } -void -BreakableLineComment::replaceWhitespaceBefore(unsigned LineIndex, - WhitespaceManager &Whitespaces) { +void BreakableLineComment::replaceWhitespaceBefore( + unsigned LineIndex, WhitespaceManager &Whitespaces) { if (OriginalPrefix != Prefix) { Whitespaces.replaceWhitespaceInToken(Tok, OriginalPrefix.size(), 0, "", "", /*InPPDirective=*/false, @@ -345,7 +344,7 @@ void BreakableBlockComment::adjustWhitespace(unsigned LineIndex, // Calculate the start of the non-whitespace text in the current line. size_t StartOfLine = Lines[LineIndex].find_first_not_of(Blanks); if (StartOfLine == StringRef::npos) - StartOfLine = Lines[LineIndex].size(); + StartOfLine = Lines[LineIndex].rtrim("\r\n").size(); StringRef Whitespace = Lines[LineIndex].substr(0, StartOfLine); // Adjust Lines to only contain relevant text. @@ -415,9 +414,8 @@ void BreakableBlockComment::replaceWhitespace(unsigned LineIndex, /*Newlines=*/0, /*IndentLevel=*/0, /*Spaces=*/1); } -void -BreakableBlockComment::replaceWhitespaceBefore(unsigned LineIndex, - WhitespaceManager &Whitespaces) { +void BreakableBlockComment::replaceWhitespaceBefore( + unsigned LineIndex, WhitespaceManager &Whitespaces) { if (LineIndex == 0) return; StringRef Prefix = Decoration; diff --git a/lib/Format/ContinuationIndenter.cpp b/lib/Format/ContinuationIndenter.cpp index 91bc64b2b8b4..2357abd7abdb 100644 --- a/lib/Format/ContinuationIndenter.cpp +++ b/lib/Format/ContinuationIndenter.cpp @@ -150,12 +150,6 @@ bool ContinuationIndenter::mustBreak(const LineState &State) { State.Stack.back().BreakBeforeParameter && !Current.isTrailingComment() && !Current.isOneOf(tok::r_paren, tok::r_brace)) return true; - if (Style.AlwaysBreakBeforeMultilineStrings && - State.Column > State.Stack.back().Indent && // Breaking saves columns. - !Previous.isOneOf(tok::kw_return, tok::lessless, tok::at) && - !Previous.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) && - nextIsMultilineString(State)) - return true; if (((Previous.is(TT_DictLiteral) && Previous.is(tok::l_brace)) || Previous.is(TT_ArrayInitializerLSquare)) && Style.ColumnLimit > 0 && @@ -170,9 +164,18 @@ bool ContinuationIndenter::mustBreak(const LineState &State) { State.Stack.back().BreakBeforeParameter) return true; - if (State.Column < getNewLineColumn(State)) + unsigned NewLineColumn = getNewLineColumn(State); + if (State.Column < NewLineColumn) return false; + if (Style.AlwaysBreakBeforeMultilineStrings && + (NewLineColumn == State.FirstIndent + Style.ContinuationIndentWidth || + Previous.is(tok::comma) || Current.NestingLevel < 2) && + !Previous.isOneOf(tok::kw_return, tok::lessless, tok::at) && + !Previous.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) && + nextIsMultilineString(State)) + return true; + // Using CanBreakBefore here and below takes care of the decision whether the // current style uses wrapping before or after operators for the given // operator. @@ -416,7 +419,21 @@ unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State, Penalty += Style.PenaltyBreakFirstLessLess; State.Column = getNewLineColumn(State); - State.Stack.back().NestedBlockIndent = State.Column; + + // Indent nested blocks relative to this column, unless in a very specific + // JavaScript special case where: + // + // var loooooong_name = + // function() { + // // code + // } + // + // is common and should be formatted like a free-standing function. + if (Style.Language != FormatStyle::LK_JavaScript || + Current.NestingLevel != 0 || !PreviousNonComment->is(tok::equal) || + !Current.is(Keywords.kw_function)) + State.Stack.back().NestedBlockIndent = State.Column; + if (NextNonComment->isMemberAccess()) { if (State.Stack.back().CallContinuation == 0) State.Stack.back().CallContinuation = State.Column; @@ -688,7 +705,8 @@ unsigned ContinuationIndenter::moveStateToNextToken(LineState &State, // foo(); // bar(); // }, a, b, c); - if (Current.isNot(tok::comment) && Previous && Previous->is(tok::l_brace) && + if (Current.isNot(tok::comment) && Previous && + Previous->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) && State.Stack.size() > 1) { if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline) for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i) @@ -713,7 +731,7 @@ unsigned ContinuationIndenter::moveStateToNextToken(LineState &State, if (Current.is(TT_ObjCStringLiteral) && State.StartOfStringLiteral == 0) State.StartOfStringLiteral = State.Column + 1; else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) && - !Current.isStringLiteral()) + !Current.isStringLiteral()) State.StartOfStringLiteral = 0; State.Column += Current.ColumnWidth; @@ -891,7 +909,7 @@ void ContinuationIndenter::moveStatePastScopeOpener(LineState &State, // be a line break within this call. for (const FormatToken *Tok = &Current; Tok && Tok != Current.MatchingParen; Tok = Tok->Next) { - if (Tok->MustBreakBefore || + if (Tok->MustBreakBefore || (Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) { BreakBeforeParameter = true; break; diff --git a/lib/Format/ContinuationIndenter.h b/lib/Format/ContinuationIndenter.h index 1da6bd95f100..9b9154ed3095 100644 --- a/lib/Format/ContinuationIndenter.h +++ b/lib/Format/ContinuationIndenter.h @@ -148,13 +148,10 @@ struct ParenState { ParenState(unsigned Indent, unsigned IndentLevel, unsigned LastSpace, bool AvoidBinPacking, bool NoLineBreak) : Indent(Indent), IndentLevel(IndentLevel), LastSpace(LastSpace), - NestedBlockIndent(Indent), FirstLessLess(0), - BreakBeforeClosingBrace(false), QuestionColumn(0), + NestedBlockIndent(Indent), BreakBeforeClosingBrace(false), AvoidBinPacking(AvoidBinPacking), BreakBeforeParameter(false), - NoLineBreak(NoLineBreak), LastOperatorWrapped(true), ColonPos(0), - StartOfFunctionCall(0), StartOfArraySubscripts(0), - NestedNameSpecifierContinuation(0), CallContinuation(0), VariablePos(0), - ContainsLineBreak(false), ContainsUnwrappedBuilder(0), + NoLineBreak(NoLineBreak), LastOperatorWrapped(true), + ContainsLineBreak(false), ContainsUnwrappedBuilder(false), AlignColons(true), ObjCSelectorNameFound(false), HasMultipleNestedBlocks(false), NestedBlockInlined(false) {} @@ -180,90 +177,90 @@ struct ParenState { /// /// Used to align "<<" operators. 0 if no such operator has been encountered /// on a level. - unsigned FirstLessLess; - - /// \brief Whether a newline needs to be inserted before the block's closing - /// brace. - /// - /// We only want to insert a newline before the closing brace if there also - /// was a newline after the beginning left brace. - bool BreakBeforeClosingBrace; + unsigned FirstLessLess = 0; /// \brief The column of a \c ? in a conditional expression; - unsigned QuestionColumn; - - /// \brief Avoid bin packing, i.e. multiple parameters/elements on multiple - /// lines, in this context. - bool AvoidBinPacking; - - /// \brief Break after the next comma (or all the commas in this context if - /// \c AvoidBinPacking is \c true). - bool BreakBeforeParameter; - - /// \brief Line breaking in this context would break a formatting rule. - bool NoLineBreak; - - /// \brief True if the last binary operator on this level was wrapped to the - /// next line. - bool LastOperatorWrapped; + unsigned QuestionColumn = 0; /// \brief The position of the colon in an ObjC method declaration/call. - unsigned ColonPos; + unsigned ColonPos = 0; /// \brief The start of the most recent function in a builder-type call. - unsigned StartOfFunctionCall; + unsigned StartOfFunctionCall = 0; /// \brief Contains the start of array subscript expressions, so that they /// can be aligned. - unsigned StartOfArraySubscripts; + unsigned StartOfArraySubscripts = 0; /// \brief If a nested name specifier was broken over multiple lines, this /// contains the start column of the second line. Otherwise 0. - unsigned NestedNameSpecifierContinuation; + unsigned NestedNameSpecifierContinuation = 0; /// \brief If a call expression was broken over multiple lines, this /// contains the start column of the second line. Otherwise 0. - unsigned CallContinuation; + unsigned CallContinuation = 0; /// \brief The column of the first variable name in a variable declaration. /// /// Used to align further variables if necessary. - unsigned VariablePos; + unsigned VariablePos = 0; + + /// \brief Whether a newline needs to be inserted before the block's closing + /// brace. + /// + /// We only want to insert a newline before the closing brace if there also + /// was a newline after the beginning left brace. + bool BreakBeforeClosingBrace : 1; + + /// \brief Avoid bin packing, i.e. multiple parameters/elements on multiple + /// lines, in this context. + bool AvoidBinPacking : 1; + + /// \brief Break after the next comma (or all the commas in this context if + /// \c AvoidBinPacking is \c true). + bool BreakBeforeParameter : 1; + + /// \brief Line breaking in this context would break a formatting rule. + bool NoLineBreak : 1; + + /// \brief True if the last binary operator on this level was wrapped to the + /// next line. + bool LastOperatorWrapped : 1; /// \brief \c true if this \c ParenState already contains a line-break. /// /// The first line break in a certain \c ParenState causes extra penalty so /// that clang-format prefers similar breaks, i.e. breaks in the same /// parenthesis. - bool ContainsLineBreak; + bool ContainsLineBreak : 1; /// \brief \c true if this \c ParenState contains multiple segments of a /// builder-type call on one line. - bool ContainsUnwrappedBuilder; + bool ContainsUnwrappedBuilder : 1; /// \brief \c true if the colons of the curren ObjC method expression should /// be aligned. /// /// Not considered for memoization as it will always have the same value at /// the same token. - bool AlignColons; + bool AlignColons : 1; /// \brief \c true if at least one selector name was found in the current /// ObjC method expression. /// /// Not considered for memoization as it will always have the same value at /// the same token. - bool ObjCSelectorNameFound; + bool ObjCSelectorNameFound : 1; /// \brief \c true if there are multiple nested blocks inside these parens. /// /// Not considered for memoization as it will always have the same value at /// the same token. - bool HasMultipleNestedBlocks; + bool HasMultipleNestedBlocks : 1; // \brief The start of a nested block (e.g. lambda introducer in C++ or // "function" in JavaScript) is not wrapped to a new line. - bool NestedBlockInlined; + bool NestedBlockInlined : 1; bool operator<(const ParenState &Other) const { if (Indent != Other.Indent) diff --git a/lib/Format/Format.cpp b/lib/Format/Format.cpp index c725b4bf30ab..0feeaa007f3e 100644 --- a/lib/Format/Format.cpp +++ b/lib/Format/Format.cpp @@ -174,7 +174,8 @@ template <> struct MappingTraits<FormatStyle> { IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlinesLeft); IO.mapOptional("AlignOperands", Style.AlignOperands); IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments); - IO.mapOptional("AlignConsecutiveAssignments", Style.AlignConsecutiveAssignments); + IO.mapOptional("AlignConsecutiveAssignments", + Style.AlignConsecutiveAssignments); IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine", Style.AllowAllParametersOfDeclarationOnNextLine); IO.mapOptional("AllowShortBlocksOnASingleLine", @@ -785,7 +786,8 @@ private: // Backticks get lexed as tok::unknown tokens. If a template string contains // a comment start, it gets lexed as a tok::comment, or tok::unknown if // unterminated. - if (!EndBacktick->isOneOf(tok::comment, tok::unknown)) + if (!EndBacktick->isOneOf(tok::comment, tok::string_literal, + tok::char_constant, tok::unknown)) return false; size_t CommentBacktickPos = EndBacktick->TokenText.find('`'); // Unknown token that's not actually a backtick, or a comment that doesn't @@ -1122,7 +1124,10 @@ private: Column = FormatTok->LastLineColumnWidth; } - if (std::find(ForEachMacros.begin(), ForEachMacros.end(), + if (!(Tokens.size() > 0 && Tokens.back()->Tok.getIdentifierInfo() && + Tokens.back()->Tok.getIdentifierInfo()->getPPKeywordID() == + tok::pp_define) && + std::find(ForEachMacros.begin(), ForEachMacros.end(), FormatTok->Tok.getIdentifierInfo()) != ForEachMacros.end()) FormatTok->Type = TT_ForEachMacro; @@ -1254,7 +1259,8 @@ public: } tooling::Replacements format(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines, - FormatTokenLexer &Tokens, bool *IncompleteFormat) { + FormatTokenLexer &Tokens, + bool *IncompleteFormat) { TokenAnnotator Annotator(Style, Tokens.getKeywords()); for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) { Annotator.annotate(*AnnotatedLines[i]); @@ -1500,8 +1506,7 @@ tooling::Replacements reformat(const FormatStyle &Style, tooling::Replacements reformat(const FormatStyle &Style, StringRef Code, ArrayRef<tooling::Range> Ranges, - StringRef FileName, - bool *IncompleteFormat) { + StringRef FileName, bool *IncompleteFormat) { if (Style.DisableFormat) return tooling::Replacements(); diff --git a/lib/Format/FormatToken.cpp b/lib/Format/FormatToken.cpp index 88678ca1abe1..316171dc1891 100644 --- a/lib/Format/FormatToken.cpp +++ b/lib/Format/FormatToken.cpp @@ -203,11 +203,14 @@ void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) { // We can never place more than ColumnLimit / 3 items in a row (because of the // spaces and the comma). - for (unsigned Columns = 1; Columns <= Style.ColumnLimit / 3; ++Columns) { + unsigned MaxItems = Style.ColumnLimit / 3; + std::vector<unsigned> MinSizeInColumn; + MinSizeInColumn.reserve(MaxItems); + for (unsigned Columns = 1; Columns <= MaxItems; ++Columns) { ColumnFormat Format; Format.Columns = Columns; Format.ColumnSizes.resize(Columns); - std::vector<unsigned> MinSizeInColumn(Columns, UINT_MAX); + MinSizeInColumn.assign(Columns, UINT_MAX); Format.LineCount = 1; bool HasRowWithSufficientColumns = false; unsigned Column = 0; diff --git a/lib/Format/FormatToken.h b/lib/Format/FormatToken.h index dd12969454e4..5b7dadb8545b 100644 --- a/lib/Format/FormatToken.h +++ b/lib/Format/FormatToken.h @@ -86,24 +86,12 @@ enum TokenType { }; // Represents what type of block a set of braces open. -enum BraceBlockKind { - BK_Unknown, - BK_Block, - BK_BracedInit -}; +enum BraceBlockKind { BK_Unknown, BK_Block, BK_BracedInit }; // The packing kind of a function's parameters. -enum ParameterPackingKind { - PPK_BinPacked, - PPK_OnePerLine, - PPK_Inconclusive -}; +enum ParameterPackingKind { PPK_BinPacked, PPK_OnePerLine, PPK_Inconclusive }; -enum FormatDecision { - FD_Unformatted, - FD_Continue, - FD_Break -}; +enum FormatDecision { FD_Unformatted, FD_Continue, FD_Break }; class TokenRole; class AnnotatedLine; diff --git a/lib/Format/TokenAnnotator.cpp b/lib/Format/TokenAnnotator.cpp index 78e6103bfcd5..8d08c3d26227 100644 --- a/lib/Format/TokenAnnotator.cpp +++ b/lib/Format/TokenAnnotator.cpp @@ -87,7 +87,7 @@ private: if (CurrentToken->Previous->isOneOf(tok::pipepipe, tok::ampamp) && CurrentToken->Previous->is(TT_BinaryOperator) && Contexts[Contexts.size() - 2].IsExpression && - Line.First->isNot(tok::kw_template)) + !Line.startsWith(tok::kw_template)) return false; updateParameterCount(Left, CurrentToken); if (!consumeToken()) @@ -255,7 +255,7 @@ private: // A '[' could be an index subscript (after an identifier or after // ')' or ']'), it could be the start of an Objective-C method - // expression, or it could the the start of an Objective-C array literal. + // expression, or it could the start of an Objective-C array literal. FormatToken *Left = CurrentToken->Previous; Left->ParentBracket = Contexts.back().ContextKind; FormatToken *Parent = Left->getPreviousNonComment(); @@ -457,7 +457,7 @@ private: if (Contexts.back().ColonIsDictLiteral) { Tok->Type = TT_DictLiteral; } else if (Contexts.back().ColonIsObjCMethodExpr || - Line.First->is(TT_ObjCMethodSpecifier)) { + Line.startsWith(TT_ObjCMethodSpecifier)) { Tok->Type = TT_ObjCMethodExpr; Tok->Previous->Type = TT_SelectorName; if (Tok->Previous->ColumnWidth > @@ -503,7 +503,7 @@ private: if (!parseParens()) return false; if (Line.MustBeDeclaration && Contexts.size() == 1 && - !Contexts.back().IsExpression && Line.First->isNot(TT_ObjCProperty) && + !Contexts.back().IsExpression && !Line.startsWith(TT_ObjCProperty) && (!Tok->Previous || !Tok->Previous->isOneOf(tok::kw_decltype, TT_LeadingJavaAnnotation))) Line.MightBeFunctionDecl = true; @@ -558,7 +558,7 @@ private: break; case tok::question: if (Style.Language == FormatStyle::LK_JavaScript && Tok->Next && - Tok->Next->isOneOf(tok::semi, tok::colon, tok::r_paren, + Tok->Next->isOneOf(tok::semi, tok::comma, tok::colon, tok::r_paren, tok::r_brace)) { // Question marks before semicolons, colons, etc. indicate optional // types (fields, parameters), e.g. @@ -581,7 +581,7 @@ private: if (Contexts.back().InCtorInitializer) Tok->Type = TT_CtorInitializerComma; else if (Contexts.back().FirstStartOfName && - (Contexts.size() == 1 || Line.First->is(tok::kw_for))) { + (Contexts.size() == 1 || Line.startsWith(tok::kw_for))) { Contexts.back().FirstStartOfName->PartOfMultiVariableDeclStmt = true; Line.IsMultiVariableDeclStmt = true; } @@ -724,7 +724,7 @@ public: if (ImportStatement) return LT_ImportStatement; - if (Line.First->is(TT_ObjCMethodSpecifier)) { + if (Line.startsWith(TT_ObjCMethodSpecifier)) { if (Contexts.back().FirstObjCSelectorName) Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = Contexts.back().LongestObjCSelectorName; @@ -820,7 +820,7 @@ private: !Line.First->isOneOf(tok::kw_template, tok::kw_using) && (!Current.Previous || Current.Previous->isNot(tok::kw_operator))) { Contexts.back().IsExpression = true; - if (!Line.First->is(TT_UnaryOperator)) { + if (!Line.startsWith(TT_UnaryOperator)) { for (FormatToken *Previous = Current.Previous; Previous && !Previous->isOneOf(tok::comma, tok::semi); Previous = Previous->Previous) { @@ -870,7 +870,7 @@ private: Contexts.back().InCtorInitializer = true; } else if (Current.is(tok::kw_new)) { Contexts.back().CanBeExpression = false; - } else if (Current.is(tok::semi) || Current.is(tok::exclaim)) { + } else if (Current.isOneOf(tok::semi, tok::exclaim)) { // This should be the condition or increment in a for-loop. Contexts.back().IsExpression = true; } @@ -1081,7 +1081,7 @@ private: // there is also an identifier before the (). else if (LeftOfParens && Tok.Next && (LeftOfParens->Tok.getIdentifierInfo() == nullptr || - LeftOfParens->is(tok::kw_return)) && + LeftOfParens->isOneOf(tok::kw_return, tok::kw_case)) && !LeftOfParens->isOneOf(TT_OverloadedOperator, tok::at, TT_TemplateCloser)) { if (Tok.Next->isOneOf(tok::identifier, tok::numeric_constant)) { @@ -1441,11 +1441,11 @@ void TokenAnnotator::annotate(AnnotatedLine &Line) { ExpressionParser ExprParser(Style, Keywords, Line); ExprParser.parse(); - if (Line.First->is(TT_ObjCMethodSpecifier)) + if (Line.startsWith(TT_ObjCMethodSpecifier)) Line.Type = LT_ObjCMethodDecl; - else if (Line.First->is(TT_ObjCDecl)) + else if (Line.startsWith(TT_ObjCDecl)) Line.Type = LT_ObjCDecl; - else if (Line.First->is(TT_ObjCProperty)) + else if (Line.startsWith(TT_ObjCProperty)) Line.Type = LT_ObjCProperty; Line.First->SpacesRequiredBefore = 1; @@ -1638,7 +1638,7 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, if (Right.isOneOf(TT_StartOfName, TT_FunctionDeclarationName) || Right.is(tok::kw_operator)) { - if (Line.First->is(tok::kw_for) && Right.PartOfMultiVariableDeclStmt) + if (Line.startsWith(tok::kw_for) && Right.PartOfMultiVariableDeclStmt) return 3; if (Left.is(TT_StartOfName)) return 110; @@ -1674,8 +1674,7 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, (!Right.Next || Right.Next->isNot(tok::l_paren))) { // Moving trailing annotations to the next line is fine for ObjC method // declarations. - if (Line.First->is(TT_ObjCMethodSpecifier)) - + if (Line.startsWith(TT_ObjCMethodSpecifier)) return 10; // Generally, breaking before a trailing annotation is bad unless it is // function-like. It seems to be especially preferable to keep standard @@ -1687,7 +1686,7 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, } // In for-loops, prefer breaking at ',' and ';'. - if (Line.First->is(tok::kw_for) && Left.is(tok::equal)) + if (Line.startsWith(tok::kw_for) && Left.is(tok::equal)) return 4; // In Objective-C method expressions, prefer breaking before "param:" over @@ -1800,6 +1799,7 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, return true; if (Left.is(TT_PointerOrReference)) return Right.Tok.isLiteral() || Right.is(TT_BlockComment) || + (Right.is(tok::l_brace) && Right.BlockKind == BK_Block) || (!Right.isOneOf(TT_PointerOrReference, TT_ArraySubscriptLSquare, tok::l_paren) && (Style.PointerAlignment != FormatStyle::PAS_Right && @@ -1844,7 +1844,8 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, tok::kw_new, tok::kw_delete) && (!Left.Previous || Left.Previous->isNot(tok::period))))) || (Style.SpaceBeforeParens == FormatStyle::SBPO_Always && - (Left.is(tok::identifier) || Left.isFunctionLikeKeyword() || Left.is(tok::r_paren)) && + (Left.is(tok::identifier) || Left.isFunctionLikeKeyword() || + Left.is(tok::r_paren)) && Line.Type != LT_PreprocessorDirective); } if (Left.is(tok::at) && Right.Tok.getObjCKeywordID() != tok::objc_not_keyword) @@ -1989,7 +1990,7 @@ bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, Left.MatchingParen && Left.MatchingParen->is(TT_OverloadedOperatorLParen)) return false; if (Right.is(tok::less) && Left.isNot(tok::l_paren) && - Line.First->is(tok::hash)) + Line.startsWith(tok::hash)) return true; if (Right.is(TT_TrailingUnaryOperator)) return false; @@ -2010,6 +2011,39 @@ bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line, if (Right.NewlinesBefore > 1) return true; + if (Style.Language == FormatStyle::LK_JavaScript) { + // FIXME: This might apply to other languages and token kinds. + if (Right.is(tok::char_constant) && Left.is(tok::plus) && Left.Previous && + Left.Previous->is(tok::char_constant)) + return true; + if (Left.is(TT_DictLiteral) && Left.is(tok::l_brace) && Line.Level == 0 && + Left.Previous && Left.Previous->is(tok::equal) && + Line.First->isOneOf(tok::identifier, Keywords.kw_import, tok::kw_export, + tok::kw_const) && + // kw_var is a pseudo-token that's a tok::identifier, so matches above. + !Line.startsWith(Keywords.kw_var)) + // Object literals on the top level of a file are treated as "enum-style". + // Each key/value pair is put on a separate line, instead of bin-packing. + return true; + if (Left.is(tok::l_brace) && Line.Level == 0 && + (Line.startsWith(tok::kw_enum) || + Line.startsWith(tok::kw_export, tok::kw_enum))) + // JavaScript top-level enum key/value pairs are put on separate lines + // instead of bin-packing. + return true; + if (Right.is(tok::r_brace) && Left.is(tok::l_brace) && + !Left.Children.empty()) + // Support AllowShortFunctionsOnASingleLine for JavaScript. + return Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_None || + (Left.NestingLevel == 0 && Line.Level == 0 && + Style.AllowShortFunctionsOnASingleLine == + FormatStyle::SFS_Inline); + } else if (Style.Language == FormatStyle::LK_Java) { + if (Right.is(tok::plus) && Left.is(tok::string_literal) && Right.Next && + Right.Next->is(tok::string_literal)) + return true; + } + // If the last token before a '}' is a comma or a trailing comment, the // intention is to insert a line break after it in order to make shuffling // around entries easier. @@ -2030,7 +2064,7 @@ bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line, Left.isNot(TT_CtorInitializerColon) && (Right.NewlinesBefore > 0 && Right.HasUnescapedNewline); if (Left.isTrailingComment()) - return true; + return true; if (Left.isStringLiteral() && (Right.isStringLiteral() || Right.is(TT_ObjCStringLiteral))) return true; @@ -2060,12 +2094,6 @@ bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line, return true; if (Right.is(TT_InlineASMBrace)) return Right.HasUnescapedNewline; - if (Style.Language == FormatStyle::LK_JavaScript && Right.is(tok::r_brace) && - Left.is(tok::l_brace) && !Left.Children.empty()) - // Support AllowShortFunctionsOnASingleLine for JavaScript. - return Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_None || - (Left.NestingLevel == 0 && Line.Level == 0 && - Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_Inline); if (isAllmanBrace(Left) || isAllmanBrace(Right)) return Style.BreakBeforeBraces == FormatStyle::BS_Allman || Style.BreakBeforeBraces == FormatStyle::BS_GNU; @@ -2082,26 +2110,6 @@ bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line, Line.Last->is(tok::l_brace)) return true; - if (Style.Language == FormatStyle::LK_JavaScript) { - // FIXME: This might apply to other languages and token kinds. - if (Right.is(tok::char_constant) && Left.is(tok::plus) && Left.Previous && - Left.Previous->is(tok::char_constant)) - return true; - if (Left.is(TT_DictLiteral) && Left.is(tok::l_brace) && - Left.NestingLevel == 0 && Left.Previous && - Left.Previous->is(tok::equal) && - Line.First->isOneOf(tok::identifier, Keywords.kw_import, - tok::kw_export) && - // kw_var is a pseudo-token that's a tok::identifier, so matches above. - !Line.First->is(Keywords.kw_var)) - // Enum style object literal. - return true; - } else if (Style.Language == FormatStyle::LK_Java) { - if (Right.is(tok::plus) && Left.is(tok::string_literal) && Right.Next && - Right.Next->is(tok::string_literal)) - return true; - } - return false; } diff --git a/lib/Format/TokenAnnotator.h b/lib/Format/TokenAnnotator.h index a948cdb1c419..b8a6be057a6c 100644 --- a/lib/Format/TokenAnnotator.h +++ b/lib/Format/TokenAnnotator.h @@ -59,7 +59,7 @@ public: I->Tok->Previous = Current; Current = Current->Next; Current->Children.clear(); - for (const auto& Child : Node.Children) { + for (const auto &Child : Node.Children) { Children.push_back(new AnnotatedLine(Child)); Current->Children.push_back(Children.back()); } @@ -80,6 +80,12 @@ public: } } + /// \c true if this line starts with the given tokens in order, ignoring + /// comments. + template <typename... Ts> bool startsWith(Ts... Tokens) const { + return startsWith(First, Tokens...); + } + FormatToken *First; FormatToken *Last; @@ -107,6 +113,18 @@ private: // Disallow copying. AnnotatedLine(const AnnotatedLine &) = delete; void operator=(const AnnotatedLine &) = delete; + + template <typename A, typename... Ts> + bool startsWith(FormatToken *Tok, A K1) const { + while (Tok && Tok->is(tok::comment)) + Tok = Tok->Next; + return Tok && Tok->is(K1); + } + + template <typename A, typename... Ts> + bool startsWith(FormatToken *Tok, A K1, Ts... Tokens) const { + return startsWith(Tok, K1) && startsWith(Tok->Next, Tokens...); + } }; /// \brief Determines extra information about the tokens comprising an diff --git a/lib/Format/UnwrappedLineFormatter.cpp b/lib/Format/UnwrappedLineFormatter.cpp index cbf8c6c92211..b6784b369edf 100644 --- a/lib/Format/UnwrappedLineFormatter.cpp +++ b/lib/Format/UnwrappedLineFormatter.cpp @@ -21,7 +21,7 @@ namespace { bool startsExternCBlock(const AnnotatedLine &Line) { const FormatToken *Next = Line.First->getNextNonComment(); const FormatToken *NextNext = Next ? Next->getNextNonComment() : nullptr; - return Line.First->is(tok::kw_extern) && Next && Next->isStringLiteral() && + return Line.startsWith(tok::kw_extern) && Next && Next->isStringLiteral() && NextNext && NextNext->is(tok::l_brace); } @@ -51,11 +51,13 @@ public: /// next. void nextLine(const AnnotatedLine &Line) { Offset = getIndentOffset(*Line.First); + // Update the indent level cache size so that we can rely on it + // having the right size in adjustToUnmodifiedline. + while (IndentForLevel.size() <= Line.Level) + IndentForLevel.push_back(-1); if (Line.InPPDirective) { Indent = Line.Level * Style.IndentWidth + AdditionalIndent; } else { - while (IndentForLevel.size() <= Line.Level) - IndentForLevel.push_back(-1); IndentForLevel.resize(Line.Level + 1); Indent = getIndent(IndentForLevel, Line.Level); } @@ -72,7 +74,7 @@ public: unsigned LevelIndent = Line.First->OriginalColumn; if (static_cast<int>(LevelIndent) - Offset >= 0) LevelIndent -= Offset; - if ((Line.First->isNot(tok::comment) || IndentForLevel[Line.Level] == -1) && + if ((!Line.First->is(tok::comment) || IndentForLevel[Line.Level] == -1) && !Line.InPPDirective) IndentForLevel[Line.Level] = LevelIndent; } @@ -187,7 +189,7 @@ private: // If necessary, change to something smarter. bool MergeShortFunctions = Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_All || - (Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_Empty && + (Style.AllowShortFunctionsOnASingleLine >= FormatStyle::SFS_Empty && I[1]->First->is(tok::r_brace)) || (Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_Inline && TheLine->Level != 0); @@ -278,7 +280,7 @@ private: TT_LineComment)) return 0; // Only inline simple if's (no nested if or else). - if (I + 2 != E && Line.First->is(tok::kw_if) && + if (I + 2 != E && Line.startsWith(tok::kw_if) && I[2]->First->is(tok::kw_else)) return 0; return 1; @@ -332,12 +334,11 @@ private: return 0; if (Line.First->isOneOf(tok::kw_if, tok::kw_while, tok::kw_do, tok::kw_try, tok::kw___try, tok::kw_catch, tok::kw___finally, - tok::kw_for, tok::r_brace) || - Line.First->is(Keywords.kw___except)) { + tok::kw_for, tok::r_brace, Keywords.kw___except)) { if (!Style.AllowShortBlocksOnASingleLine) return 0; if (!Style.AllowShortIfStatementsOnASingleLine && - Line.First->is(tok::kw_if)) + Line.startsWith(tok::kw_if)) return 0; if (!Style.AllowShortLoopsOnASingleLine && Line.First->isOneOf(tok::kw_while, tok::kw_do, tok::kw_for)) @@ -360,7 +361,7 @@ private: Tok->SpacesRequiredBefore = 0; Tok->CanBreakBefore = true; return 1; - } else if (Limit != 0 && Line.First->isNot(tok::kw_namespace) && + } else if (Limit != 0 && !Line.startsWith(tok::kw_namespace) && !startsExternCBlock(Line)) { // We don't merge short records. if (Line.First->isOneOf(tok::kw_class, tok::kw_union, tok::kw_struct, @@ -444,9 +445,9 @@ private: const FormatStyle &Style; const AdditionalKeywords &Keywords; - const SmallVectorImpl<AnnotatedLine*>::const_iterator End; + const SmallVectorImpl<AnnotatedLine *>::const_iterator End; - SmallVectorImpl<AnnotatedLine*>::const_iterator Next; + SmallVectorImpl<AnnotatedLine *>::const_iterator Next; }; static void markFinalized(FormatToken *Tok) { diff --git a/lib/Format/UnwrappedLineFormatter.h b/lib/Format/UnwrappedLineFormatter.h index da9aa1c605e4..478617d6a88e 100644 --- a/lib/Format/UnwrappedLineFormatter.h +++ b/lib/Format/UnwrappedLineFormatter.h @@ -52,7 +52,8 @@ private: /// \brief Returns the column limit for a line, taking into account whether we /// need an escaped newline due to a continued preprocessor directive. - unsigned getColumnLimit(bool InPPDirective, const AnnotatedLine *NextLine) const; + unsigned getColumnLimit(bool InPPDirective, + const AnnotatedLine *NextLine) const; // Cache to store the penalty of formatting a vector of AnnotatedLines // starting from a specific additional offset. Improves performance if there diff --git a/lib/Format/UnwrappedLineParser.cpp b/lib/Format/UnwrappedLineParser.cpp index 6ad43294ca97..ea1ca39870e0 100644 --- a/lib/Format/UnwrappedLineParser.cpp +++ b/lib/Format/UnwrappedLineParser.cpp @@ -251,7 +251,6 @@ void UnwrappedLineParser::parse() { assert(PPLevelBranchIndex.back() <= PPLevelBranchCount.back()); } } while (!PPLevelBranchIndex.empty()); - } void UnwrappedLineParser::parseFile() { @@ -774,7 +773,15 @@ void UnwrappedLineParser::parseStructuralElement() { parseBracedList(); break; case tok::kw_enum: + // parseEnum falls through and does not yet add an unwrapped line as an + // enum definition can start a structural element. parseEnum(); + // This does not apply for Java and JavaScript. + if (Style.Language == FormatStyle::LK_Java || + Style.Language == FormatStyle::LK_JavaScript) { + addUnwrappedLine(); + return; + } break; case tok::kw_typedef: nextToken(); @@ -785,9 +792,15 @@ void UnwrappedLineParser::parseStructuralElement() { case tok::kw_struct: case tok::kw_union: case tok::kw_class: + // parseRecord falls through and does not yet add an unwrapped line as a + // record declaration or definition can start a structural element. parseRecord(); - // A record declaration or definition is always the start of a structural - // element. + // This does not apply for Java and JavaScript. + if (Style.Language == FormatStyle::LK_Java || + Style.Language == FormatStyle::LK_JavaScript) { + addUnwrappedLine(); + return; + } break; case tok::period: nextToken(); @@ -848,6 +861,7 @@ void UnwrappedLineParser::parseStructuralElement() { Style.Language == FormatStyle::LK_Java) && FormatTok->is(Keywords.kw_interface)) { parseRecord(); + addUnwrappedLine(); break; } @@ -872,8 +886,7 @@ void UnwrappedLineParser::parseStructuralElement() { ? FormatTok->NewlinesBefore > 0 : CommentsBeforeNextToken.front()->NewlinesBefore > 0; - if (FollowedByNewline && - (Text.size() >= 5 || FunctionLike) && + if (FollowedByNewline && (Text.size() >= 5 || FunctionLike) && tokenCanStartNewLine(FormatTok->Tok) && Text == Text.upper()) { addUnwrappedLine(); return; @@ -1033,7 +1046,7 @@ void UnwrappedLineParser::tryToParseJSFunction() { if (FormatTok->is(tok::l_brace)) tryToParseBracedList(); else - while(FormatTok->isNot(tok::l_brace) && !eof()) + while (FormatTok->isNot(tok::l_brace) && !eof()) nextToken(); } @@ -1066,7 +1079,7 @@ bool UnwrappedLineParser::parseBracedList(bool ContinueOnSemicolons) { nextToken(); // Fat arrows can be followed by simple expressions or by child blocks // in curly braces. - if (FormatTok->is(tok::l_brace)){ + if (FormatTok->is(tok::l_brace)) { parseChildBlock(); continue; } @@ -1475,6 +1488,7 @@ void UnwrappedLineParser::parseEnum() { // Eat up enum class ... if (FormatTok->Tok.is(tok::kw_class) || FormatTok->Tok.is(tok::kw_struct)) nextToken(); + while (FormatTok->Tok.getIdentifierInfo() || FormatTok->isOneOf(tok::colon, tok::coloncolon, tok::less, tok::greater, tok::comma, tok::question)) { @@ -1482,8 +1496,14 @@ void UnwrappedLineParser::parseEnum() { // We can have macros or attributes in between 'enum' and the enum name. if (FormatTok->is(tok::l_paren)) parseParens(); - if (FormatTok->is(tok::identifier)) + if (FormatTok->is(tok::identifier)) { nextToken(); + // If there are two identifiers in a row, this is likely an elaborate + // return type. In Java, this can be "implements", etc. + if (Style.Language == FormatStyle::LK_Cpp && + FormatTok->is(tok::identifier)) + return; + } } // Just a declaration or something is wrong. @@ -1505,8 +1525,8 @@ void UnwrappedLineParser::parseEnum() { addUnwrappedLine(); } - // We fall through to parsing a structural element afterwards, so that in - // enum A {} n, m; + // There is no addUnwrappedLine() here so that we fall through to parsing a + // structural element afterwards. Thus, in "enum A {} n, m;", // "} n, m;" will end up in one unwrapped line. } @@ -1576,7 +1596,6 @@ void UnwrappedLineParser::parseRecord() { const FormatToken &InitialToken = *FormatTok; nextToken(); - // The actual identifier can be a nested name specifier, and in macros // it is often token-pasted. while (FormatTok->isOneOf(tok::identifier, tok::coloncolon, tok::hashhash, @@ -1623,13 +1642,9 @@ void UnwrappedLineParser::parseRecord() { parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/true, /*MunchSemi=*/false); } - // We fall through to parsing a structural element afterwards, so - // class A {} n, m; - // will end up in one unwrapped line. - // This does not apply for Java and JavaScript. - if (Style.Language == FormatStyle::LK_Java || - Style.Language == FormatStyle::LK_JavaScript) - addUnwrappedLine(); + // There is no addUnwrappedLine() here so that we fall through to parsing a + // structural element afterwards. Thus, in "class A {} n, m;", + // "} n, m;" will end up in one unwrapped line. } void UnwrappedLineParser::parseObjCProtocolList() { @@ -1722,7 +1737,8 @@ void UnwrappedLineParser::parseJavaScriptEs6ImportExport() { return; } - if (FormatTok->isOneOf(tok::kw_const, tok::kw_class, Keywords.kw_var)) + if (FormatTok->isOneOf(tok::kw_const, tok::kw_class, tok::kw_enum, + Keywords.kw_var)) return; // Fall through to parsing the corresponding structure. if (FormatTok->is(tok::l_brace)) { diff --git a/lib/Format/WhitespaceManager.h b/lib/Format/WhitespaceManager.h index 4bfc813b2c34..d97383832981 100644 --- a/lib/Format/WhitespaceManager.h +++ b/lib/Format/WhitespaceManager.h @@ -167,9 +167,11 @@ private: /// \brief Align consecutive assignments over all \c Changes. void alignConsecutiveAssignments(); - /// \brief Align consecutive assignments from change \p Start to change \p End at + /// \brief Align consecutive assignments from change \p Start to change \p End + /// at /// the specified \p Column. - void alignConsecutiveAssignments(unsigned Start, unsigned End, unsigned Column); + void alignConsecutiveAssignments(unsigned Start, unsigned End, + unsigned Column); /// \brief Align trailing comments over all \c Changes. void alignTrailingComments(); diff --git a/lib/Frontend/ASTMerge.cpp b/lib/Frontend/ASTMerge.cpp index b84df94ef806..f6f1551b4235 100644 --- a/lib/Frontend/ASTMerge.cpp +++ b/lib/Frontend/ASTMerge.cpp @@ -45,8 +45,10 @@ void ASTMergeAction::ExecuteAction() { new ForwardingDiagnosticConsumer( *CI.getDiagnostics().getClient()), /*ShouldOwnClient=*/true)); - std::unique_ptr<ASTUnit> Unit = ASTUnit::LoadFromASTFile( - ASTFiles[I], Diags, CI.getFileSystemOpts(), false); + std::unique_ptr<ASTUnit> Unit = + ASTUnit::LoadFromASTFile(ASTFiles[I], CI.getPCHContainerOperations(), + Diags, CI.getFileSystemOpts(), false); + if (!Unit) continue; diff --git a/lib/Frontend/ASTUnit.cpp b/lib/Frontend/ASTUnit.cpp index 4fd330d44b77..01c56bdc4df9 100644 --- a/lib/Frontend/ASTUnit.cpp +++ b/lib/Frontend/ASTUnit.cpp @@ -648,7 +648,9 @@ void ASTUnit::ConfigureDiags(IntrusiveRefCntPtr<DiagnosticsEngine> Diags, } std::unique_ptr<ASTUnit> ASTUnit::LoadFromASTFile( - const std::string &Filename, IntrusiveRefCntPtr<DiagnosticsEngine> Diags, + const std::string &Filename, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + IntrusiveRefCntPtr<DiagnosticsEngine> Diags, const FileSystemOptions &FileSystemOpts, bool OnlyLocalDecls, ArrayRef<RemappedFile> RemappedFiles, bool CaptureDiagnostics, bool AllowPCHWithCompilerErrors, bool UserFilesAreVolatile) { @@ -705,10 +707,10 @@ std::unique_ptr<ASTUnit> ASTUnit::LoadFromASTFile( bool disableValid = false; if (::getenv("LIBCLANG_DISABLE_PCH_VALIDATION")) disableValid = true; - AST->Reader = new ASTReader(PP, Context, - /*isysroot=*/"", - /*DisableValidation=*/disableValid, - AllowPCHWithCompilerErrors); + AST->Reader = new ASTReader(PP, Context, *PCHContainerOps, + /*isysroot=*/"", + /*DisableValidation=*/disableValid, + AllowPCHWithCompilerErrors); AST->Reader->setListener(llvm::make_unique<ASTInfoCollector>( *AST->PP, Context, AST->ASTFileLangOpts, AST->TargetOpts, AST->Target, @@ -916,13 +918,16 @@ class PrecompilePreambleConsumer : public PCHGenerator { unsigned &Hash; std::vector<Decl *> TopLevelDecls; PrecompilePreambleAction *Action; + raw_ostream *Out; public: PrecompilePreambleConsumer(ASTUnit &Unit, PrecompilePreambleAction *Action, const Preprocessor &PP, StringRef isysroot, raw_ostream *Out) - : PCHGenerator(PP, "", nullptr, isysroot, Out, /*AllowASTWithErrors=*/true), - Unit(Unit), Hash(Unit.getCurrentTopLevelHashValue()), Action(Action) { + : PCHGenerator(PP, "", nullptr, isysroot, std::make_shared<PCHBuffer>(), + /*AllowASTWithErrors=*/true), + Unit(Unit), Hash(Unit.getCurrentTopLevelHashValue()), Action(Action), + Out(Out) { Hash = 0; } @@ -943,6 +948,14 @@ public: void HandleTranslationUnit(ASTContext &Ctx) override { PCHGenerator::HandleTranslationUnit(Ctx); if (hasEmittedPCH()) { + // Write the generated bitstream to "Out". + *Out << getPCH(); + // Make sure it hits disk now. + Out->flush(); + // Free the buffer. + llvm::SmallVector<char, 0> Empty; + getPCH() = std::move(Empty); + // Translate the top-level declarations we captured during // parsing into declaration IDs in the precompiled // preamble. This will allow us to deserialize those top-level @@ -1015,14 +1028,16 @@ static void checkAndSanitizeDiags(SmallVectorImpl<StoredDiagnostic> & /// /// \returns True if a failure occurred that causes the ASTUnit not to /// contain any translation-unit information, false otherwise. -bool ASTUnit::Parse(std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer) { +bool ASTUnit::Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps, + std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer) { SavedMainFileBuffer.reset(); if (!Invocation) return true; // Create the compiler instance to use for building the AST. - std::unique_ptr<CompilerInstance> Clang(new CompilerInstance()); + std::unique_ptr<CompilerInstance> Clang( + new CompilerInstance(PCHContainerOps)); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> @@ -1323,6 +1338,7 @@ makeStandaloneDiagnostic(const LangOptions &LangOpts, /// Otherwise, returns a NULL pointer. std::unique_ptr<llvm::MemoryBuffer> ASTUnit::getMainBufferWithPrecompiledPreamble( + std::shared_ptr<PCHContainerOperations> PCHContainerOps, const CompilerInvocation &PreambleInvocationIn, bool AllowRebuild, unsigned MaxLines) { @@ -1487,7 +1503,8 @@ ASTUnit::getMainBufferWithPrecompiledPreamble( PreprocessorOpts.PrecompiledPreambleBytes.second = false; // Create the compiler instance to use for building the precompiled preamble. - std::unique_ptr<CompilerInstance> Clang(new CompilerInstance()); + std::unique_ptr<CompilerInstance> Clang( + new CompilerInstance(PCHContainerOps)); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> @@ -1702,12 +1719,13 @@ ASTUnit *ASTUnit::create(CompilerInvocation *CI, } ASTUnit *ASTUnit::LoadFromCompilerInvocationAction( - CompilerInvocation *CI, IntrusiveRefCntPtr<DiagnosticsEngine> Diags, - ASTFrontendAction *Action, ASTUnit *Unit, bool Persistent, - StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, - bool PrecompilePreamble, bool CacheCodeCompletionResults, - bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile, - std::unique_ptr<ASTUnit> *ErrAST) { + CompilerInvocation *CI, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + IntrusiveRefCntPtr<DiagnosticsEngine> Diags, ASTFrontendAction *Action, + ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath, + bool OnlyLocalDecls, bool CaptureDiagnostics, bool PrecompilePreamble, + bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, + bool UserFilesAreVolatile, std::unique_ptr<ASTUnit> *ErrAST) { assert(CI && "A CompilerInvocation is required"); std::unique_ptr<ASTUnit> OwnAST; @@ -1746,7 +1764,8 @@ ASTUnit *ASTUnit::LoadFromCompilerInvocationAction( ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts()); // Create the compiler instance to use for building the AST. - std::unique_ptr<CompilerInstance> Clang(new CompilerInstance()); + std::unique_ptr<CompilerInstance> Clang( + new CompilerInstance(PCHContainerOps)); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> @@ -1841,7 +1860,9 @@ ASTUnit *ASTUnit::LoadFromCompilerInvocationAction( return AST; } -bool ASTUnit::LoadFromCompilerInvocation(bool PrecompilePreamble) { +bool ASTUnit::LoadFromCompilerInvocation( + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + bool PrecompilePreamble) { if (!Invocation) return true; @@ -1853,7 +1874,8 @@ bool ASTUnit::LoadFromCompilerInvocation(bool PrecompilePreamble) { std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer; if (PrecompilePreamble) { PreambleRebuildCounter = 2; - OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation); + OverrideMainBuffer = + getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation); } SimpleTimer ParsingTimer(WantTiming); @@ -1863,12 +1885,14 @@ bool ASTUnit::LoadFromCompilerInvocation(bool PrecompilePreamble) { llvm::CrashRecoveryContextCleanupRegistrar<llvm::MemoryBuffer> MemBufferCleanup(OverrideMainBuffer.get()); - return Parse(std::move(OverrideMainBuffer)); + return Parse(PCHContainerOps, std::move(OverrideMainBuffer)); } std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation( - CompilerInvocation *CI, IntrusiveRefCntPtr<DiagnosticsEngine> Diags, - bool OnlyLocalDecls, bool CaptureDiagnostics, bool PrecompilePreamble, + CompilerInvocation *CI, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + IntrusiveRefCntPtr<DiagnosticsEngine> Diags, bool OnlyLocalDecls, + bool CaptureDiagnostics, bool PrecompilePreamble, TranslationUnitKind TUKind, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile) { // Create the AST unit. @@ -1897,13 +1921,14 @@ std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation( llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> > DiagCleanup(Diags.get()); - if (AST->LoadFromCompilerInvocation(PrecompilePreamble)) + if (AST->LoadFromCompilerInvocation(PCHContainerOps, PrecompilePreamble)) return nullptr; return AST; } ASTUnit *ASTUnit::LoadFromCommandLine( const char **ArgBegin, const char **ArgEnd, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, IntrusiveRefCntPtr<DiagnosticsEngine> Diags, StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, ArrayRef<RemappedFile> RemappedFiles, bool RemappedFilesKeepOriginalName, @@ -1975,7 +2000,7 @@ ASTUnit *ASTUnit::LoadFromCommandLine( llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit> ASTUnitCleanup(AST.get()); - if (AST->LoadFromCompilerInvocation(PrecompilePreamble)) { + if (AST->LoadFromCompilerInvocation(PCHContainerOps, PrecompilePreamble)) { // Some error occurred, if caller wants to examine diagnostics, pass it the // ASTUnit. if (ErrAST) { @@ -1988,7 +2013,8 @@ ASTUnit *ASTUnit::LoadFromCommandLine( return AST.release(); } -bool ASTUnit::Reparse(ArrayRef<RemappedFile> RemappedFiles) { +bool ASTUnit::Reparse(std::shared_ptr<PCHContainerOperations> PCHContainerOps, + ArrayRef<RemappedFile> RemappedFiles) { if (!Invocation) return true; @@ -2012,8 +2038,9 @@ bool ASTUnit::Reparse(ArrayRef<RemappedFile> RemappedFiles) { // build a precompiled preamble, do so now. std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer; if (!getPreambleFile(this).empty() || PreambleRebuildCounter > 0) - OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation); - + OverrideMainBuffer = + getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation); + // Clear out the diagnostics state. getDiagnostics().Reset(); ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts()); @@ -2021,7 +2048,7 @@ bool ASTUnit::Reparse(ArrayRef<RemappedFile> RemappedFiles) { getDiagnostics().setNumWarnings(NumWarningsInPreamble); // Parse the sources - bool Result = Parse(std::move(OverrideMainBuffer)); + bool Result = Parse(PCHContainerOps, std::move(OverrideMainBuffer)); // If we're caching global code-completion results, and the top-level // declarations have changed, clear out the code-completion cache. @@ -2273,18 +2300,15 @@ void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S, AllResults.size()); } - - -void ASTUnit::CodeComplete(StringRef File, unsigned Line, unsigned Column, - ArrayRef<RemappedFile> RemappedFiles, - bool IncludeMacros, - bool IncludeCodePatterns, - bool IncludeBriefComments, - CodeCompleteConsumer &Consumer, - DiagnosticsEngine &Diag, LangOptions &LangOpts, - SourceManager &SourceMgr, FileManager &FileMgr, - SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics, - SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers) { +void ASTUnit::CodeComplete( + StringRef File, unsigned Line, unsigned Column, + ArrayRef<RemappedFile> RemappedFiles, bool IncludeMacros, + bool IncludeCodePatterns, bool IncludeBriefComments, + CodeCompleteConsumer &Consumer, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + DiagnosticsEngine &Diag, LangOptions &LangOpts, SourceManager &SourceMgr, + FileManager &FileMgr, SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics, + SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers) { if (!Invocation) return; @@ -2318,7 +2342,8 @@ void ASTUnit::CodeComplete(StringRef File, unsigned Line, unsigned Column, LangOpts.SpellChecking = false; CCInvocation->getDiagnosticOpts().IgnoreWarnings = true; - std::unique_ptr<CompilerInstance> Clang(new CompilerInstance()); + std::unique_ptr<CompilerInstance> Clang( + new CompilerInstance(PCHContainerOps)); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> @@ -2389,7 +2414,7 @@ void ASTUnit::CodeComplete(StringRef File, unsigned Line, unsigned Column, if (!llvm::sys::fs::getUniqueID(MainPath, MainID)) { if (CompleteFileID == MainID && Line > 1) OverrideMainBuffer = getMainBufferWithPrecompiledPreamble( - *CCInvocation, false, Line - 1); + PCHContainerOps, *CCInvocation, false, Line - 1); } } } diff --git a/lib/Frontend/CMakeLists.txt b/lib/Frontend/CMakeLists.txt index 7c5fca54d1e1..9a3e459640a5 100644 --- a/lib/Frontend/CMakeLists.txt +++ b/lib/Frontend/CMakeLists.txt @@ -31,6 +31,7 @@ add_clang_library(clangFrontend LogDiagnosticPrinter.cpp ModuleDependencyCollector.cpp MultiplexConsumer.cpp + PCHContainerOperations.cpp PrintPreprocessedOutput.cpp SerializedDiagnosticPrinter.cpp SerializedDiagnosticReader.cpp diff --git a/lib/Frontend/ChainedIncludesSource.cpp b/lib/Frontend/ChainedIncludesSource.cpp index f3677f8000c6..be30d43a843e 100644 --- a/lib/Frontend/ChainedIncludesSource.cpp +++ b/lib/Frontend/ChainedIncludesSource.cpp @@ -80,8 +80,9 @@ createASTReader(CompilerInstance &CI, StringRef pchFile, ASTDeserializationListener *deserialListener = nullptr) { Preprocessor &PP = CI.getPreprocessor(); std::unique_ptr<ASTReader> Reader; - Reader.reset(new ASTReader(PP, CI.getASTContext(), /*isysroot=*/"", - /*DisableValidation=*/true)); + Reader.reset(new ASTReader(PP, CI.getASTContext(), + *CI.getPCHContainerOperations(), + /*isysroot=*/"", /*DisableValidation=*/true)); for (unsigned ti = 0; ti < bufNames.size(); ++ti) { StringRef sr(bufNames[ti]); Reader->addInMemoryBuffer(sr, std::move(MemBufs[ti])); @@ -145,7 +146,8 @@ IntrusiveRefCntPtr<ExternalSemaSource> clang::createChainedIncludesSource( IntrusiveRefCntPtr<DiagnosticsEngine> Diags( new DiagnosticsEngine(DiagID, &CI.getDiagnosticOpts(), DiagClient)); - std::unique_ptr<CompilerInstance> Clang(new CompilerInstance()); + std::unique_ptr<CompilerInstance> Clang( + new CompilerInstance(CI.getPCHContainerOperations())); Clang->setInvocation(CInvok.release()); Clang->setDiagnostics(Diags.get()); Clang->setTarget(TargetInfo::CreateTargetInfo( @@ -157,11 +159,9 @@ IntrusiveRefCntPtr<ExternalSemaSource> clang::createChainedIncludesSource( &Clang->getPreprocessor()); Clang->createASTContext(); - SmallVector<char, 256> serialAST; - llvm::raw_svector_ostream OS(serialAST); - auto consumer = - llvm::make_unique<PCHGenerator>(Clang->getPreprocessor(), "-", nullptr, - /*isysroot=*/"", &OS); + auto Buffer = std::make_shared<PCHBuffer>(); + auto consumer = llvm::make_unique<PCHGenerator>( + Clang->getPreprocessor(), "-", nullptr, /*isysroot=*/"", Buffer); Clang->getASTContext().setASTMutationListener( consumer->GetASTMutationListener()); Clang->setASTConsumer(std::move(consumer)); @@ -198,7 +198,11 @@ IntrusiveRefCntPtr<ExternalSemaSource> clang::createChainedIncludesSource( ParseAST(Clang->getSema()); Clang->getDiagnosticClient().EndSourceFile(); - SerialBufs.push_back(llvm::MemoryBuffer::getMemBufferCopy(OS.str())); + assert(Buffer->IsComplete && "serialization did not complete"); + auto &serialAST = Buffer->Data; + SerialBufs.push_back(llvm::MemoryBuffer::getMemBufferCopy( + StringRef(serialAST.data(), serialAST.size()))); + serialAST.clear(); source->CIs.push_back(Clang.release()); } diff --git a/lib/Frontend/CompilerInstance.cpp b/lib/Frontend/CompilerInstance.cpp index aef3905b328c..6b0fed676182 100644 --- a/lib/Frontend/CompilerInstance.cpp +++ b/lib/Frontend/CompilerInstance.cpp @@ -51,12 +51,13 @@ using namespace clang; -CompilerInstance::CompilerInstance(bool BuildingModule) - : ModuleLoader(BuildingModule), - Invocation(new CompilerInvocation()), ModuleManager(nullptr), - BuildGlobalModuleIndex(false), HaveFullGlobalModuleIndex(false), - ModuleBuildFailed(false) { -} +CompilerInstance::CompilerInstance( + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + bool BuildingModule) + : ModuleLoader(BuildingModule), Invocation(new CompilerInvocation()), + ModuleManager(nullptr), ThePCHContainerOperations(PCHContainerOps), + BuildGlobalModuleIndex(false), HaveFullGlobalModuleIndex(false), + ModuleBuildFailed(false) {} CompilerInstance::~CompilerInstance() { assert(OutputFiles.empty() && "Still output files in flight?"); @@ -321,7 +322,8 @@ void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) { PP->getFileManager(), PPOpts); // Predefine macros and configure the preprocessor. - InitializePreprocessor(*PP, PPOpts, getFrontendOpts()); + InitializePreprocessor(*PP, PPOpts, *getPCHContainerOperations(), + getFrontendOpts()); // Initialize the header search object. ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(), @@ -397,22 +399,24 @@ void CompilerInstance::createPCHExternalASTSource( ModuleManager = createPCHExternalASTSource( Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation, AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(), - DeserializationListener, OwnDeserializationListener, Preamble, + *getPCHContainerOperations(), DeserializationListener, + OwnDeserializationListener, Preamble, getFrontendOpts().UseGlobalModuleIndex); } IntrusiveRefCntPtr<ASTReader> CompilerInstance::createPCHExternalASTSource( StringRef Path, const std::string &Sysroot, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context, + const PCHContainerOperations &PCHContainerOps, void *DeserializationListener, bool OwnDeserializationListener, bool Preamble, bool UseGlobalModuleIndex) { HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts(); - IntrusiveRefCntPtr<ASTReader> Reader( - new ASTReader(PP, Context, Sysroot.empty() ? "" : Sysroot.c_str(), - DisablePCHValidation, AllowPCHWithCompilerErrors, - /*AllowConfigurationMismatch*/ false, - HSOpts.ModulesValidateSystemHeaders, UseGlobalModuleIndex)); + IntrusiveRefCntPtr<ASTReader> Reader(new ASTReader( + PP, Context, PCHContainerOps, Sysroot.empty() ? "" : Sysroot.c_str(), + DisablePCHValidation, AllowPCHWithCompilerErrors, + /*AllowConfigurationMismatch*/ false, HSOpts.ModulesValidateSystemHeaders, + UseGlobalModuleIndex)); // We need the external source to be set up before we read the AST, because // eagerly-deserialized declarations may use it. @@ -918,7 +922,8 @@ static bool compileModuleImpl(CompilerInstance &ImportingInstance, // Construct a compiler instance that will be used to actually create the // module. - CompilerInstance Instance(/*BuildingModule=*/true); + CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(), + /*BuildingModule=*/true); Instance.setInvocation(&*Invocation); Instance.createDiagnostics(new ForwardingDiagnosticConsumer( @@ -1232,13 +1237,13 @@ void CompilerInstance::createModuleManager() { HeaderSearchOptions &HSOpts = getHeaderSearchOpts(); std::string Sysroot = HSOpts.Sysroot; const PreprocessorOptions &PPOpts = getPreprocessorOpts(); - ModuleManager = new ASTReader(getPreprocessor(), *Context, - Sysroot.empty() ? "" : Sysroot.c_str(), - PPOpts.DisablePCHValidation, - /*AllowASTWithCompilerErrors=*/false, - /*AllowConfigurationMismatch=*/false, - HSOpts.ModulesValidateSystemHeaders, - getFrontendOpts().UseGlobalModuleIndex); + ModuleManager = new ASTReader( + getPreprocessor(), *Context, *getPCHContainerOperations(), + Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation, + /*AllowASTWithCompilerErrors=*/false, + /*AllowConfigurationMismatch=*/false, + HSOpts.ModulesValidateSystemHeaders, + getFrontendOpts().UseGlobalModuleIndex); if (hasASTConsumer()) { ModuleManager->setDeserializationListener( getASTConsumer().GetASTDeserializationListener()); @@ -1279,6 +1284,7 @@ bool CompilerInstance::loadModuleFile(StringRef FileName) { ModuleFileStack.push_back(FileName); ModuleNameStack.push_back(StringRef()); if (ASTReader::readASTFileControlBlock(FileName, CI.getFileManager(), + *CI.getPCHContainerOperations(), *this)) { CI.getDiagnostics().Report( SourceLocation(), CI.getFileManager().getBufferForFile(FileName) @@ -1644,8 +1650,8 @@ GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex( llvm::sys::fs::create_directories( getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); GlobalModuleIndex::writeIndex( - getFileManager(), - getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); + getFileManager(), *getPCHContainerOperations(), + getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); ModuleManager->resetForReload(); ModuleManager->loadGlobalIndex(); GlobalIndex = ModuleManager->getGlobalIndex(); @@ -1672,8 +1678,8 @@ GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex( } if (RecreateIndex) { GlobalModuleIndex::writeIndex( - getFileManager(), - getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); + getFileManager(), *getPCHContainerOperations(), + getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); ModuleManager->resetForReload(); ModuleManager->loadGlobalIndex(); GlobalIndex = ModuleManager->getGlobalIndex(); diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp index 4f7d15fa507f..85467631c943 100644 --- a/lib/Frontend/CompilerInvocation.cpp +++ b/lib/Frontend/CompilerInvocation.cpp @@ -321,6 +321,29 @@ GenerateOptimizationRemarkRegex(DiagnosticsEngine &Diags, ArgList &Args, return Pattern; } +static bool parseDiagnosticLevelMask(StringRef FlagName, + const std::vector<std::string> &Levels, + DiagnosticsEngine *Diags, + DiagnosticLevelMask &M) { + bool Success = true; + for (const auto &Level : Levels) { + DiagnosticLevelMask const PM = + llvm::StringSwitch<DiagnosticLevelMask>(Level) + .Case("note", DiagnosticLevelMask::Note) + .Case("remark", DiagnosticLevelMask::Remark) + .Case("warning", DiagnosticLevelMask::Warning) + .Case("error", DiagnosticLevelMask::Error) + .Default(DiagnosticLevelMask::None); + if (PM == DiagnosticLevelMask::None) { + Success = false; + if (Diags) + Diags->Report(diag::err_drv_invalid_value) << FlagName << Level; + } + M = M | PM; + } + return Success; +} + static void parseSanitizerKinds(StringRef FlagName, const std::vector<std::string> &Sanitizers, DiagnosticsEngine &Diags, SanitizerSet &S) { @@ -532,8 +555,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, Args.hasArg(OPT_fsanitize_coverage_8bit_counters); Opts.SanitizeMemoryTrackOrigins = getLastArgIntValue(Args, OPT_fsanitize_memory_track_origins_EQ, 0, Diags); - Opts.SanitizeUndefinedTrapOnError = - Args.hasArg(OPT_fsanitize_undefined_trap_on_error); Opts.SSPBufferSize = getLastArgIntValue(Args, OPT_stack_protector_buffer_size, 8, Diags); Opts.StackRealignment = Args.hasArg(OPT_mstackrealign); @@ -643,6 +664,9 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, parseSanitizerKinds("-fsanitize-recover=", Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags, Opts.SanitizeRecover); + parseSanitizerKinds("-fsanitize-trap=", + Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags, + Opts.SanitizeTrap); Opts.CudaGpuBinaryFileNames = Args.getAllArgValues(OPT_fcuda_include_gpubinary); @@ -748,11 +772,18 @@ bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args, << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args) << Format; } - + Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info); Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits); Opts.ShowPresumedLoc = !Args.hasArg(OPT_fno_diagnostics_use_presumed_location); Opts.VerifyDiagnostics = Args.hasArg(OPT_verify); + DiagnosticLevelMask DiagMask = DiagnosticLevelMask::None; + Success &= parseDiagnosticLevelMask("-verify-ignore-unexpected=", + Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), + Diags, DiagMask); + if (Args.hasArg(OPT_verify_ignore_unexpected)) + DiagMask = DiagnosticLevelMask::All; + Opts.setVerifyIgnoreUnexpected(DiagMask); Opts.ElideType = !Args.hasArg(OPT_fno_elide_type); Opts.ShowTemplateTree = Args.hasArg(OPT_fdiagnostics_show_template_tree); Opts.ErrorLimit = getLastArgIntValue(Args, OPT_ferror_limit, 0, Diags); @@ -1065,8 +1096,7 @@ static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args) { Opts.ModuleCachePath = Args.getLastArgValue(OPT_fmodules_cache_path); Opts.ModuleUserBuildPath = Args.getLastArgValue(OPT_fmodules_user_build_path); Opts.DisableModuleHash = Args.hasArg(OPT_fdisable_module_hash); - // -fmodules implies -fmodule-maps - Opts.ModuleMaps = Args.hasArg(OPT_fmodule_maps) || Args.hasArg(OPT_fmodules); + Opts.ImplicitModuleMaps = Args.hasArg(OPT_fimplicit_module_maps); Opts.ModuleMapFileHomeIsCwd = Args.hasArg(OPT_fmodule_map_file_home_is_cwd); Opts.ModuleCachePruneInterval = getLastArgIntValue(Args, OPT_fmodules_prune_interval, 7 * 24 * 60 * 60); @@ -1495,8 +1525,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, !Args.hasArg(OPT_fno_modules_search_all) && Args.hasArg(OPT_fmodules_search_all); Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery); - Opts.ModulesImplicitMaps = Args.hasFlag(OPT_fmodules_implicit_maps, - OPT_fno_modules_implicit_maps, true); Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules); Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char); Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar); @@ -1803,7 +1831,7 @@ static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args) { Opts.FeaturesAsWritten = Args.getAllArgValues(OPT_target_feature); Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version); Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple)); - + Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ); // Use the default target triple if unspecified. if (Opts.Triple.empty()) Opts.Triple = llvm::sys::getDefaultTargetTriple(); diff --git a/lib/Frontend/FrontendAction.cpp b/lib/Frontend/FrontendAction.cpp index 9bba75541ffb..db9dd3b09887 100644 --- a/lib/Frontend/FrontendAction.cpp +++ b/lib/Frontend/FrontendAction.cpp @@ -191,7 +191,8 @@ bool FrontendAction::BeginSourceFile(CompilerInstance &CI, IntrusiveRefCntPtr<DiagnosticsEngine> Diags(&CI.getDiagnostics()); std::unique_ptr<ASTUnit> AST = - ASTUnit::LoadFromASTFile(InputFile, Diags, CI.getFileSystemOpts()); + ASTUnit::LoadFromASTFile(InputFile, CI.getPCHContainerOperations(), + Diags, CI.getFileSystemOpts()); if (!AST) goto failure; @@ -271,11 +272,10 @@ bool FrontendAction::BeginSourceFile(CompilerInstance &CI, for (llvm::sys::fs::directory_iterator Dir(DirNative, EC), DirEnd; Dir != DirEnd && !EC; Dir.increment(EC)) { // Check whether this is an acceptable AST file. - if (ASTReader::isAcceptableASTFile(Dir->path(), FileMgr, - CI.getLangOpts(), - CI.getTargetOpts(), - CI.getPreprocessorOpts(), - SpecificModuleCachePath)) { + if (ASTReader::isAcceptableASTFile( + Dir->path(), FileMgr, *CI.getPCHContainerOperations(), + CI.getLangOpts(), CI.getTargetOpts(), CI.getPreprocessorOpts(), + SpecificModuleCachePath)) { PPOpts.ImplicitPCHInclude = Dir->path(); Found = true; break; @@ -443,8 +443,8 @@ bool FrontendAction::Execute() { if (CI.shouldBuildGlobalModuleIndex() && CI.hasFileManager() && CI.hasPreprocessor()) { GlobalModuleIndex::writeIndex( - CI.getFileManager(), - CI.getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); + CI.getFileManager(), *CI.getPCHContainerOperations(), + CI.getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); } return true; diff --git a/lib/Frontend/FrontendActions.cpp b/lib/Frontend/FrontendActions.cpp index 46cdeebfdbeb..6f202a15483a 100644 --- a/lib/Frontend/FrontendActions.cpp +++ b/lib/Frontend/FrontendActions.cpp @@ -14,6 +14,7 @@ #include "clang/Frontend/ASTUnit.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendDiagnostic.h" +#include "clang/Frontend/MultiplexConsumer.h" #include "clang/Frontend/Utils.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/Pragma.h" @@ -79,18 +80,28 @@ std::unique_ptr<ASTConsumer> GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { std::string Sysroot; std::string OutputFile; - raw_ostream *OS = + raw_pwrite_stream *OS = ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile); if (!OS) return nullptr; if (!CI.getFrontendOpts().RelocatablePCH) Sysroot.clear(); - return llvm::make_unique<PCHGenerator>(CI.getPreprocessor(), OutputFile, - nullptr, Sysroot, OS); + + auto Buffer = std::make_shared<PCHBuffer>(); + std::vector<std::unique_ptr<ASTConsumer>> Consumers; + Consumers.push_back(llvm::make_unique<PCHGenerator>( + CI.getPreprocessor(), OutputFile, nullptr, Sysroot, Buffer)); + Consumers.push_back( + CI.getPCHContainerOperations()->CreatePCHContainerGenerator( + CI.getDiagnostics(), CI.getHeaderSearchOpts(), + CI.getPreprocessorOpts(), CI.getTargetOpts(), CI.getLangOpts(), + InFile, OutputFile, OS, Buffer)); + + return llvm::make_unique<MultiplexConsumer>(std::move(Consumers)); } -raw_ostream *GeneratePCHAction::ComputeASTConsumerArguments( +raw_pwrite_stream *GeneratePCHAction::ComputeASTConsumerArguments( CompilerInstance &CI, StringRef InFile, std::string &Sysroot, std::string &OutputFile) { Sysroot = CI.getHeaderSearchOpts().Sysroot; @@ -102,7 +113,7 @@ raw_ostream *GeneratePCHAction::ComputeASTConsumerArguments( // We use createOutputFile here because this is exposed via libclang, and we // must disable the RemoveFileOnSignal behavior. // We use a temporary to avoid race conditions. - raw_ostream *OS = + raw_pwrite_stream *OS = CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true, /*RemoveFileOnSignal=*/false, InFile, /*Extension=*/"", /*useTemporary=*/true); @@ -118,13 +129,21 @@ GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { std::string Sysroot; std::string OutputFile; - raw_ostream *OS = + raw_pwrite_stream *OS = ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile); if (!OS) return nullptr; - return llvm::make_unique<PCHGenerator>(CI.getPreprocessor(), OutputFile, - Module, Sysroot, OS); + auto Buffer = std::make_shared<PCHBuffer>(); + std::vector<std::unique_ptr<ASTConsumer>> Consumers; + Consumers.push_back(llvm::make_unique<PCHGenerator>( + CI.getPreprocessor(), OutputFile, Module, Sysroot, Buffer)); + Consumers.push_back( + CI.getPCHContainerOperations()->CreatePCHContainerGenerator( + CI.getDiagnostics(), CI.getHeaderSearchOpts(), + CI.getPreprocessorOpts(), CI.getTargetOpts(), CI.getLangOpts(), + InFile, OutputFile, OS, Buffer)); + return llvm::make_unique<MultiplexConsumer>(std::move(Consumers)); } static SmallVectorImpl<char> & @@ -348,7 +367,7 @@ bool GenerateModuleAction::BeginSourceFileAction(CompilerInstance &CI, return true; } -raw_ostream *GenerateModuleAction::ComputeASTConsumerArguments( +raw_pwrite_stream *GenerateModuleAction::ComputeASTConsumerArguments( CompilerInstance &CI, StringRef InFile, std::string &Sysroot, std::string &OutputFile) { // If no output file was provided, figure out where this module would go @@ -363,7 +382,7 @@ raw_ostream *GenerateModuleAction::ComputeASTConsumerArguments( // We use createOutputFile here because this is exposed via libclang, and we // must disable the RemoveFileOnSignal behavior. // We use a temporary to avoid race conditions. - raw_ostream *OS = + raw_pwrite_stream *OS = CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true, /*RemoveFileOnSignal=*/false, InFile, /*Extension=*/"", /*useTemporary=*/true, @@ -395,13 +414,13 @@ void VerifyPCHAction::ExecuteAction() { CompilerInstance &CI = getCompilerInstance(); bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0; const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot; - std::unique_ptr<ASTReader> Reader( - new ASTReader(CI.getPreprocessor(), CI.getASTContext(), - Sysroot.empty() ? "" : Sysroot.c_str(), - /*DisableValidation*/ false, - /*AllowPCHWithCompilerErrors*/ false, - /*AllowConfigurationMismatch*/ true, - /*ValidateSystemInputs*/ true)); + std::unique_ptr<ASTReader> Reader(new ASTReader( + CI.getPreprocessor(), CI.getASTContext(), *CI.getPCHContainerOperations(), + Sysroot.empty() ? "" : Sysroot.c_str(), + /*DisableValidation*/ false, + /*AllowPCHWithCompilerErrors*/ false, + /*AllowConfigurationMismatch*/ true, + /*ValidateSystemInputs*/ true)); Reader->ReadAST(getCurrentFile(), Preamble ? serialization::MK_Preamble @@ -550,9 +569,9 @@ void DumpModuleInfoAction::ExecuteAction() { Out << "Information for module file '" << getCurrentFile() << "':\n"; DumpModuleInfoListener Listener(Out); - ASTReader::readASTFileControlBlock(getCurrentFile(), - getCompilerInstance().getFileManager(), - Listener); + ASTReader::readASTFileControlBlock( + getCurrentFile(), getCompilerInstance().getFileManager(), + *getCompilerInstance().getPCHContainerOperations(), Listener); } //===----------------------------------------------------------------------===// diff --git a/lib/Frontend/InitPreprocessor.cpp b/lib/Frontend/InitPreprocessor.cpp index dfc46f47cce3..24171468f1b2 100644 --- a/lib/Frontend/InitPreprocessor.cpp +++ b/lib/Frontend/InitPreprocessor.cpp @@ -97,10 +97,11 @@ static void AddImplicitIncludePTH(MacroBuilder &Builder, Preprocessor &PP, /// \brief Add an implicit \#include using the original file used to generate /// a PCH file. static void AddImplicitIncludePCH(MacroBuilder &Builder, Preprocessor &PP, + const PCHContainerOperations &PCHContainerOps, StringRef ImplicitIncludePCH) { std::string OriginalFile = - ASTReader::getOriginalSourceFile(ImplicitIncludePCH, PP.getFileManager(), - PP.getDiagnostics()); + ASTReader::getOriginalSourceFile(ImplicitIncludePCH, PP.getFileManager(), + PCHContainerOps, PP.getDiagnostics()); if (OriginalFile.empty()) return; @@ -891,9 +892,10 @@ static void InitializePredefinedMacros(const TargetInfo &TI, /// InitializePreprocessor - Initialize the preprocessor getting it and the /// environment ready to process a single file. This returns true on error. /// -void clang::InitializePreprocessor(Preprocessor &PP, - const PreprocessorOptions &InitOpts, - const FrontendOptions &FEOpts) { +void clang::InitializePreprocessor( + Preprocessor &PP, const PreprocessorOptions &InitOpts, + const PCHContainerOperations &PCHContainerOps, + const FrontendOptions &FEOpts) { const LangOptions &LangOpts = PP.getLangOpts(); std::string PredefineBuffer; PredefineBuffer.reserve(4080); @@ -952,7 +954,8 @@ void clang::InitializePreprocessor(Preprocessor &PP, // Process -include-pch/-include-pth directives. if (!InitOpts.ImplicitPCHInclude.empty()) - AddImplicitIncludePCH(Builder, PP, InitOpts.ImplicitPCHInclude); + AddImplicitIncludePCH(Builder, PP, PCHContainerOps, + InitOpts.ImplicitPCHInclude); if (!InitOpts.ImplicitPTHInclude.empty()) AddImplicitIncludePTH(Builder, PP, InitOpts.ImplicitPTHInclude); diff --git a/lib/Frontend/MultiplexConsumer.cpp b/lib/Frontend/MultiplexConsumer.cpp index 219e9492d28b..a53f4d2a5a17 100644 --- a/lib/Frontend/MultiplexConsumer.cpp +++ b/lib/Frontend/MultiplexConsumer.cpp @@ -33,11 +33,13 @@ public: void ReaderInitialized(ASTReader *Reader) override; void IdentifierRead(serialization::IdentID ID, IdentifierInfo *II) override; + void MacroRead(serialization::MacroID ID, MacroInfo *MI) override; void TypeRead(serialization::TypeIdx Idx, QualType T) override; void DeclRead(serialization::DeclID ID, const Decl *D) override; void SelectorRead(serialization::SelectorID iD, Selector Sel) override; void MacroDefinitionRead(serialization::PreprocessedEntityID, MacroDefinitionRecord *MD) override; + void ModuleRead(serialization::SubmoduleID ID, Module *Mod) override; private: std::vector<ASTDeserializationListener *> Listeners; @@ -60,6 +62,12 @@ void MultiplexASTDeserializationListener::IdentifierRead( Listeners[i]->IdentifierRead(ID, II); } +void MultiplexASTDeserializationListener::MacroRead( + serialization::MacroID ID, MacroInfo *MI) { + for (auto &Listener : Listeners) + Listener->MacroRead(ID, MI); +} + void MultiplexASTDeserializationListener::TypeRead( serialization::TypeIdx Idx, QualType T) { for (size_t i = 0, e = Listeners.size(); i != e; ++i) @@ -84,6 +92,12 @@ void MultiplexASTDeserializationListener::MacroDefinitionRead( Listeners[i]->MacroDefinitionRead(ID, MD); } +void MultiplexASTDeserializationListener::ModuleRead( + serialization::SubmoduleID ID, Module *Mod) { + for (auto &Listener : Listeners) + Listener->ModuleRead(ID, Mod); +} + // This ASTMutationListener forwards its notifications to a set of // child listeners. class MultiplexASTMutationListener : public ASTMutationListener { @@ -99,6 +113,7 @@ public: const VarTemplateSpecializationDecl *D) override; void AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, const FunctionDecl *D) override; + void ResolvedExceptionSpec(const FunctionDecl *FD) override; void DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) override; void ResolvedOperatorDelete(const CXXDestructorDecl *DD, const FunctionDecl *Delete) override; @@ -106,6 +121,7 @@ public: void StaticDataMemberInstantiated(const VarDecl *D) override; void AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, const ObjCInterfaceDecl *IFD) override; + void FunctionDefinitionInstantiated(const FunctionDecl *D) override; void AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop, const ObjCPropertyDecl *OrigProp, const ObjCCategoryDecl *ClassExt) override; @@ -153,6 +169,11 @@ void MultiplexASTMutationListener::AddedCXXTemplateSpecialization( for (size_t i = 0, e = Listeners.size(); i != e; ++i) Listeners[i]->AddedCXXTemplateSpecialization(TD, D); } +void MultiplexASTMutationListener::ResolvedExceptionSpec( + const FunctionDecl *FD) { + for (auto &Listener : Listeners) + Listener->ResolvedExceptionSpec(FD); +} void MultiplexASTMutationListener::DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) { for (size_t i = 0, e = Listeners.size(); i != e; ++i) @@ -179,6 +200,11 @@ void MultiplexASTMutationListener::AddedObjCCategoryToInterface( for (size_t i = 0, e = Listeners.size(); i != e; ++i) Listeners[i]->AddedObjCCategoryToInterface(CatD, IFD); } +void MultiplexASTMutationListener::FunctionDefinitionInstantiated( + const FunctionDecl *D) { + for (auto &Listener : Listeners) + Listener->FunctionDefinitionInstantiated(D); +} void MultiplexASTMutationListener::AddedObjCPropertyInClassExtension( const ObjCPropertyDecl *Prop, const ObjCPropertyDecl *OrigProp, diff --git a/lib/Frontend/PCHContainerOperations.cpp b/lib/Frontend/PCHContainerOperations.cpp new file mode 100644 index 000000000000..fd3278b3b145 --- /dev/null +++ b/lib/Frontend/PCHContainerOperations.cpp @@ -0,0 +1,70 @@ +//===--- Frontend/PCHContainerOperations.cpp - PCH Containers ---*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines PCHContainerOperations and RawPCHContainerOperation. +// +//===----------------------------------------------------------------------===// + +#include "clang/Frontend/PCHContainerOperations.h" +#include "clang/AST/ASTConsumer.h" +#include "llvm/Bitcode/BitstreamReader.h" +#include "llvm/Support/raw_ostream.h" +#include "clang/Lex/ModuleLoader.h" +using namespace clang; + +PCHContainerOperations::~PCHContainerOperations() {} + +namespace { + +/// \brief A PCHContainerGenerator that writes out the PCH to a flat file. +class PCHContainerGenerator : public ASTConsumer { + std::shared_ptr<PCHBuffer> Buffer; + raw_pwrite_stream *OS; + +public: + PCHContainerGenerator(DiagnosticsEngine &Diags, + const HeaderSearchOptions &HSO, + const PreprocessorOptions &PPO, const TargetOptions &TO, + const LangOptions &LO, const std::string &MainFileName, + const std::string &OutputFileName, + llvm::raw_pwrite_stream *OS, + std::shared_ptr<PCHBuffer> Buffer) + : Buffer(Buffer), OS(OS) {} + + virtual ~PCHContainerGenerator() {} + + void HandleTranslationUnit(ASTContext &Ctx) override { + if (Buffer->IsComplete) { + // Make sure it hits disk now. + *OS << Buffer->Data; + OS->flush(); + } + // Free the space of the temporary buffer. + llvm::SmallVector<char, 0> Empty; + Buffer->Data = std::move(Empty); + } +}; +} + +std::unique_ptr<ASTConsumer> +RawPCHContainerOperations::CreatePCHContainerGenerator( + DiagnosticsEngine &Diags, const HeaderSearchOptions &HSO, + const PreprocessorOptions &PPO, const TargetOptions &TO, + const LangOptions &LO, const std::string &MainFileName, + const std::string &OutputFileName, llvm::raw_pwrite_stream *OS, + std::shared_ptr<PCHBuffer> Buffer) const { + return llvm::make_unique<PCHContainerGenerator>( + Diags, HSO, PPO, TO, LO, MainFileName, OutputFileName, OS, Buffer); +} + +void RawPCHContainerOperations::ExtractPCH( + llvm::MemoryBufferRef Buffer, llvm::BitstreamReader &StreamFile) const { + StreamFile.init((const unsigned char *)Buffer.getBufferStart(), + (const unsigned char *)Buffer.getBufferEnd()); +} diff --git a/lib/Frontend/PrintPreprocessedOutput.cpp b/lib/Frontend/PrintPreprocessedOutput.cpp index 6192554299ab..a58c935620a2 100644 --- a/lib/Frontend/PrintPreprocessedOutput.cpp +++ b/lib/Frontend/PrintPreprocessedOutput.cpp @@ -562,8 +562,13 @@ struct UnknownPragmaHandler : public PragmaHandler { const char *Prefix; PrintPPOutputPPCallbacks *Callbacks; - UnknownPragmaHandler(const char *prefix, PrintPPOutputPPCallbacks *callbacks) - : Prefix(prefix), Callbacks(callbacks) {} + // Set to true if tokens should be expanded + bool ShouldExpandTokens; + + UnknownPragmaHandler(const char *prefix, PrintPPOutputPPCallbacks *callbacks, + bool RequireTokenExpansion) + : Prefix(prefix), Callbacks(callbacks), + ShouldExpandTokens(RequireTokenExpansion) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PragmaTok) override { // Figure out what line we went to and insert the appropriate number of @@ -571,16 +576,24 @@ struct UnknownPragmaHandler : public PragmaHandler { Callbacks->startNewLineIfNeeded(); Callbacks->MoveToLine(PragmaTok.getLocation()); Callbacks->OS.write(Prefix, strlen(Prefix)); + + Token PrevToken; + Token PrevPrevToken; + PrevToken.startToken(); + PrevPrevToken.startToken(); + // Read and print all of the pragma tokens. while (PragmaTok.isNot(tok::eod)) { - if (PragmaTok.hasLeadingSpace()) + if (PragmaTok.hasLeadingSpace() || + Callbacks->AvoidConcat(PrevPrevToken, PrevToken, PragmaTok)) Callbacks->OS << ' '; std::string TokSpell = PP.getSpelling(PragmaTok); Callbacks->OS.write(&TokSpell[0], TokSpell.size()); - // Expand macros in pragmas with -fms-extensions. The assumption is that - // the majority of pragmas in such a file will be Microsoft pragmas. - if (PP.getLangOpts().MicrosoftExt) + PrevPrevToken = PrevToken; + PrevToken = PragmaTok; + + if (ShouldExpandTokens) PP.Lex(PragmaTok); else PP.LexUnexpandedToken(PragmaTok); @@ -718,10 +731,29 @@ void clang::DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS, PrintPPOutputPPCallbacks *Callbacks = new PrintPPOutputPPCallbacks( PP, *OS, !Opts.ShowLineMarkers, Opts.ShowMacros, Opts.UseLineDirectives); - PP.AddPragmaHandler(new UnknownPragmaHandler("#pragma", Callbacks)); - PP.AddPragmaHandler("GCC", new UnknownPragmaHandler("#pragma GCC",Callbacks)); - PP.AddPragmaHandler("clang", - new UnknownPragmaHandler("#pragma clang", Callbacks)); + + // Expand macros in pragmas with -fms-extensions. The assumption is that + // the majority of pragmas in such a file will be Microsoft pragmas. + PP.AddPragmaHandler(new UnknownPragmaHandler( + "#pragma", Callbacks, + /*RequireTokenExpansion=*/PP.getLangOpts().MicrosoftExt)); + PP.AddPragmaHandler( + "GCC", new UnknownPragmaHandler( + "#pragma GCC", Callbacks, + /*RequireTokenExpansion=*/PP.getLangOpts().MicrosoftExt)); + PP.AddPragmaHandler( + "clang", new UnknownPragmaHandler( + "#pragma clang", Callbacks, + /*RequireTokenExpansion=*/PP.getLangOpts().MicrosoftExt)); + + // The tokens after pragma omp need to be expanded. + // + // OpenMP [2.1, Directive format] + // Preprocessing tokens following the #pragma omp are subject to macro + // replacement. + PP.AddPragmaHandler("omp", + new UnknownPragmaHandler("#pragma omp", Callbacks, + /*RequireTokenExpansion=*/true)); PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(Callbacks)); diff --git a/lib/Frontend/Rewrite/FixItRewriter.cpp b/lib/Frontend/Rewrite/FixItRewriter.cpp index a3e14f9f020e..dc787ac9557c 100644 --- a/lib/Frontend/Rewrite/FixItRewriter.cpp +++ b/lib/Frontend/Rewrite/FixItRewriter.cpp @@ -81,6 +81,13 @@ bool FixItRewriter::WriteFixedFiles( RewritesReceiver Rec(Rewrite); Editor.applyRewrites(Rec); + if (FixItOpts->InPlace) { + // Overwriting open files on Windows is tricky, but the rewriter can do it + // for us. + Rewrite.overwriteChangedFiles(); + return false; + } + for (iterator I = buffer_begin(), E = buffer_end(); I != E; ++I) { const FileEntry *Entry = Rewrite.getSourceMgr().getFileEntryForID(I->first); int fd; diff --git a/lib/Frontend/Rewrite/FrontendActions.cpp b/lib/Frontend/Rewrite/FrontendActions.cpp index 1b5eb2855bea..dbc661b71905 100644 --- a/lib/Frontend/Rewrite/FrontendActions.cpp +++ b/lib/Frontend/Rewrite/FrontendActions.cpp @@ -48,9 +48,10 @@ FixItAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { namespace { class FixItRewriteInPlace : public FixItOptions { public: + FixItRewriteInPlace() { InPlace = true; } + std::string RewriteFilename(const std::string &Filename, int &fd) override { - fd = -1; - return Filename; + llvm_unreachable("don't call RewriteFilename for inplace rewrites"); } }; diff --git a/lib/Frontend/VerifyDiagnosticConsumer.cpp b/lib/Frontend/VerifyDiagnosticConsumer.cpp index 910e394553de..55df9361b58e 100644 --- a/lib/Frontend/VerifyDiagnosticConsumer.cpp +++ b/lib/Frontend/VerifyDiagnosticConsumer.cpp @@ -691,7 +691,8 @@ static unsigned CheckLists(DiagnosticsEngine &Diags, SourceManager &SourceMgr, const char *Label, DirectiveList &Left, const_diag_iterator d2_begin, - const_diag_iterator d2_end) { + const_diag_iterator d2_end, + bool IgnoreUnexpected) { std::vector<Directive *> LeftOnly; DiagList Right(d2_begin, d2_end); @@ -727,7 +728,8 @@ static unsigned CheckLists(DiagnosticsEngine &Diags, SourceManager &SourceMgr, } // Now all that's left in Right are those that were not matched. unsigned num = PrintExpected(Diags, SourceMgr, LeftOnly, Label); - num += PrintUnexpected(Diags, &SourceMgr, Right.begin(), Right.end(), Label); + if (!IgnoreUnexpected) + num += PrintUnexpected(Diags, &SourceMgr, Right.begin(), Right.end(), Label); return num; } @@ -745,21 +747,28 @@ static unsigned CheckResults(DiagnosticsEngine &Diags, SourceManager &SourceMgr, // Seen \ Expected - set seen but not expected unsigned NumProblems = 0; + const DiagnosticLevelMask DiagMask = + Diags.getDiagnosticOptions().getVerifyIgnoreUnexpected(); + // See if there are error mismatches. NumProblems += CheckLists(Diags, SourceMgr, "error", ED.Errors, - Buffer.err_begin(), Buffer.err_end()); + Buffer.err_begin(), Buffer.err_end(), + bool(DiagnosticLevelMask::Error & DiagMask)); // See if there are warning mismatches. NumProblems += CheckLists(Diags, SourceMgr, "warning", ED.Warnings, - Buffer.warn_begin(), Buffer.warn_end()); + Buffer.warn_begin(), Buffer.warn_end(), + bool(DiagnosticLevelMask::Warning & DiagMask)); // See if there are remark mismatches. NumProblems += CheckLists(Diags, SourceMgr, "remark", ED.Remarks, - Buffer.remark_begin(), Buffer.remark_end()); + Buffer.remark_begin(), Buffer.remark_end(), + bool(DiagnosticLevelMask::Remark & DiagMask)); // See if there are note mismatches. NumProblems += CheckLists(Diags, SourceMgr, "note", ED.Notes, - Buffer.note_begin(), Buffer.note_end()); + Buffer.note_begin(), Buffer.note_end(), + bool(DiagnosticLevelMask::Note & DiagMask)); return NumProblems; } @@ -854,12 +863,20 @@ void VerifyDiagnosticConsumer::CheckDiagnostics() { // Check that the expected diagnostics occurred. NumErrors += CheckResults(Diags, *SrcManager, *Buffer, ED); } else { - NumErrors += (PrintUnexpected(Diags, nullptr, Buffer->err_begin(), - Buffer->err_end(), "error") + - PrintUnexpected(Diags, nullptr, Buffer->warn_begin(), - Buffer->warn_end(), "warn") + - PrintUnexpected(Diags, nullptr, Buffer->note_begin(), - Buffer->note_end(), "note")); + const DiagnosticLevelMask DiagMask = + ~Diags.getDiagnosticOptions().getVerifyIgnoreUnexpected(); + if (bool(DiagnosticLevelMask::Error & DiagMask)) + NumErrors += PrintUnexpected(Diags, nullptr, Buffer->err_begin(), + Buffer->err_end(), "error"); + if (bool(DiagnosticLevelMask::Warning & DiagMask)) + NumErrors += PrintUnexpected(Diags, nullptr, Buffer->warn_begin(), + Buffer->warn_end(), "warn"); + if (bool(DiagnosticLevelMask::Remark & DiagMask)) + NumErrors += PrintUnexpected(Diags, nullptr, Buffer->remark_begin(), + Buffer->remark_end(), "remark"); + if (bool(DiagnosticLevelMask::Note & DiagMask)) + NumErrors += PrintUnexpected(Diags, nullptr, Buffer->note_begin(), + Buffer->note_end(), "note"); } Diags.setClient(CurClient, Owner.release() != nullptr); diff --git a/lib/Headers/CMakeLists.txt b/lib/Headers/CMakeLists.txt index 29a738e7a81a..5f8857c41b49 100644 --- a/lib/Headers/CMakeLists.txt +++ b/lib/Headers/CMakeLists.txt @@ -62,6 +62,7 @@ set(files x86intrin.h xmmintrin.h xopintrin.h + xtestintrin.h ) set(output_dir ${LLVM_LIBRARY_OUTPUT_INTDIR}/clang/${CLANG_VERSION}/include) diff --git a/lib/Headers/Intrin.h b/lib/Headers/Intrin.h index 727a55e5b761..dd04e06ad8bc 100644 --- a/lib/Headers/Intrin.h +++ b/lib/Headers/Intrin.h @@ -39,6 +39,9 @@ #include <setjmp.h> #endif +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__)) + #ifdef __cplusplus extern "C" { #endif @@ -421,7 +424,7 @@ unsigned __int64 _shrx_u64(unsigned __int64, unsigned int); * Multiply two 64-bit integers and obtain a 64-bit result. * The low-half is returned directly and the high half is in an out parameter. */ -static __inline__ unsigned __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned __int64 DEFAULT_FN_ATTRS _umul128(unsigned __int64 _Multiplier, unsigned __int64 _Multiplicand, unsigned __int64 *_HighProduct) { unsigned __int128 _FullProduct = @@ -429,7 +432,7 @@ _umul128(unsigned __int64 _Multiplier, unsigned __int64 _Multiplicand, *_HighProduct = _FullProduct >> 64; return _FullProduct; } -static __inline__ unsigned __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned __int64 DEFAULT_FN_ATTRS __umulh(unsigned __int64 _Multiplier, unsigned __int64 _Multiplicand) { unsigned __int128 _FullProduct = (unsigned __int128)_Multiplier * (unsigned __int128)_Multiplicand; @@ -444,54 +447,54 @@ void __cdecl _xsaveopt64(void *, unsigned __int64); /*----------------------------------------------------------------------------*\ |* Bit Twiddling \*----------------------------------------------------------------------------*/ -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _rotl8(unsigned char _Value, unsigned char _Shift) { _Shift &= 0x7; return _Shift ? (_Value << _Shift) | (_Value >> (8 - _Shift)) : _Value; } -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _rotr8(unsigned char _Value, unsigned char _Shift) { _Shift &= 0x7; return _Shift ? (_Value >> _Shift) | (_Value << (8 - _Shift)) : _Value; } -static __inline__ unsigned short __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned short DEFAULT_FN_ATTRS _rotl16(unsigned short _Value, unsigned char _Shift) { _Shift &= 0xf; return _Shift ? (_Value << _Shift) | (_Value >> (16 - _Shift)) : _Value; } -static __inline__ unsigned short __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned short DEFAULT_FN_ATTRS _rotr16(unsigned short _Value, unsigned char _Shift) { _Shift &= 0xf; return _Shift ? (_Value >> _Shift) | (_Value << (16 - _Shift)) : _Value; } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS _rotl(unsigned int _Value, int _Shift) { _Shift &= 0x1f; return _Shift ? (_Value << _Shift) | (_Value >> (32 - _Shift)) : _Value; } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS _rotr(unsigned int _Value, int _Shift) { _Shift &= 0x1f; return _Shift ? (_Value >> _Shift) | (_Value << (32 - _Shift)) : _Value; } -static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long DEFAULT_FN_ATTRS _lrotl(unsigned long _Value, int _Shift) { _Shift &= 0x1f; return _Shift ? (_Value << _Shift) | (_Value >> (32 - _Shift)) : _Value; } -static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long DEFAULT_FN_ATTRS _lrotr(unsigned long _Value, int _Shift) { _Shift &= 0x1f; return _Shift ? (_Value >> _Shift) | (_Value << (32 - _Shift)) : _Value; } static -__inline__ unsigned __int64 __attribute__((__always_inline__, __nodebug__)) +__inline__ unsigned __int64 DEFAULT_FN_ATTRS _rotl64(unsigned __int64 _Value, int _Shift) { _Shift &= 0x3f; return _Shift ? (_Value << _Shift) | (_Value >> (64 - _Shift)) : _Value; } static -__inline__ unsigned __int64 __attribute__((__always_inline__, __nodebug__)) +__inline__ unsigned __int64 DEFAULT_FN_ATTRS _rotr64(unsigned __int64 _Value, int _Shift) { _Shift &= 0x3f; return _Shift ? (_Value >> _Shift) | (_Value << (64 - _Shift)) : _Value; @@ -499,52 +502,52 @@ _rotr64(unsigned __int64 _Value, int _Shift) { /*----------------------------------------------------------------------------*\ |* Bit Counting and Testing \*----------------------------------------------------------------------------*/ -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _BitScanForward(unsigned long *_Index, unsigned long _Mask) { if (!_Mask) return 0; *_Index = __builtin_ctzl(_Mask); return 1; } -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _BitScanReverse(unsigned long *_Index, unsigned long _Mask) { if (!_Mask) return 0; *_Index = 31 - __builtin_clzl(_Mask); return 1; } -static __inline__ unsigned short __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned short DEFAULT_FN_ATTRS __popcnt16(unsigned short value) { return __builtin_popcount((int)value); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __popcnt(unsigned int value) { return __builtin_popcount(value); } -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _bittest(long const *a, long b) { return (*a >> b) & 1; } -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _bittestandcomplement(long *a, long b) { unsigned char x = (*a >> b) & 1; *a = *a ^ (1 << b); return x; } -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _bittestandreset(long *a, long b) { unsigned char x = (*a >> b) & 1; *a = *a & ~(1 << b); return x; } -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _bittestandset(long *a, long b) { unsigned char x = (*a >> b) & 1; *a = *a | (1 << b); return x; } #if defined(__i386__) || defined(__x86_64__) -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _interlockedbittestandset(long volatile *__BitBase, long __BitPos) { unsigned char __Res; __asm__ ("xor %0, %0\n" @@ -556,14 +559,14 @@ _interlockedbittestandset(long volatile *__BitBase, long __BitPos) { } #endif #ifdef __x86_64__ -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _BitScanForward64(unsigned long *_Index, unsigned __int64 _Mask) { if (!_Mask) return 0; *_Index = __builtin_ctzll(_Mask); return 1; } -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _BitScanReverse64(unsigned long *_Index, unsigned __int64 _Mask) { if (!_Mask) return 0; @@ -571,33 +574,33 @@ _BitScanReverse64(unsigned long *_Index, unsigned __int64 _Mask) { return 1; } static __inline__ -unsigned __int64 __attribute__((__always_inline__, __nodebug__)) +unsigned __int64 DEFAULT_FN_ATTRS __popcnt64(unsigned __int64 value) { return __builtin_popcountll(value); } -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _bittest64(__int64 const *a, __int64 b) { return (*a >> b) & 1; } -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _bittestandcomplement64(__int64 *a, __int64 b) { unsigned char x = (*a >> b) & 1; *a = *a ^ (1ll << b); return x; } -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _bittestandreset64(__int64 *a, __int64 b) { unsigned char x = (*a >> b) & 1; *a = *a & ~(1ll << b); return x; } -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _bittestandset64(__int64 *a, __int64 b) { unsigned char x = (*a >> b) & 1; *a = *a | (1ll << b); return x; } -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS _interlockedbittestandset64(__int64 volatile *__BitBase, __int64 __BitPos) { unsigned char __Res; __asm__ ("xor %0, %0\n" @@ -611,16 +614,16 @@ _interlockedbittestandset64(__int64 volatile *__BitBase, __int64 __BitPos) { /*----------------------------------------------------------------------------*\ |* Interlocked Exchange Add \*----------------------------------------------------------------------------*/ -static __inline__ char __attribute__((__always_inline__, __nodebug__)) +static __inline__ char DEFAULT_FN_ATTRS _InterlockedExchangeAdd8(char volatile *_Addend, char _Value) { return __atomic_add_fetch(_Addend, _Value, 0) - _Value; } -static __inline__ short __attribute__((__always_inline__, __nodebug__)) +static __inline__ short DEFAULT_FN_ATTRS _InterlockedExchangeAdd16(short volatile *_Addend, short _Value) { return __atomic_add_fetch(_Addend, _Value, 0) - _Value; } #ifdef __x86_64__ -static __inline__ __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __int64 DEFAULT_FN_ATTRS _InterlockedExchangeAdd64(__int64 volatile *_Addend, __int64 _Value) { return __atomic_add_fetch(_Addend, _Value, 0) - _Value; } @@ -628,20 +631,20 @@ _InterlockedExchangeAdd64(__int64 volatile *_Addend, __int64 _Value) { /*----------------------------------------------------------------------------*\ |* Interlocked Exchange Sub \*----------------------------------------------------------------------------*/ -static __inline__ char __attribute__((__always_inline__, __nodebug__)) +static __inline__ char DEFAULT_FN_ATTRS _InterlockedExchangeSub8(char volatile *_Subend, char _Value) { return __atomic_sub_fetch(_Subend, _Value, 0) + _Value; } -static __inline__ short __attribute__((__always_inline__, __nodebug__)) +static __inline__ short DEFAULT_FN_ATTRS _InterlockedExchangeSub16(short volatile *_Subend, short _Value) { return __atomic_sub_fetch(_Subend, _Value, 0) + _Value; } -static __inline__ long __attribute__((__always_inline__, __nodebug__)) +static __inline__ long DEFAULT_FN_ATTRS _InterlockedExchangeSub(long volatile *_Subend, long _Value) { return __atomic_sub_fetch(_Subend, _Value, 0) + _Value; } #ifdef __x86_64__ -static __inline__ __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __int64 DEFAULT_FN_ATTRS _InterlockedExchangeSub64(__int64 volatile *_Subend, __int64 _Value) { return __atomic_sub_fetch(_Subend, _Value, 0) + _Value; } @@ -649,12 +652,12 @@ _InterlockedExchangeSub64(__int64 volatile *_Subend, __int64 _Value) { /*----------------------------------------------------------------------------*\ |* Interlocked Increment \*----------------------------------------------------------------------------*/ -static __inline__ short __attribute__((__always_inline__, __nodebug__)) +static __inline__ short DEFAULT_FN_ATTRS _InterlockedIncrement16(short volatile *_Value) { return __atomic_add_fetch(_Value, 1, 0); } #ifdef __x86_64__ -static __inline__ __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __int64 DEFAULT_FN_ATTRS _InterlockedIncrement64(__int64 volatile *_Value) { return __atomic_add_fetch(_Value, 1, 0); } @@ -662,12 +665,12 @@ _InterlockedIncrement64(__int64 volatile *_Value) { /*----------------------------------------------------------------------------*\ |* Interlocked Decrement \*----------------------------------------------------------------------------*/ -static __inline__ short __attribute__((__always_inline__, __nodebug__)) +static __inline__ short DEFAULT_FN_ATTRS _InterlockedDecrement16(short volatile *_Value) { return __atomic_sub_fetch(_Value, 1, 0); } #ifdef __x86_64__ -static __inline__ __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __int64 DEFAULT_FN_ATTRS _InterlockedDecrement64(__int64 volatile *_Value) { return __atomic_sub_fetch(_Value, 1, 0); } @@ -675,20 +678,20 @@ _InterlockedDecrement64(__int64 volatile *_Value) { /*----------------------------------------------------------------------------*\ |* Interlocked And \*----------------------------------------------------------------------------*/ -static __inline__ char __attribute__((__always_inline__, __nodebug__)) +static __inline__ char DEFAULT_FN_ATTRS _InterlockedAnd8(char volatile *_Value, char _Mask) { return __atomic_and_fetch(_Value, _Mask, 0); } -static __inline__ short __attribute__((__always_inline__, __nodebug__)) +static __inline__ short DEFAULT_FN_ATTRS _InterlockedAnd16(short volatile *_Value, short _Mask) { return __atomic_and_fetch(_Value, _Mask, 0); } -static __inline__ long __attribute__((__always_inline__, __nodebug__)) +static __inline__ long DEFAULT_FN_ATTRS _InterlockedAnd(long volatile *_Value, long _Mask) { return __atomic_and_fetch(_Value, _Mask, 0); } #ifdef __x86_64__ -static __inline__ __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __int64 DEFAULT_FN_ATTRS _InterlockedAnd64(__int64 volatile *_Value, __int64 _Mask) { return __atomic_and_fetch(_Value, _Mask, 0); } @@ -696,20 +699,20 @@ _InterlockedAnd64(__int64 volatile *_Value, __int64 _Mask) { /*----------------------------------------------------------------------------*\ |* Interlocked Or \*----------------------------------------------------------------------------*/ -static __inline__ char __attribute__((__always_inline__, __nodebug__)) +static __inline__ char DEFAULT_FN_ATTRS _InterlockedOr8(char volatile *_Value, char _Mask) { return __atomic_or_fetch(_Value, _Mask, 0); } -static __inline__ short __attribute__((__always_inline__, __nodebug__)) +static __inline__ short DEFAULT_FN_ATTRS _InterlockedOr16(short volatile *_Value, short _Mask) { return __atomic_or_fetch(_Value, _Mask, 0); } -static __inline__ long __attribute__((__always_inline__, __nodebug__)) +static __inline__ long DEFAULT_FN_ATTRS _InterlockedOr(long volatile *_Value, long _Mask) { return __atomic_or_fetch(_Value, _Mask, 0); } #ifdef __x86_64__ -static __inline__ __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __int64 DEFAULT_FN_ATTRS _InterlockedOr64(__int64 volatile *_Value, __int64 _Mask) { return __atomic_or_fetch(_Value, _Mask, 0); } @@ -717,20 +720,20 @@ _InterlockedOr64(__int64 volatile *_Value, __int64 _Mask) { /*----------------------------------------------------------------------------*\ |* Interlocked Xor \*----------------------------------------------------------------------------*/ -static __inline__ char __attribute__((__always_inline__, __nodebug__)) +static __inline__ char DEFAULT_FN_ATTRS _InterlockedXor8(char volatile *_Value, char _Mask) { return __atomic_xor_fetch(_Value, _Mask, 0); } -static __inline__ short __attribute__((__always_inline__, __nodebug__)) +static __inline__ short DEFAULT_FN_ATTRS _InterlockedXor16(short volatile *_Value, short _Mask) { return __atomic_xor_fetch(_Value, _Mask, 0); } -static __inline__ long __attribute__((__always_inline__, __nodebug__)) +static __inline__ long DEFAULT_FN_ATTRS _InterlockedXor(long volatile *_Value, long _Mask) { return __atomic_xor_fetch(_Value, _Mask, 0); } #ifdef __x86_64__ -static __inline__ __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __int64 DEFAULT_FN_ATTRS _InterlockedXor64(__int64 volatile *_Value, __int64 _Mask) { return __atomic_xor_fetch(_Value, _Mask, 0); } @@ -738,18 +741,18 @@ _InterlockedXor64(__int64 volatile *_Value, __int64 _Mask) { /*----------------------------------------------------------------------------*\ |* Interlocked Exchange \*----------------------------------------------------------------------------*/ -static __inline__ char __attribute__((__always_inline__, __nodebug__)) +static __inline__ char DEFAULT_FN_ATTRS _InterlockedExchange8(char volatile *_Target, char _Value) { __atomic_exchange(_Target, &_Value, &_Value, 0); return _Value; } -static __inline__ short __attribute__((__always_inline__, __nodebug__)) +static __inline__ short DEFAULT_FN_ATTRS _InterlockedExchange16(short volatile *_Target, short _Value) { __atomic_exchange(_Target, &_Value, &_Value, 0); return _Value; } #ifdef __x86_64__ -static __inline__ __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __int64 DEFAULT_FN_ATTRS _InterlockedExchange64(__int64 volatile *_Target, __int64 _Value) { __atomic_exchange(_Target, &_Value, &_Value, 0); return _Value; @@ -758,19 +761,19 @@ _InterlockedExchange64(__int64 volatile *_Target, __int64 _Value) { /*----------------------------------------------------------------------------*\ |* Interlocked Compare Exchange \*----------------------------------------------------------------------------*/ -static __inline__ char __attribute__((__always_inline__, __nodebug__)) +static __inline__ char DEFAULT_FN_ATTRS _InterlockedCompareExchange8(char volatile *_Destination, char _Exchange, char _Comparand) { __atomic_compare_exchange(_Destination, &_Comparand, &_Exchange, 0, 0, 0); return _Comparand; } -static __inline__ short __attribute__((__always_inline__, __nodebug__)) +static __inline__ short DEFAULT_FN_ATTRS _InterlockedCompareExchange16(short volatile *_Destination, short _Exchange, short _Comparand) { __atomic_compare_exchange(_Destination, &_Comparand, &_Exchange, 0, 0, 0); return _Comparand; } -static __inline__ __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __int64 DEFAULT_FN_ATTRS _InterlockedCompareExchange64(__int64 volatile *_Destination, __int64 _Exchange, __int64 _Comparand) { __atomic_compare_exchange(_Destination, &_Comparand, &_Exchange, 0, 0, 0); @@ -780,24 +783,24 @@ _InterlockedCompareExchange64(__int64 volatile *_Destination, |* Barriers \*----------------------------------------------------------------------------*/ #if defined(__i386__) || defined(__x86_64__) -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __attribute__((__deprecated__("use other intrinsics or C++11 atomics instead"))) _ReadWriteBarrier(void) { __asm__ volatile ("" : : : "memory"); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __attribute__((__deprecated__("use other intrinsics or C++11 atomics instead"))) _ReadBarrier(void) { __asm__ volatile ("" : : : "memory"); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __attribute__((__deprecated__("use other intrinsics or C++11 atomics instead"))) _WriteBarrier(void) { __asm__ volatile ("" : : : "memory"); } #endif #ifdef __x86_64__ -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __faststorefence(void) { __asm__ volatile("lock orq $0, (%%rsp)" : : : "memory"); } @@ -812,33 +815,33 @@ __faststorefence(void) { (__offset)) #ifdef __i386__ -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS __readfsbyte(unsigned long __offset) { return *__ptr_to_addr_space(257, unsigned char, __offset); } -static __inline__ unsigned __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned __int64 DEFAULT_FN_ATTRS __readfsqword(unsigned long __offset) { return *__ptr_to_addr_space(257, unsigned __int64, __offset); } -static __inline__ unsigned short __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned short DEFAULT_FN_ATTRS __readfsword(unsigned long __offset) { return *__ptr_to_addr_space(257, unsigned short, __offset); } #endif #ifdef __x86_64__ -static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned char DEFAULT_FN_ATTRS __readgsbyte(unsigned long __offset) { return *__ptr_to_addr_space(256, unsigned char, __offset); } -static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long DEFAULT_FN_ATTRS __readgsdword(unsigned long __offset) { return *__ptr_to_addr_space(256, unsigned long, __offset); } -static __inline__ unsigned __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned __int64 DEFAULT_FN_ATTRS __readgsqword(unsigned long __offset) { return *__ptr_to_addr_space(256, unsigned __int64, __offset); } -static __inline__ unsigned short __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned short DEFAULT_FN_ATTRS __readgsword(unsigned long __offset) { return *__ptr_to_addr_space(256, unsigned short, __offset); } @@ -848,44 +851,44 @@ __readgsword(unsigned long __offset) { |* movs, stos \*----------------------------------------------------------------------------*/ #if defined(__i386__) || defined(__x86_64__) -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __movsb(unsigned char *__dst, unsigned char const *__src, size_t __n) { __asm__("rep movsb" : : "D"(__dst), "S"(__src), "c"(__n) : "%edi", "%esi", "%ecx"); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __movsd(unsigned long *__dst, unsigned long const *__src, size_t __n) { __asm__("rep movsl" : : "D"(__dst), "S"(__src), "c"(__n) : "%edi", "%esi", "%ecx"); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __movsw(unsigned short *__dst, unsigned short const *__src, size_t __n) { __asm__("rep movsh" : : "D"(__dst), "S"(__src), "c"(__n) : "%edi", "%esi", "%ecx"); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __stosb(unsigned char *__dst, unsigned char __x, size_t __n) { __asm__("rep stosb" : : "D"(__dst), "a"(__x), "c"(__n) : "%edi", "%ecx"); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __stosd(unsigned long *__dst, unsigned long __x, size_t __n) { __asm__("rep stosl" : : "D"(__dst), "a"(__x), "c"(__n) : "%edi", "%ecx"); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __stosw(unsigned short *__dst, unsigned short __x, size_t __n) { __asm__("rep stosh" : : "D"(__dst), "a"(__x), "c"(__n) : "%edi", "%ecx"); } #endif #ifdef __x86_64__ -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __movsq(unsigned long long *__dst, unsigned long long const *__src, size_t __n) { __asm__("rep movsq" : : "D"(__dst), "S"(__src), "c"(__n) : "%edi", "%esi", "%ecx"); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __stosq(unsigned __int64 *__dst, unsigned __int64 __x, size_t __n) { __asm__("rep stosq" : : "D"(__dst), "a"(__x), "c"(__n) : "%edi", "%ecx"); @@ -895,32 +898,32 @@ __stosq(unsigned __int64 *__dst, unsigned __int64 __x, size_t __n) { /*----------------------------------------------------------------------------*\ |* Misc \*----------------------------------------------------------------------------*/ -static __inline__ void * __attribute__((__always_inline__, __nodebug__)) +static __inline__ void * DEFAULT_FN_ATTRS _AddressOfReturnAddress(void) { return (void*)((char*)__builtin_frame_address(0) + sizeof(void*)); } -static __inline__ void * __attribute__((__always_inline__, __nodebug__)) +static __inline__ void * DEFAULT_FN_ATTRS _ReturnAddress(void) { return __builtin_return_address(0); } #if defined(__i386__) || defined(__x86_64__) -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __cpuid(int __info[4], int __level) { __asm__ ("cpuid" : "=a"(__info[0]), "=b" (__info[1]), "=c"(__info[2]), "=d"(__info[3]) : "a"(__level)); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __cpuidex(int __info[4], int __level, int __ecx) { __asm__ ("cpuid" : "=a"(__info[0]), "=b" (__info[1]), "=c"(__info[2]), "=d"(__info[3]) : "a"(__level), "c"(__ecx)); } -static __inline__ unsigned __int64 __cdecl __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned __int64 __cdecl DEFAULT_FN_ATTRS _xgetbv(unsigned int __xcr_no) { unsigned int __eax, __edx; __asm__ ("xgetbv" : "=a" (__eax), "=d" (__edx) : "c" (__xcr_no)); return ((unsigned __int64)__edx << 32) | __eax; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __halt(void) { __asm__ volatile ("hlt"); } @@ -930,7 +933,7 @@ __halt(void) { |* Privileged intrinsics \*----------------------------------------------------------------------------*/ #if defined(__i386__) || defined(__x86_64__) -static __inline__ unsigned __int64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned __int64 DEFAULT_FN_ATTRS __readmsr(unsigned long __register) { // Loads the contents of a 64-bit model specific register (MSR) specified in // the ECX register into registers EDX:EAX. The EDX register is loaded with @@ -944,14 +947,14 @@ __readmsr(unsigned long __register) { return (((unsigned __int64)__edx) << 32) | (unsigned __int64)__eax; } -static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long DEFAULT_FN_ATTRS __readcr3(void) { unsigned long __cr3_val; __asm__ __volatile__ ("mov %%cr3, %0" : "=q"(__cr3_val) : : "memory"); return __cr3_val; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS __writecr3(unsigned int __cr3_val) { __asm__ ("mov %0, %%cr3" : : "q"(__cr3_val) : "memory"); } @@ -961,5 +964,7 @@ __writecr3(unsigned int __cr3_val) { } #endif +#undef DEFAULT_FN_ATTRS + #endif /* __INTRIN_H */ #endif /* _MSC_VER */ diff --git a/lib/Headers/__wmmintrin_aes.h b/lib/Headers/__wmmintrin_aes.h index 2bfa027e07b1..17b3f1d55f76 100644 --- a/lib/Headers/__wmmintrin_aes.h +++ b/lib/Headers/__wmmintrin_aes.h @@ -25,35 +25,34 @@ #include <emmintrin.h> -#if !defined (__AES__) -# error "AES instructions not enabled" -#else +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("aes"))) -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_aesenc_si128(__m128i __V, __m128i __R) { return (__m128i)__builtin_ia32_aesenc128(__V, __R); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_aesenclast_si128(__m128i __V, __m128i __R) { return (__m128i)__builtin_ia32_aesenclast128(__V, __R); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_aesdec_si128(__m128i __V, __m128i __R) { return (__m128i)__builtin_ia32_aesdec128(__V, __R); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_aesdeclast_si128(__m128i __V, __m128i __R) { return (__m128i)__builtin_ia32_aesdeclast128(__V, __R); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_aesimc_si128(__m128i __V) { return (__m128i)__builtin_ia32_aesimc128(__V); @@ -62,6 +61,6 @@ _mm_aesimc_si128(__m128i __V) #define _mm_aeskeygenassist_si128(C, R) \ __builtin_ia32_aeskeygenassist128((C), (R)) -#endif +#undef DEFAULT_FN_ATTRS #endif /* _WMMINTRIN_AES_H */ diff --git a/lib/Headers/__wmmintrin_pclmul.h b/lib/Headers/__wmmintrin_pclmul.h index 8d1f1b7c0868..48a85d24ee1b 100644 --- a/lib/Headers/__wmmintrin_pclmul.h +++ b/lib/Headers/__wmmintrin_pclmul.h @@ -23,12 +23,8 @@ #ifndef _WMMINTRIN_PCLMUL_H #define _WMMINTRIN_PCLMUL_H -#if !defined (__PCLMUL__) -# error "PCLMUL instruction is not enabled" -#else #define _mm_clmulepi64_si128(__X, __Y, __I) \ ((__m128i)__builtin_ia32_pclmulqdq128((__v2di)(__m128i)(__X), \ (__v2di)(__m128i)(__Y), (char)(__I))) -#endif #endif /* _WMMINTRIN_PCLMUL_H */ diff --git a/lib/Headers/adxintrin.h b/lib/Headers/adxintrin.h index 9db8bcbd9030..050dc8aea8b9 100644 --- a/lib/Headers/adxintrin.h +++ b/lib/Headers/adxintrin.h @@ -28,9 +28,11 @@ #ifndef __ADXINTRIN_H #define __ADXINTRIN_H +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__)) + /* Intrinsics that are available only if __ADX__ defined */ -#ifdef __ADX__ -static __inline unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline unsigned char __attribute__((__always_inline__, __nodebug__, __target__("adx"))) _addcarryx_u32(unsigned char __cf, unsigned int __x, unsigned int __y, unsigned int *__p) { @@ -38,17 +40,16 @@ _addcarryx_u32(unsigned char __cf, unsigned int __x, unsigned int __y, } #ifdef __x86_64__ -static __inline unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline unsigned char __attribute__((__always_inline__, __nodebug__, __target__("adx"))) _addcarryx_u64(unsigned char __cf, unsigned long long __x, unsigned long long __y, unsigned long long *__p) { return __builtin_ia32_addcarryx_u64(__cf, __x, __y, __p); } #endif -#endif /* Intrinsics that are also available if __ADX__ undefined */ -static __inline unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline unsigned char DEFAULT_FN_ATTRS _addcarry_u32(unsigned char __cf, unsigned int __x, unsigned int __y, unsigned int *__p) { @@ -56,7 +57,7 @@ _addcarry_u32(unsigned char __cf, unsigned int __x, unsigned int __y, } #ifdef __x86_64__ -static __inline unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline unsigned char DEFAULT_FN_ATTRS _addcarry_u64(unsigned char __cf, unsigned long long __x, unsigned long long __y, unsigned long long *__p) { @@ -64,7 +65,7 @@ _addcarry_u64(unsigned char __cf, unsigned long long __x, } #endif -static __inline unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline unsigned char DEFAULT_FN_ATTRS _subborrow_u32(unsigned char __cf, unsigned int __x, unsigned int __y, unsigned int *__p) { @@ -72,7 +73,7 @@ _subborrow_u32(unsigned char __cf, unsigned int __x, unsigned int __y, } #ifdef __x86_64__ -static __inline unsigned char __attribute__((__always_inline__, __nodebug__)) +static __inline unsigned char DEFAULT_FN_ATTRS _subborrow_u64(unsigned char __cf, unsigned long long __x, unsigned long long __y, unsigned long long *__p) { @@ -80,4 +81,6 @@ _subborrow_u64(unsigned char __cf, unsigned long long __x, } #endif +#undef DEFAULT_FN_ATTRS + #endif /* __ADXINTRIN_H */ diff --git a/lib/Headers/altivec.h b/lib/Headers/altivec.h index 7427ed53fcba..28df89057205 100644 --- a/lib/Headers/altivec.h +++ b/lib/Headers/altivec.h @@ -12012,6 +12012,29 @@ static vector unsigned long long __ATTRS_o_ai __builtin_crypto_vpmsumb( vector unsigned long long __a, vector unsigned long long __b) { return __builtin_altivec_crypto_vpmsumd(__a, __b); } + +static vector signed char __ATTRS_o_ai vec_vgbbd (vector signed char __a) +{ + return __builtin_altivec_vgbbd((vector unsigned char) __a); +} + +static vector unsigned char __ATTRS_o_ai vec_vgbbd (vector unsigned char __a) +{ + return __builtin_altivec_vgbbd(__a); +} + +static vector long long __ATTRS_o_ai +vec_vbpermq (vector signed char __a, vector signed char __b) +{ + return __builtin_altivec_vbpermq((vector unsigned char) __a, + (vector unsigned char) __b); +} + +static vector long long __ATTRS_o_ai +vec_vbpermq (vector unsigned char __a, vector unsigned char __b) +{ + return __builtin_altivec_vbpermq(__a, __b); +} #endif #undef __ATTRS_o_ai diff --git a/lib/Headers/ammintrin.h b/lib/Headers/ammintrin.h index 17f5ab15718a..3f3820576671 100644 --- a/lib/Headers/ammintrin.h +++ b/lib/Headers/ammintrin.h @@ -24,12 +24,11 @@ #ifndef __AMMINTRIN_H #define __AMMINTRIN_H -#ifndef __SSE4A__ -#error "SSE4A instruction set not enabled" -#else - #include <pmmintrin.h> +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse4a"))) + /// \brief Extracts the specified bits from the lower 64 bits of the 128-bit /// integer vector operand at the index idx and of the length len. /// @@ -81,7 +80,7 @@ /// non-zero, the result is undefined. /// \returns A 128-bit vector whose lower 64 bits contain the bits extracted /// from the source operand. -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_extract_si64(__m128i __x, __m128i __y) { return (__m128i)__builtin_ia32_extrq((__v2di)__x, (__v16qi)__y); @@ -157,7 +156,7 @@ _mm_extract_si64(__m128i __x, __m128i __y) /// lower bits of source operand __y. The upper 64 bits of the return value /// are undefined. -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_insert_si64(__m128i __x, __m128i __y) { return (__m128i)__builtin_ia32_insertq((__v2di)__x, (__v2di)__y); @@ -178,7 +177,7 @@ _mm_insert_si64(__m128i __x, __m128i __y) /// \param __a /// The 64-bit double-precision floating-point register value to /// be stored. -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_stream_sd(double *__p, __m128d __a) { __builtin_ia32_movntsd(__p, (__v2df)__a); @@ -199,12 +198,12 @@ _mm_stream_sd(double *__p, __m128d __a) /// \param __a /// The 32-bit single-precision floating-point register value to /// be stored. -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_stream_ss(float *__p, __m128 __a) { __builtin_ia32_movntss(__p, (__v4sf)__a); } -#endif /* __SSE4A__ */ +#undef DEFAULT_FN_ATTRS #endif /* __AMMINTRIN_H */ diff --git a/lib/Headers/arm_acle.h b/lib/Headers/arm_acle.h index 6c56f3b77812..73a7e76ce3c4 100644 --- a/lib/Headers/arm_acle.h +++ b/lib/Headers/arm_acle.h @@ -289,6 +289,14 @@ static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__)) } #endif +/* 10.1 Special register intrinsics */ +#define __arm_rsr(sysreg) __builtin_arm_rsr(sysreg) +#define __arm_rsr64(sysreg) __builtin_arm_rsr64(sysreg) +#define __arm_rsrp(sysreg) __builtin_arm_rsrp(sysreg) +#define __arm_wsr(sysreg, v) __builtin_arm_wsr(sysreg, v) +#define __arm_wsr64(sysreg, v) __builtin_arm_wsr64(sysreg, v) +#define __arm_wsrp(sysreg, v) __builtin_arm_wsrp(sysreg, v) + #if defined(__cplusplus) } #endif diff --git a/lib/Headers/avx2intrin.h b/lib/Headers/avx2intrin.h index e1e639de1ba8..5f1817e45a7a 100644 --- a/lib/Headers/avx2intrin.h +++ b/lib/Headers/avx2intrin.h @@ -28,94 +28,97 @@ #ifndef __AVX2INTRIN_H #define __AVX2INTRIN_H +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx2"))) + /* SSE4 Multiple Packed Sums of Absolute Difference. */ #define _mm256_mpsadbw_epu8(X, Y, M) __builtin_ia32_mpsadbw256((X), (Y), (M)) -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_abs_epi8(__m256i __a) { return (__m256i)__builtin_ia32_pabsb256((__v32qi)__a); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_abs_epi16(__m256i __a) { return (__m256i)__builtin_ia32_pabsw256((__v16hi)__a); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_abs_epi32(__m256i __a) { return (__m256i)__builtin_ia32_pabsd256((__v8si)__a); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_packs_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_packsswb256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_packs_epi32(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_packssdw256((__v8si)__a, (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_packus_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_packuswb256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_packus_epi32(__m256i __V1, __m256i __V2) { return (__m256i) __builtin_ia32_packusdw256((__v8si)__V1, (__v8si)__V2); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_add_epi8(__m256i __a, __m256i __b) { return (__m256i)((__v32qi)__a + (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_add_epi16(__m256i __a, __m256i __b) { return (__m256i)((__v16hi)__a + (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_add_epi32(__m256i __a, __m256i __b) { return (__m256i)((__v8si)__a + (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_add_epi64(__m256i __a, __m256i __b) { return __a + __b; } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_adds_epi8(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_paddsb256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_adds_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_paddsw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_adds_epu8(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_paddusb256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_adds_epu16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_paddusw256((__v16hi)__a, (__v16hi)__b); @@ -126,31 +129,31 @@ _mm256_adds_epu16(__m256i __a, __m256i __b) __m256i __b = (b); \ (__m256i)__builtin_ia32_palignr256((__v32qi)__a, (__v32qi)__b, (n)); }) -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_and_si256(__m256i __a, __m256i __b) { return __a & __b; } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_andnot_si256(__m256i __a, __m256i __b) { return ~__a & __b; } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_avg_epu8(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pavgb256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_avg_epu16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pavgw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_blendv_epi8(__m256i __V1, __m256i __V2, __m256i __M) { return (__m256i)__builtin_ia32_pblendvb256((__v32qi)__V1, (__v32qi)__V2, @@ -178,307 +181,307 @@ _mm256_blendv_epi8(__m256i __V1, __m256i __V2, __m256i __M) (((M) & 0x40) ? 30 : 14), \ (((M) & 0x80) ? 31 : 15)); }) -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cmpeq_epi8(__m256i __a, __m256i __b) { return (__m256i)((__v32qi)__a == (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cmpeq_epi16(__m256i __a, __m256i __b) { return (__m256i)((__v16hi)__a == (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cmpeq_epi32(__m256i __a, __m256i __b) { return (__m256i)((__v8si)__a == (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cmpeq_epi64(__m256i __a, __m256i __b) { return (__m256i)(__a == __b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cmpgt_epi8(__m256i __a, __m256i __b) { return (__m256i)((__v32qi)__a > (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cmpgt_epi16(__m256i __a, __m256i __b) { return (__m256i)((__v16hi)__a > (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cmpgt_epi32(__m256i __a, __m256i __b) { return (__m256i)((__v8si)__a > (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cmpgt_epi64(__m256i __a, __m256i __b) { return (__m256i)(__a > __b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_hadd_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_phaddw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_hadd_epi32(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_phaddd256((__v8si)__a, (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_hadds_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_phaddsw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_hsub_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_phsubw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_hsub_epi32(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_phsubd256((__v8si)__a, (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_hsubs_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_phsubsw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maddubs_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmaddubsw256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_madd_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmaddwd256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_max_epi8(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmaxsb256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_max_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmaxsw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_max_epi32(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmaxsd256((__v8si)__a, (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_max_epu8(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmaxub256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_max_epu16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmaxuw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_max_epu32(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmaxud256((__v8si)__a, (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_min_epi8(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pminsb256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_min_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pminsw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_min_epi32(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pminsd256((__v8si)__a, (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_min_epu8(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pminub256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_min_epu16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pminuw256 ((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_min_epu32(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pminud256((__v8si)__a, (__v8si)__b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm256_movemask_epi8(__m256i __a) { return __builtin_ia32_pmovmskb256((__v32qi)__a); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cvtepi8_epi16(__m128i __V) { return (__m256i)__builtin_ia32_pmovsxbw256((__v16qi)__V); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cvtepi8_epi32(__m128i __V) { return (__m256i)__builtin_ia32_pmovsxbd256((__v16qi)__V); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cvtepi8_epi64(__m128i __V) { return (__m256i)__builtin_ia32_pmovsxbq256((__v16qi)__V); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cvtepi16_epi32(__m128i __V) { return (__m256i)__builtin_ia32_pmovsxwd256((__v8hi)__V); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cvtepi16_epi64(__m128i __V) { return (__m256i)__builtin_ia32_pmovsxwq256((__v8hi)__V); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cvtepi32_epi64(__m128i __V) { return (__m256i)__builtin_ia32_pmovsxdq256((__v4si)__V); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cvtepu8_epi16(__m128i __V) { return (__m256i)__builtin_ia32_pmovzxbw256((__v16qi)__V); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cvtepu8_epi32(__m128i __V) { return (__m256i)__builtin_ia32_pmovzxbd256((__v16qi)__V); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cvtepu8_epi64(__m128i __V) { return (__m256i)__builtin_ia32_pmovzxbq256((__v16qi)__V); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cvtepu16_epi32(__m128i __V) { return (__m256i)__builtin_ia32_pmovzxwd256((__v8hi)__V); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cvtepu16_epi64(__m128i __V) { return (__m256i)__builtin_ia32_pmovzxwq256((__v8hi)__V); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cvtepu32_epi64(__m128i __V) { return (__m256i)__builtin_ia32_pmovzxdq256((__v4si)__V); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mul_epi32(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmuldq256((__v8si)__a, (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mulhrs_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmulhrsw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mulhi_epu16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmulhuw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mulhi_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmulhw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mullo_epi16(__m256i __a, __m256i __b) { return (__m256i)((__v16hi)__a * (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mullo_epi32 (__m256i __a, __m256i __b) { return (__m256i)((__v8si)__a * (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mul_epu32(__m256i __a, __m256i __b) { return __builtin_ia32_pmuludq256((__v8si)__a, (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_or_si256(__m256i __a, __m256i __b) { return __a | __b; } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sad_epu8(__m256i __a, __m256i __b) { return __builtin_ia32_psadbw256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_shuffle_epi8(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pshufb256((__v32qi)__a, (__v32qi)__b); @@ -520,19 +523,19 @@ _mm256_shuffle_epi8(__m256i __a, __m256i __b) 8 + (((imm) & 0xc0) >> 6), \ 12, 13, 14, 15); }) -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sign_epi8(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_psignb256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sign_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_psignw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sign_epi32(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_psignd256((__v8si)__a, (__v8si)__b); @@ -544,61 +547,61 @@ _mm256_sign_epi32(__m256i __a, __m256i __b) #define _mm256_bslli_epi128(a, count) _mm256_slli_si256((a), (count)) -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_slli_epi16(__m256i __a, int __count) { return (__m256i)__builtin_ia32_psllwi256((__v16hi)__a, __count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sll_epi16(__m256i __a, __m128i __count) { return (__m256i)__builtin_ia32_psllw256((__v16hi)__a, (__v8hi)__count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_slli_epi32(__m256i __a, int __count) { return (__m256i)__builtin_ia32_pslldi256((__v8si)__a, __count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sll_epi32(__m256i __a, __m128i __count) { return (__m256i)__builtin_ia32_pslld256((__v8si)__a, (__v4si)__count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_slli_epi64(__m256i __a, int __count) { return __builtin_ia32_psllqi256(__a, __count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sll_epi64(__m256i __a, __m128i __count) { return __builtin_ia32_psllq256(__a, __count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_srai_epi16(__m256i __a, int __count) { return (__m256i)__builtin_ia32_psrawi256((__v16hi)__a, __count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sra_epi16(__m256i __a, __m128i __count) { return (__m256i)__builtin_ia32_psraw256((__v16hi)__a, (__v8hi)__count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_srai_epi32(__m256i __a, int __count) { return (__m256i)__builtin_ia32_psradi256((__v8si)__a, __count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sra_epi32(__m256i __a, __m128i __count) { return (__m256i)__builtin_ia32_psrad256((__v8si)__a, (__v4si)__count); @@ -610,175 +613,175 @@ _mm256_sra_epi32(__m256i __a, __m128i __count) #define _mm256_bsrli_epi128(a, count) _mm256_srli_si256((a), (count)) -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_srli_epi16(__m256i __a, int __count) { return (__m256i)__builtin_ia32_psrlwi256((__v16hi)__a, __count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_srl_epi16(__m256i __a, __m128i __count) { return (__m256i)__builtin_ia32_psrlw256((__v16hi)__a, (__v8hi)__count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_srli_epi32(__m256i __a, int __count) { return (__m256i)__builtin_ia32_psrldi256((__v8si)__a, __count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_srl_epi32(__m256i __a, __m128i __count) { return (__m256i)__builtin_ia32_psrld256((__v8si)__a, (__v4si)__count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_srli_epi64(__m256i __a, int __count) { return __builtin_ia32_psrlqi256(__a, __count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_srl_epi64(__m256i __a, __m128i __count) { return __builtin_ia32_psrlq256(__a, __count); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sub_epi8(__m256i __a, __m256i __b) { return (__m256i)((__v32qi)__a - (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sub_epi16(__m256i __a, __m256i __b) { return (__m256i)((__v16hi)__a - (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sub_epi32(__m256i __a, __m256i __b) { return (__m256i)((__v8si)__a - (__v8si)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sub_epi64(__m256i __a, __m256i __b) { return __a - __b; } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_subs_epi8(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_psubsb256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_subs_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_psubsw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_subs_epu8(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_psubusb256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_subs_epu16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_psubusw256((__v16hi)__a, (__v16hi)__b); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_unpackhi_epi8(__m256i __a, __m256i __b) { return (__m256i)__builtin_shufflevector((__v32qi)__a, (__v32qi)__b, 8, 32+8, 9, 32+9, 10, 32+10, 11, 32+11, 12, 32+12, 13, 32+13, 14, 32+14, 15, 32+15, 24, 32+24, 25, 32+25, 26, 32+26, 27, 32+27, 28, 32+28, 29, 32+29, 30, 32+30, 31, 32+31); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_unpackhi_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_shufflevector((__v16hi)__a, (__v16hi)__b, 4, 16+4, 5, 16+5, 6, 16+6, 7, 16+7, 12, 16+12, 13, 16+13, 14, 16+14, 15, 16+15); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_unpackhi_epi32(__m256i __a, __m256i __b) { return (__m256i)__builtin_shufflevector((__v8si)__a, (__v8si)__b, 2, 8+2, 3, 8+3, 6, 8+6, 7, 8+7); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_unpackhi_epi64(__m256i __a, __m256i __b) { return (__m256i)__builtin_shufflevector(__a, __b, 1, 4+1, 3, 4+3); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_unpacklo_epi8(__m256i __a, __m256i __b) { return (__m256i)__builtin_shufflevector((__v32qi)__a, (__v32qi)__b, 0, 32+0, 1, 32+1, 2, 32+2, 3, 32+3, 4, 32+4, 5, 32+5, 6, 32+6, 7, 32+7, 16, 32+16, 17, 32+17, 18, 32+18, 19, 32+19, 20, 32+20, 21, 32+21, 22, 32+22, 23, 32+23); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_unpacklo_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_shufflevector((__v16hi)__a, (__v16hi)__b, 0, 16+0, 1, 16+1, 2, 16+2, 3, 16+3, 8, 16+8, 9, 16+9, 10, 16+10, 11, 16+11); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_unpacklo_epi32(__m256i __a, __m256i __b) { return (__m256i)__builtin_shufflevector((__v8si)__a, (__v8si)__b, 0, 8+0, 1, 8+1, 4, 8+4, 5, 8+5); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_unpacklo_epi64(__m256i __a, __m256i __b) { return (__m256i)__builtin_shufflevector(__a, __b, 0, 4+0, 2, 4+2); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_xor_si256(__m256i __a, __m256i __b) { return __a ^ __b; } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_stream_load_si256(__m256i *__V) { return (__m256i)__builtin_ia32_movntdqa256((__v4di *)__V); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_broadcastss_ps(__m128 __X) { return (__m128)__builtin_ia32_vbroadcastss_ps((__v4sf)__X); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_broadcastsd_pd(__m128d __a) { return __builtin_shufflevector(__a, __a, 0, 0); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_broadcastss_ps(__m128 __X) { return (__m256)__builtin_ia32_vbroadcastss_ps256((__v4sf)__X); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_broadcastsd_pd(__m128d __X) { return (__m256d)__builtin_ia32_vbroadcastsd_pd256((__v2df)__X); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_broadcastsi128_si256(__m128i __X) { return (__m256i)__builtin_shufflevector(__X, __X, 0, 1, 0, 1); @@ -806,56 +809,56 @@ _mm256_broadcastsi128_si256(__m128i __X) (((M) & 0x40) ? 14 : 6), \ (((M) & 0x80) ? 15 : 7)); }) -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_broadcastb_epi8(__m128i __X) { return (__m256i)__builtin_ia32_pbroadcastb256((__v16qi)__X); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_broadcastw_epi16(__m128i __X) { return (__m256i)__builtin_ia32_pbroadcastw256((__v8hi)__X); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_broadcastd_epi32(__m128i __X) { return (__m256i)__builtin_ia32_pbroadcastd256((__v4si)__X); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_broadcastq_epi64(__m128i __X) { return (__m256i)__builtin_ia32_pbroadcastq256(__X); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_broadcastb_epi8(__m128i __X) { return (__m128i)__builtin_ia32_pbroadcastb128((__v16qi)__X); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_broadcastw_epi16(__m128i __X) { return (__m128i)__builtin_ia32_pbroadcastw128((__v8hi)__X); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_broadcastd_epi32(__m128i __X) { return (__m128i)__builtin_ia32_pbroadcastd128((__v4si)__X); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_broadcastq_epi64(__m128i __X) { return (__m128i)__builtin_ia32_pbroadcastq128(__X); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_permutevar8x32_epi32(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_permvarsi256((__v8si)__a, (__v8si)__b); @@ -867,7 +870,7 @@ _mm256_permutevar8x32_epi32(__m256i __a, __m256i __b) (M) & 0x3, ((M) & 0xc) >> 2, \ ((M) & 0x30) >> 4, ((M) & 0xc0) >> 6); }) -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_permutevar8x32_ps(__m256 __a, __m256 __b) { return (__m256)__builtin_ia32_permvarsf256((__v8sf)__a, (__v8sf)__b); @@ -900,109 +903,109 @@ _mm256_permutevar8x32_ps(__m256 __a, __m256 __b) (((M) & 1) ? 4 : 2), \ (((M) & 1) ? 5 : 3) );}) -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskload_epi32(int const *__X, __m256i __M) { return (__m256i)__builtin_ia32_maskloadd256((const __v8si *)__X, (__v8si)__M); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskload_epi64(long long const *__X, __m256i __M) { return (__m256i)__builtin_ia32_maskloadq256((const __v4di *)__X, __M); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskload_epi32(int const *__X, __m128i __M) { return (__m128i)__builtin_ia32_maskloadd((const __v4si *)__X, (__v4si)__M); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskload_epi64(long long const *__X, __m128i __M) { return (__m128i)__builtin_ia32_maskloadq((const __v2di *)__X, (__v2di)__M); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm256_maskstore_epi32(int *__X, __m256i __M, __m256i __Y) { __builtin_ia32_maskstored256((__v8si *)__X, (__v8si)__M, (__v8si)__Y); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm256_maskstore_epi64(long long *__X, __m256i __M, __m256i __Y) { __builtin_ia32_maskstoreq256((__v4di *)__X, __M, __Y); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_maskstore_epi32(int *__X, __m128i __M, __m128i __Y) { __builtin_ia32_maskstored((__v4si *)__X, (__v4si)__M, (__v4si)__Y); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_maskstore_epi64(long long *__X, __m128i __M, __m128i __Y) { __builtin_ia32_maskstoreq(( __v2di *)__X, __M, __Y); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sllv_epi32(__m256i __X, __m256i __Y) { return (__m256i)__builtin_ia32_psllv8si((__v8si)__X, (__v8si)__Y); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sllv_epi32(__m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_psllv4si((__v4si)__X, (__v4si)__Y); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_sllv_epi64(__m256i __X, __m256i __Y) { return (__m256i)__builtin_ia32_psllv4di(__X, __Y); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sllv_epi64(__m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_psllv2di(__X, __Y); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_srav_epi32(__m256i __X, __m256i __Y) { return (__m256i)__builtin_ia32_psrav8si((__v8si)__X, (__v8si)__Y); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_srav_epi32(__m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_psrav4si((__v4si)__X, (__v4si)__Y); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_srlv_epi32(__m256i __X, __m256i __Y) { return (__m256i)__builtin_ia32_psrlv8si((__v8si)__X, (__v8si)__Y); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_srlv_epi32(__m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_psrlv4si((__v4si)__X, (__v4si)__Y); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_srlv_epi64(__m256i __X, __m256i __Y) { return (__m256i)__builtin_ia32_psrlv4di(__X, __Y); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_srlv_epi64(__m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_psrlv2di(__X, __Y); @@ -1248,4 +1251,6 @@ _mm_srlv_epi64(__m128i __X, __m128i __Y) (const __v4di *)__m, (__v4di)__i, \ (__v4di)_mm256_set1_epi64x(-1), (s)); }) +#undef DEFAULT_FN_ATTRS + #endif /* __AVX2INTRIN_H */ diff --git a/lib/Headers/avx512bwintrin.h b/lib/Headers/avx512bwintrin.h index d0591e406f7b..4eb97471781e 100644 --- a/lib/Headers/avx512bwintrin.h +++ b/lib/Headers/avx512bwintrin.h @@ -33,7 +33,10 @@ typedef unsigned long long __mmask64; typedef char __v64qi __attribute__ ((__vector_size__ (64))); typedef short __v32hi __attribute__ ((__vector_size__ (64))); -static __inline __v64qi __attribute__ ((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512bw"))) + +static __inline __v64qi DEFAULT_FN_ATTRS _mm512_setzero_qi (void) { return (__v64qi){ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -45,7 +48,7 @@ _mm512_setzero_qi (void) { 0, 0, 0, 0, 0, 0, 0, 0 }; } -static __inline __v32hi __attribute__ ((__always_inline__, __nodebug__)) +static __inline __v32hi DEFAULT_FN_ATTRS _mm512_setzero_hi (void) { return (__v32hi){ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -55,300 +58,300 @@ _mm512_setzero_hi (void) { /* Integer compare */ -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_cmpeq_epi8_mask(__m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_pcmpeqb512_mask((__v64qi)__a, (__v64qi)__b, (__mmask64)-1); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_mask_cmpeq_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_pcmpeqb512_mask((__v64qi)__a, (__v64qi)__b, __u); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_cmpeq_epu8_mask(__m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)__a, (__v64qi)__b, 0, (__mmask64)-1); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_mask_cmpeq_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)__a, (__v64qi)__b, 0, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_cmpeq_epi16_mask(__m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_pcmpeqw512_mask((__v32hi)__a, (__v32hi)__b, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_mask_cmpeq_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_pcmpeqw512_mask((__v32hi)__a, (__v32hi)__b, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_cmpeq_epu16_mask(__m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)__a, (__v32hi)__b, 0, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_mask_cmpeq_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)__a, (__v32hi)__b, 0, __u); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_cmpge_epi8_mask(__m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_cmpb512_mask((__v64qi)__a, (__v64qi)__b, 5, (__mmask64)-1); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_mask_cmpge_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_cmpb512_mask((__v64qi)__a, (__v64qi)__b, 5, __u); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_cmpge_epu8_mask(__m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)__a, (__v64qi)__b, 5, (__mmask64)-1); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_mask_cmpge_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)__a, (__v64qi)__b, 5, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_cmpge_epi16_mask(__m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_cmpw512_mask((__v32hi)__a, (__v32hi)__b, 5, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_mask_cmpge_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_cmpw512_mask((__v32hi)__a, (__v32hi)__b, 5, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_cmpge_epu16_mask(__m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)__a, (__v32hi)__b, 5, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_mask_cmpge_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)__a, (__v32hi)__b, 5, __u); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_cmpgt_epi8_mask(__m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_pcmpgtb512_mask((__v64qi)__a, (__v64qi)__b, (__mmask64)-1); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_mask_cmpgt_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_pcmpgtb512_mask((__v64qi)__a, (__v64qi)__b, __u); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_cmpgt_epu8_mask(__m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)__a, (__v64qi)__b, 6, (__mmask64)-1); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_mask_cmpgt_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)__a, (__v64qi)__b, 6, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_cmpgt_epi16_mask(__m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_pcmpgtw512_mask((__v32hi)__a, (__v32hi)__b, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_mask_cmpgt_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_pcmpgtw512_mask((__v32hi)__a, (__v32hi)__b, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_cmpgt_epu16_mask(__m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)__a, (__v32hi)__b, 6, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_mask_cmpgt_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)__a, (__v32hi)__b, 6, __u); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_cmple_epi8_mask(__m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_cmpb512_mask((__v64qi)__a, (__v64qi)__b, 2, (__mmask64)-1); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_mask_cmple_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_cmpb512_mask((__v64qi)__a, (__v64qi)__b, 2, __u); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_cmple_epu8_mask(__m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)__a, (__v64qi)__b, 2, (__mmask64)-1); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_mask_cmple_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)__a, (__v64qi)__b, 2, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_cmple_epi16_mask(__m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_cmpw512_mask((__v32hi)__a, (__v32hi)__b, 2, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_mask_cmple_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_cmpw512_mask((__v32hi)__a, (__v32hi)__b, 2, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_cmple_epu16_mask(__m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)__a, (__v32hi)__b, 2, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_mask_cmple_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)__a, (__v32hi)__b, 2, __u); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_cmplt_epi8_mask(__m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_cmpb512_mask((__v64qi)__a, (__v64qi)__b, 1, (__mmask64)-1); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_mask_cmplt_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_cmpb512_mask((__v64qi)__a, (__v64qi)__b, 1, __u); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_cmplt_epu8_mask(__m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)__a, (__v64qi)__b, 1, (__mmask64)-1); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_mask_cmplt_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)__a, (__v64qi)__b, 1, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_cmplt_epi16_mask(__m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_cmpw512_mask((__v32hi)__a, (__v32hi)__b, 1, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_mask_cmplt_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_cmpw512_mask((__v32hi)__a, (__v32hi)__b, 1, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_cmplt_epu16_mask(__m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)__a, (__v32hi)__b, 1, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_mask_cmplt_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)__a, (__v32hi)__b, 1, __u); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_cmpneq_epi8_mask(__m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_cmpb512_mask((__v64qi)__a, (__v64qi)__b, 4, (__mmask64)-1); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_mask_cmpneq_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_cmpb512_mask((__v64qi)__a, (__v64qi)__b, 4, __u); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_cmpneq_epu8_mask(__m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)__a, (__v64qi)__b, 4, (__mmask64)-1); } -static __inline__ __mmask64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask64 DEFAULT_FN_ATTRS _mm512_mask_cmpneq_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { return (__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)__a, (__v64qi)__b, 4, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_cmpneq_epi16_mask(__m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_cmpw512_mask((__v32hi)__a, (__v32hi)__b, 4, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_mask_cmpneq_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_cmpw512_mask((__v32hi)__a, (__v32hi)__b, 4, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_cmpneq_epu16_mask(__m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)__a, (__v32hi)__b, 4, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm512_mask_cmpneq_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { return (__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)__a, (__v32hi)__b, 4, __u); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_add_epi8 (__m512i __A, __m512i __B) { return (__m512i) ((__v64qi) __A + (__v64qi) __B); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_add_epi8 (__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_paddb512_mask ((__v64qi) __A, (__v64qi) __B, @@ -356,7 +359,7 @@ _mm512_mask_add_epi8 (__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { (__mmask64) __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_add_epi8 (__mmask64 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_paddb512_mask ((__v64qi) __A, (__v64qi) __B, @@ -365,12 +368,12 @@ _mm512_maskz_add_epi8 (__mmask64 __U, __m512i __A, __m512i __B) { (__mmask64) __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_sub_epi8 (__m512i __A, __m512i __B) { return (__m512i) ((__v64qi) __A - (__v64qi) __B); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_sub_epi8 (__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_psubb512_mask ((__v64qi) __A, (__v64qi) __B, @@ -378,7 +381,7 @@ _mm512_mask_sub_epi8 (__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { (__mmask64) __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_sub_epi8 (__mmask64 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_psubb512_mask ((__v64qi) __A, (__v64qi) __B, @@ -387,12 +390,12 @@ _mm512_maskz_sub_epi8 (__mmask64 __U, __m512i __A, __m512i __B) { (__mmask64) __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_add_epi16 (__m512i __A, __m512i __B) { return (__m512i) ((__v32hi) __A + (__v32hi) __B); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_add_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_paddw512_mask ((__v32hi) __A, (__v32hi) __B, @@ -400,7 +403,7 @@ _mm512_mask_add_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { (__mmask32) __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_add_epi16 (__mmask32 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_paddw512_mask ((__v32hi) __A, (__v32hi) __B, @@ -409,12 +412,12 @@ _mm512_maskz_add_epi16 (__mmask32 __U, __m512i __A, __m512i __B) { (__mmask32) __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_sub_epi16 (__m512i __A, __m512i __B) { return (__m512i) ((__v32hi) __A - (__v32hi) __B); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_sub_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_psubw512_mask ((__v32hi) __A, (__v32hi) __B, @@ -422,7 +425,7 @@ _mm512_mask_sub_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { (__mmask32) __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_sub_epi16 (__mmask32 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_psubw512_mask ((__v32hi) __A, (__v32hi) __B, @@ -431,12 +434,12 @@ _mm512_maskz_sub_epi16 (__mmask32 __U, __m512i __A, __m512i __B) { (__mmask32) __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mullo_epi16 (__m512i __A, __m512i __B) { return (__m512i) ((__v32hi) __A * (__v32hi) __B); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_mullo_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmullw512_mask ((__v32hi) __A, (__v32hi) __B, @@ -444,7 +447,7 @@ _mm512_mask_mullo_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { (__mmask32) __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_mullo_epi16 (__mmask32 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmullw512_mask ((__v32hi) __A, (__v32hi) __B, @@ -493,4 +496,6 @@ _mm512_maskz_mullo_epi16 (__mmask32 __U, __m512i __A, __m512i __B) { (__v32hi)(__m512i)(b), \ (p), (__mmask32)(m)); }) +#undef DEFAULT_FN_ATTRS + #endif diff --git a/lib/Headers/avx512dqintrin.h b/lib/Headers/avx512dqintrin.h index fd33be2f44a6..cfcfc62b9455 100644 --- a/lib/Headers/avx512dqintrin.h +++ b/lib/Headers/avx512dqintrin.h @@ -28,12 +28,15 @@ #ifndef __AVX512DQINTRIN_H #define __AVX512DQINTRIN_H -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512dq"))) + +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mullo_epi64 (__m512i __A, __m512i __B) { return (__m512i) ((__v8di) __A * (__v8di) __B); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_mullo_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmullq512_mask ((__v8di) __A, (__v8di) __B, @@ -41,7 +44,7 @@ _mm512_mask_mullo_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { (__mmask8) __U); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_mullo_epi64 (__mmask8 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmullq512_mask ((__v8di) __A, (__v8di) __B, @@ -50,12 +53,12 @@ _mm512_maskz_mullo_epi64 (__mmask8 __U, __m512i __A, __m512i __B) { (__mmask8) __U); } -static __inline__ __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_xor_pd (__m512d __A, __m512d __B) { return (__m512d) ((__v8di) __A ^ (__v8di) __B); } -static __inline__ __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_mask_xor_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_xorpd512_mask ((__v8df) __A, (__v8df) __B, @@ -63,7 +66,7 @@ _mm512_mask_xor_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_maskz_xor_pd (__mmask8 __U, __m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_xorpd512_mask ((__v8df) __A, (__v8df) __B, @@ -72,12 +75,12 @@ _mm512_maskz_xor_pd (__mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_xor_ps (__m512 __A, __m512 __B) { return (__m512) ((__v16si) __A ^ (__v16si) __B); } -static __inline__ __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_mask_xor_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { return (__m512) __builtin_ia32_xorps512_mask ((__v16sf) __A, (__v16sf) __B, @@ -85,7 +88,7 @@ _mm512_mask_xor_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_maskz_xor_ps (__mmask16 __U, __m512 __A, __m512 __B) { return (__m512) __builtin_ia32_xorps512_mask ((__v16sf) __A, (__v16sf) __B, @@ -94,12 +97,12 @@ _mm512_maskz_xor_ps (__mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_or_pd (__m512d __A, __m512d __B) { return (__m512d) ((__v8di) __A | (__v8di) __B); } -static __inline__ __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_mask_or_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_orpd512_mask ((__v8df) __A, (__v8df) __B, @@ -107,7 +110,7 @@ _mm512_mask_or_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_maskz_or_pd (__mmask8 __U, __m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_orpd512_mask ((__v8df) __A, (__v8df) __B, @@ -116,12 +119,12 @@ _mm512_maskz_or_pd (__mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_or_ps (__m512 __A, __m512 __B) { return (__m512) ((__v16si) __A | (__v16si) __B); } -static __inline__ __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_mask_or_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { return (__m512) __builtin_ia32_orps512_mask ((__v16sf) __A, (__v16sf) __B, @@ -129,7 +132,7 @@ _mm512_mask_or_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_maskz_or_ps (__mmask16 __U, __m512 __A, __m512 __B) { return (__m512) __builtin_ia32_orps512_mask ((__v16sf) __A, (__v16sf) __B, @@ -138,12 +141,12 @@ _mm512_maskz_or_ps (__mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_and_pd (__m512d __A, __m512d __B) { return (__m512d) ((__v8di) __A & (__v8di) __B); } -static __inline__ __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_mask_and_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_andpd512_mask ((__v8df) __A, (__v8df) __B, @@ -151,7 +154,7 @@ _mm512_mask_and_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_maskz_and_pd (__mmask8 __U, __m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_andpd512_mask ((__v8df) __A, (__v8df) __B, @@ -160,12 +163,12 @@ _mm512_maskz_and_pd (__mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_and_ps (__m512 __A, __m512 __B) { return (__m512) ((__v16si) __A & (__v16si) __B); } -static __inline__ __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_mask_and_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { return (__m512) __builtin_ia32_andps512_mask ((__v16sf) __A, (__v16sf) __B, @@ -173,7 +176,7 @@ _mm512_mask_and_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_maskz_and_ps (__mmask16 __U, __m512 __A, __m512 __B) { return (__m512) __builtin_ia32_andps512_mask ((__v16sf) __A, (__v16sf) __B, @@ -182,7 +185,7 @@ _mm512_maskz_and_ps (__mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_andnot_pd (__m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_andnpd512_mask ((__v8df) __A, (__v8df) __B, @@ -191,7 +194,7 @@ _mm512_andnot_pd (__m512d __A, __m512d __B) { (__mmask8) -1); } -static __inline__ __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_mask_andnot_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_andnpd512_mask ((__v8df) __A, (__v8df) __B, @@ -199,7 +202,7 @@ _mm512_mask_andnot_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_maskz_andnot_pd (__mmask8 __U, __m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_andnpd512_mask ((__v8df) __A, (__v8df) __B, @@ -208,7 +211,7 @@ _mm512_maskz_andnot_pd (__mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_andnot_ps (__m512 __A, __m512 __B) { return (__m512) __builtin_ia32_andnps512_mask ((__v16sf) __A, (__v16sf) __B, @@ -217,7 +220,7 @@ _mm512_andnot_ps (__m512 __A, __m512 __B) { (__mmask16) -1); } -static __inline__ __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_mask_andnot_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { return (__m512) __builtin_ia32_andnps512_mask ((__v16sf) __A, (__v16sf) __B, @@ -225,7 +228,7 @@ _mm512_mask_andnot_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_maskz_andnot_ps (__mmask16 __U, __m512 __A, __m512 __B) { return (__m512) __builtin_ia32_andnps512_mask ((__v16sf) __A, (__v16sf) __B, @@ -234,4 +237,6 @@ _mm512_maskz_andnot_ps (__mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } +#undef DEFAULT_FN_ATTRS + #endif diff --git a/lib/Headers/avx512erintrin.h b/lib/Headers/avx512erintrin.h index 57c61aa0e112..56edffc11ca8 100644 --- a/lib/Headers/avx512erintrin.h +++ b/lib/Headers/avx512erintrin.h @@ -27,7 +27,6 @@ #ifndef __AVX512ERINTRIN_H #define __AVX512ERINTRIN_H - // exp2a23 #define _mm512_exp2a23_round_pd(A, R) __extension__ ({ \ (__m512d)__builtin_ia32_exp2pd_mask((__v8df)(__m512d)(A), \ diff --git a/lib/Headers/avx512fintrin.h b/lib/Headers/avx512fintrin.h index d299704d9b2b..98eb73b3113f 100644 --- a/lib/Headers/avx512fintrin.h +++ b/lib/Headers/avx512fintrin.h @@ -46,15 +46,18 @@ typedef unsigned short __mmask16; #define _MM_FROUND_TO_ZERO 0x03 #define _MM_FROUND_CUR_DIRECTION 0x04 +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512f"))) + /* Create vectors with repeated elements */ -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_setzero_si512(void) { return (__m512i)(__v8di){ 0, 0, 0, 0, 0, 0, 0, 0 }; } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_maskz_set1_epi32(__mmask16 __M, int __A) { return (__m512i) __builtin_ia32_pbroadcastd512_gpr_mask (__A, @@ -63,7 +66,7 @@ _mm512_maskz_set1_epi32(__mmask16 __M, int __A) __M); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_maskz_set1_epi64(__mmask8 __M, long long __A) { #ifdef __x86_64__ @@ -79,45 +82,45 @@ _mm512_maskz_set1_epi64(__mmask8 __M, long long __A) #endif } -static __inline __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_setzero_ps(void) { return (__m512){ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }; } -static __inline __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_setzero_pd(void) { return (__m512d){ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }; } -static __inline __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_set1_ps(float __w) { return (__m512){ __w, __w, __w, __w, __w, __w, __w, __w, __w, __w, __w, __w, __w, __w, __w, __w }; } -static __inline __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_set1_pd(double __w) { return (__m512d){ __w, __w, __w, __w, __w, __w, __w, __w }; } -static __inline __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_set1_epi32(int __s) { return (__m512i)(__v16si){ __s, __s, __s, __s, __s, __s, __s, __s, __s, __s, __s, __s, __s, __s, __s, __s }; } -static __inline __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_set1_epi64(long long __d) { return (__m512i)(__v8di){ __d, __d, __d, __d, __d, __d, __d, __d }; } -static __inline__ __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_broadcastss_ps(__m128 __X) { float __f = __X[0]; @@ -127,7 +130,7 @@ _mm512_broadcastss_ps(__m128 __X) __f, __f, __f, __f }; } -static __inline__ __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_broadcastsd_pd(__m128d __X) { double __d = __X[0]; @@ -137,39 +140,39 @@ _mm512_broadcastsd_pd(__m128d __X) /* Cast between vector types */ -static __inline __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_castpd256_pd512(__m256d __a) { return __builtin_shufflevector(__a, __a, 0, 1, 2, 3, -1, -1, -1, -1); } -static __inline __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_castps256_ps512(__m256 __a) { return __builtin_shufflevector(__a, __a, 0, 1, 2, 3, 4, 5, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1); } -static __inline __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline __m128d DEFAULT_FN_ATTRS _mm512_castpd512_pd128(__m512d __a) { return __builtin_shufflevector(__a, __a, 0, 1); } -static __inline __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline __m128 DEFAULT_FN_ATTRS _mm512_castps512_ps128(__m512 __a) { return __builtin_shufflevector(__a, __a, 0, 1, 2, 3); } /* Bitwise operators */ -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_and_epi32(__m512i __a, __m512i __b) { return __a & __b; } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_and_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pandd512_mask((__v16si) __a, @@ -177,7 +180,7 @@ _mm512_mask_and_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b) (__v16si) __src, (__mmask16) __k); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_and_epi32(__mmask16 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pandd512_mask((__v16si) __a, @@ -187,13 +190,13 @@ _mm512_maskz_and_epi32(__mmask16 __k, __m512i __a, __m512i __b) (__mmask16) __k); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_and_epi64(__m512i __a, __m512i __b) { return __a & __b; } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_and_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pandq512_mask ((__v8di) __a, @@ -201,7 +204,7 @@ _mm512_mask_and_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b) (__v8di) __src, (__mmask8) __k); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_and_epi64(__mmask8 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pandq512_mask ((__v8di) __a, @@ -211,7 +214,7 @@ _mm512_maskz_and_epi64(__mmask8 __k, __m512i __a, __m512i __b) (__mmask8) __k); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_andnot_epi32 (__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pandnd512_mask ((__v16si) __A, @@ -221,7 +224,7 @@ _mm512_andnot_epi32 (__m512i __A, __m512i __B) (__mmask16) -1); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_andnot_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pandnd512_mask ((__v16si) __A, @@ -230,7 +233,7 @@ _mm512_mask_andnot_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) (__mmask16) __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_andnot_epi32 (__mmask16 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pandnd512_mask ((__v16si) __A, @@ -240,7 +243,7 @@ _mm512_maskz_andnot_epi32 (__mmask16 __U, __m512i __A, __m512i __B) (__mmask16) __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_andnot_epi64 (__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pandnq512_mask ((__v8di) __A, @@ -250,7 +253,7 @@ _mm512_andnot_epi64 (__m512i __A, __m512i __B) (__mmask8) -1); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_andnot_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pandnq512_mask ((__v8di) __A, @@ -258,7 +261,7 @@ _mm512_mask_andnot_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) (__v8di) __W, __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_andnot_epi64 (__mmask8 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pandnq512_mask ((__v8di) __A, @@ -267,13 +270,13 @@ _mm512_maskz_andnot_epi64 (__mmask8 __U, __m512i __A, __m512i __B) _mm512_setzero_pd (), __U); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_or_epi32(__m512i __a, __m512i __b) { return __a | __b; } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_or_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pord512_mask((__v16si) __a, @@ -281,7 +284,7 @@ _mm512_mask_or_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b) (__v16si) __src, (__mmask16) __k); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_or_epi32(__mmask16 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pord512_mask((__v16si) __a, @@ -291,13 +294,13 @@ _mm512_maskz_or_epi32(__mmask16 __k, __m512i __a, __m512i __b) (__mmask16) __k); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_or_epi64(__m512i __a, __m512i __b) { return __a | __b; } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_or_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_porq512_mask ((__v8di) __a, @@ -305,7 +308,7 @@ _mm512_mask_or_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b) (__v8di) __src, (__mmask8) __k); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_or_epi64(__mmask8 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_porq512_mask ((__v8di) __a, @@ -315,13 +318,13 @@ _mm512_maskz_or_epi64(__mmask8 __k, __m512i __a, __m512i __b) (__mmask8) __k); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_xor_epi32(__m512i __a, __m512i __b) { return __a ^ __b; } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_xor_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pxord512_mask((__v16si) __a, @@ -329,7 +332,7 @@ _mm512_mask_xor_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b) (__v16si) __src, (__mmask16) __k); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_xor_epi32(__mmask16 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pxord512_mask((__v16si) __a, @@ -339,13 +342,13 @@ _mm512_maskz_xor_epi32(__mmask16 __k, __m512i __a, __m512i __b) (__mmask16) __k); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_xor_epi64(__m512i __a, __m512i __b) { return __a ^ __b; } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_xor_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pxorq512_mask ((__v8di) __a, @@ -353,7 +356,7 @@ _mm512_mask_xor_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b) (__v8di) __src, (__mmask8) __k); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_xor_epi64(__mmask8 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pxorq512_mask ((__v8di) __a, @@ -363,68 +366,68 @@ _mm512_maskz_xor_epi64(__mmask8 __k, __m512i __a, __m512i __b) (__mmask8) __k); } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_and_si512(__m512i __a, __m512i __b) { return __a & __b; } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_or_si512(__m512i __a, __m512i __b) { return __a | __b; } -static __inline__ __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_xor_si512(__m512i __a, __m512i __b) { return __a ^ __b; } /* Arithmetic */ -static __inline __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_add_pd(__m512d __a, __m512d __b) { return __a + __b; } -static __inline __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_add_ps(__m512 __a, __m512 __b) { return __a + __b; } -static __inline __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_mul_pd(__m512d __a, __m512d __b) { return __a * __b; } -static __inline __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_mul_ps(__m512 __a, __m512 __b) { return __a * __b; } -static __inline __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_sub_pd(__m512d __a, __m512d __b) { return __a - __b; } -static __inline __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_sub_ps(__m512 __a, __m512 __b) { return __a - __b; } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_add_epi64 (__m512i __A, __m512i __B) { return (__m512i) ((__v8di) __A + (__v8di) __B); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_add_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_paddq512_mask ((__v8di) __A, @@ -433,7 +436,7 @@ _mm512_mask_add_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) (__mmask8) __U); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_add_epi64 (__mmask8 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_paddq512_mask ((__v8di) __A, @@ -443,13 +446,13 @@ _mm512_maskz_add_epi64 (__mmask8 __U, __m512i __A, __m512i __B) (__mmask8) __U); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_sub_epi64 (__m512i __A, __m512i __B) { return (__m512i) ((__v8di) __A - (__v8di) __B); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_sub_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_psubq512_mask ((__v8di) __A, @@ -458,7 +461,7 @@ _mm512_mask_sub_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) (__mmask8) __U); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_sub_epi64 (__mmask8 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_psubq512_mask ((__v8di) __A, @@ -468,13 +471,13 @@ _mm512_maskz_sub_epi64 (__mmask8 __U, __m512i __A, __m512i __B) (__mmask8) __U); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_add_epi32 (__m512i __A, __m512i __B) { return (__m512i) ((__v16si) __A + (__v16si) __B); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_add_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_paddd512_mask ((__v16si) __A, @@ -483,7 +486,7 @@ _mm512_mask_add_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) (__mmask16) __U); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_add_epi32 (__mmask16 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_paddd512_mask ((__v16si) __A, @@ -493,13 +496,13 @@ _mm512_maskz_add_epi32 (__mmask16 __U, __m512i __A, __m512i __B) (__mmask16) __U); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_sub_epi32 (__m512i __A, __m512i __B) { return (__m512i) ((__v16si) __A - (__v16si) __B); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_mask_sub_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_psubd512_mask ((__v16si) __A, @@ -508,7 +511,7 @@ _mm512_mask_sub_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) (__mmask16) __U); } -static __inline__ __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m512i DEFAULT_FN_ATTRS _mm512_maskz_sub_epi32 (__mmask16 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_psubd512_mask ((__v16si) __A, @@ -518,7 +521,7 @@ _mm512_maskz_sub_epi32 (__mmask16 __U, __m512i __A, __m512i __B) (__mmask16) __U); } -static __inline__ __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_max_pd(__m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_maxpd512_mask ((__v8df) __A, @@ -529,7 +532,7 @@ _mm512_max_pd(__m512d __A, __m512d __B) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_max_ps(__m512 __A, __m512 __B) { return (__m512) __builtin_ia32_maxps512_mask ((__v16sf) __A, @@ -541,7 +544,7 @@ _mm512_max_ps(__m512 __A, __m512 __B) } static __inline __m512i -__attribute__ ((__always_inline__, __nodebug__)) +DEFAULT_FN_ATTRS _mm512_max_epi32(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmaxsd512_mask ((__v16si) __A, @@ -551,7 +554,7 @@ _mm512_max_epi32(__m512i __A, __m512i __B) (__mmask16) -1); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_max_epu32(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmaxud512_mask ((__v16si) __A, @@ -561,7 +564,7 @@ _mm512_max_epu32(__m512i __A, __m512i __B) (__mmask16) -1); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_max_epi64(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmaxsq512_mask ((__v8di) __A, @@ -571,7 +574,7 @@ _mm512_max_epi64(__m512i __A, __m512i __B) (__mmask8) -1); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_max_epu64(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmaxuq512_mask ((__v8di) __A, @@ -581,7 +584,7 @@ _mm512_max_epu64(__m512i __A, __m512i __B) (__mmask8) -1); } -static __inline__ __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_min_pd(__m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_minpd512_mask ((__v8df) __A, @@ -592,7 +595,7 @@ _mm512_min_pd(__m512d __A, __m512d __B) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_min_ps(__m512 __A, __m512 __B) { return (__m512) __builtin_ia32_minps512_mask ((__v16sf) __A, @@ -604,7 +607,7 @@ _mm512_min_ps(__m512 __A, __m512 __B) } static __inline __m512i -__attribute__ ((__always_inline__, __nodebug__)) +DEFAULT_FN_ATTRS _mm512_min_epi32(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pminsd512_mask ((__v16si) __A, @@ -614,7 +617,7 @@ _mm512_min_epi32(__m512i __A, __m512i __B) (__mmask16) -1); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_min_epu32(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pminud512_mask ((__v16si) __A, @@ -624,7 +627,7 @@ _mm512_min_epu32(__m512i __A, __m512i __B) (__mmask16) -1); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_min_epi64(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pminsq512_mask ((__v8di) __A, @@ -634,7 +637,7 @@ _mm512_min_epi64(__m512i __A, __m512i __B) (__mmask8) -1); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_min_epu64(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pminuq512_mask ((__v8di) __A, @@ -644,7 +647,7 @@ _mm512_min_epu64(__m512i __A, __m512i __B) (__mmask8) -1); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_mul_epi32(__m512i __X, __m512i __Y) { return (__m512i) __builtin_ia32_pmuldq512_mask ((__v16si) __X, @@ -654,7 +657,7 @@ _mm512_mul_epi32(__m512i __X, __m512i __Y) (__mmask8) -1); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_mask_mul_epi32 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y) { return (__m512i) __builtin_ia32_pmuldq512_mask ((__v16si) __X, @@ -662,7 +665,7 @@ _mm512_mask_mul_epi32 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y) (__v8di) __W, __M); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_maskz_mul_epi32 (__mmask8 __M, __m512i __X, __m512i __Y) { return (__m512i) __builtin_ia32_pmuldq512_mask ((__v16si) __X, @@ -672,7 +675,7 @@ _mm512_maskz_mul_epi32 (__mmask8 __M, __m512i __X, __m512i __Y) __M); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_mul_epu32(__m512i __X, __m512i __Y) { return (__m512i) __builtin_ia32_pmuludq512_mask ((__v16si) __X, @@ -682,7 +685,7 @@ _mm512_mul_epu32(__m512i __X, __m512i __Y) (__mmask8) -1); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_mask_mul_epu32 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y) { return (__m512i) __builtin_ia32_pmuludq512_mask ((__v16si) __X, @@ -690,7 +693,7 @@ _mm512_mask_mul_epu32 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y) (__v8di) __W, __M); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_maskz_mul_epu32 (__mmask8 __M, __m512i __X, __m512i __Y) { return (__m512i) __builtin_ia32_pmuludq512_mask ((__v16si) __X, @@ -700,13 +703,13 @@ _mm512_maskz_mul_epu32 (__mmask8 __M, __m512i __X, __m512i __Y) __M); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_mullo_epi32 (__m512i __A, __m512i __B) { return (__m512i) ((__v16si) __A * (__v16si) __B); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_maskz_mullo_epi32 (__mmask16 __M, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmulld512_mask ((__v16si) __A, @@ -716,7 +719,7 @@ _mm512_maskz_mullo_epi32 (__mmask16 __M, __m512i __A, __m512i __B) __M); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_mask_mullo_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmulld512_mask ((__v16si) __A, @@ -724,7 +727,7 @@ _mm512_mask_mullo_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B) (__v16si) __W, __M); } -static __inline__ __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_sqrt_pd(__m512d a) { return (__m512d)__builtin_ia32_sqrtpd512_mask((__v8df)a, @@ -733,7 +736,7 @@ _mm512_sqrt_pd(__m512d a) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_sqrt_ps(__m512 a) { return (__m512)__builtin_ia32_sqrtps512_mask((__v16sf)a, @@ -742,7 +745,7 @@ _mm512_sqrt_ps(__m512 a) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_rsqrt14_pd(__m512d __A) { return (__m512d) __builtin_ia32_rsqrt14pd512_mask ((__v8df) __A, @@ -750,7 +753,7 @@ _mm512_rsqrt14_pd(__m512d __A) _mm512_setzero_pd (), (__mmask8) -1);} -static __inline__ __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_rsqrt14_ps(__m512 __A) { return (__m512) __builtin_ia32_rsqrt14ps512_mask ((__v16sf) __A, @@ -759,7 +762,7 @@ _mm512_rsqrt14_ps(__m512 __A) (__mmask16) -1); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_rsqrt14_ss(__m128 __A, __m128 __B) { return (__m128) __builtin_ia32_rsqrt14ss_mask ((__v4sf) __A, @@ -769,7 +772,7 @@ _mm_rsqrt14_ss(__m128 __A, __m128 __B) (__mmask8) -1); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_rsqrt14_sd(__m128d __A, __m128d __B) { return (__m128d) __builtin_ia32_rsqrt14sd_mask ((__v2df) __A, @@ -779,7 +782,7 @@ _mm_rsqrt14_sd(__m128d __A, __m128d __B) (__mmask8) -1); } -static __inline__ __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_rcp14_pd(__m512d __A) { return (__m512d) __builtin_ia32_rcp14pd512_mask ((__v8df) __A, @@ -788,7 +791,7 @@ _mm512_rcp14_pd(__m512d __A) (__mmask8) -1); } -static __inline__ __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_rcp14_ps(__m512 __A) { return (__m512) __builtin_ia32_rcp14ps512_mask ((__v16sf) __A, @@ -796,7 +799,7 @@ _mm512_rcp14_ps(__m512 __A) _mm512_setzero_ps (), (__mmask16) -1); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_rcp14_ss(__m128 __A, __m128 __B) { return (__m128) __builtin_ia32_rcp14ss_mask ((__v4sf) __A, @@ -806,7 +809,7 @@ _mm_rcp14_ss(__m128 __A, __m128 __B) (__mmask8) -1); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_rcp14_sd(__m128d __A, __m128d __B) { return (__m128d) __builtin_ia32_rcp14sd_mask ((__v2df) __A, @@ -816,7 +819,7 @@ _mm_rcp14_sd(__m128d __A, __m128d __B) (__mmask8) -1); } -static __inline __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_floor_ps(__m512 __A) { return (__m512) __builtin_ia32_rndscaleps_mask ((__v16sf) __A, @@ -825,7 +828,7 @@ _mm512_floor_ps(__m512 __A) _MM_FROUND_CUR_DIRECTION); } -static __inline __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_floor_pd(__m512d __A) { return (__m512d) __builtin_ia32_rndscalepd_mask ((__v8df) __A, @@ -834,7 +837,7 @@ _mm512_floor_pd(__m512d __A) _MM_FROUND_CUR_DIRECTION); } -static __inline __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_ceil_ps(__m512 __A) { return (__m512) __builtin_ia32_rndscaleps_mask ((__v16sf) __A, @@ -843,7 +846,7 @@ _mm512_ceil_ps(__m512 __A) _MM_FROUND_CUR_DIRECTION); } -static __inline __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_ceil_pd(__m512d __A) { return (__m512d) __builtin_ia32_rndscalepd_mask ((__v8df) __A, @@ -852,7 +855,7 @@ _mm512_ceil_pd(__m512d __A) _MM_FROUND_CUR_DIRECTION); } -static __inline __m512i __attribute__ (( __always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_abs_epi64(__m512i __A) { return (__m512i) __builtin_ia32_pabsq512_mask ((__v8di) __A, @@ -861,7 +864,7 @@ _mm512_abs_epi64(__m512i __A) (__mmask8) -1); } -static __inline __m512i __attribute__ (( __always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_abs_epi32(__m512i __A) { return (__m512i) __builtin_ia32_pabsd512_mask ((__v16si) __A, @@ -878,7 +881,7 @@ _mm512_abs_epi32(__m512i __A) (__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(A), (B), (__v8df)(A), \ -1, _MM_FROUND_CUR_DIRECTION); }) -static __inline__ __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_fmadd_pd(__m512d __A, __m512d __B, __m512d __C) { return (__m512d) @@ -889,7 +892,7 @@ _mm512_fmadd_pd(__m512d __A, __m512d __B, __m512d __C) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_fmsub_pd(__m512d __A, __m512d __B, __m512d __C) { return (__m512d) @@ -900,7 +903,7 @@ _mm512_fmsub_pd(__m512d __A, __m512d __B, __m512d __C) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512d DEFAULT_FN_ATTRS _mm512_fnmadd_pd(__m512d __A, __m512d __B, __m512d __C) { return (__m512d) @@ -911,7 +914,7 @@ _mm512_fnmadd_pd(__m512d __A, __m512d __B, __m512d __C) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_fmadd_ps(__m512 __A, __m512 __B, __m512 __C) { return (__m512) @@ -922,7 +925,7 @@ _mm512_fmadd_ps(__m512 __A, __m512 __B, __m512 __C) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_fmsub_ps(__m512 __A, __m512 __B, __m512 __C) { return (__m512) @@ -933,7 +936,7 @@ _mm512_fmsub_ps(__m512 __A, __m512 __B, __m512 __C) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m512 DEFAULT_FN_ATTRS _mm512_fnmadd_ps(__m512 __A, __m512 __B, __m512 __C) { return (__m512) @@ -946,7 +949,7 @@ _mm512_fnmadd_ps(__m512 __A, __m512 __B, __m512 __C) /* Vector permutations */ -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_permutex2var_epi32(__m512i __A, __m512i __I, __m512i __B) { return (__m512i) __builtin_ia32_vpermt2vard512_mask ((__v16si) __I @@ -955,7 +958,7 @@ _mm512_permutex2var_epi32(__m512i __A, __m512i __I, __m512i __B) (__v16si) __B, (__mmask16) -1); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_permutex2var_epi64(__m512i __A, __m512i __I, __m512i __B) { return (__m512i) __builtin_ia32_vpermt2varq512_mask ((__v8di) __I @@ -965,7 +968,7 @@ _mm512_permutex2var_epi64(__m512i __A, __m512i __I, __m512i __B) (__mmask8) -1); } -static __inline __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_permutex2var_pd(__m512d __A, __m512i __I, __m512d __B) { return (__m512d) __builtin_ia32_vpermt2varpd512_mask ((__v8di) __I @@ -974,7 +977,7 @@ _mm512_permutex2var_pd(__m512d __A, __m512i __I, __m512d __B) (__v8df) __B, (__mmask8) -1); } -static __inline __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_permutex2var_ps(__m512 __A, __m512i __I, __m512 __B) { return (__m512) __builtin_ia32_vpermt2varps512_mask ((__v16si) __I @@ -1016,7 +1019,7 @@ _mm512_permutex2var_ps(__m512 __A, __m512i __I, __m512 __B) /* Vector Blend */ -static __inline __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_mask_blend_pd(__mmask8 __U, __m512d __A, __m512d __W) { return (__m512d) __builtin_ia32_blendmpd_512_mask ((__v8df) __A, @@ -1024,7 +1027,7 @@ _mm512_mask_blend_pd(__mmask8 __U, __m512d __A, __m512d __W) (__mmask8) __U); } -static __inline __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_mask_blend_ps(__mmask16 __U, __m512 __A, __m512 __W) { return (__m512) __builtin_ia32_blendmps_512_mask ((__v16sf) __A, @@ -1032,7 +1035,7 @@ _mm512_mask_blend_ps(__mmask16 __U, __m512 __A, __m512 __W) (__mmask16) __U); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_mask_blend_epi64(__mmask8 __U, __m512i __A, __m512i __W) { return (__m512i) __builtin_ia32_blendmq_512_mask ((__v8di) __A, @@ -1040,7 +1043,7 @@ _mm512_mask_blend_epi64(__mmask8 __U, __m512i __A, __m512i __W) (__mmask8) __U); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_mask_blend_epi32(__mmask16 __U, __m512i __A, __m512i __W) { return (__m512i) __builtin_ia32_blendmd_512_mask ((__v16si) __A, @@ -1084,7 +1087,7 @@ _mm512_mask_blend_epi32(__mmask16 __U, __m512i __A, __m512i __W) /* Conversion */ -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_cvttps_epu32(__m512 __A) { return (__m512i) __builtin_ia32_cvttps2udq512_mask ((__v16sf) __A, @@ -1104,7 +1107,7 @@ _mm512_cvttps_epu32(__m512 __A) (__v16sf)_mm512_setzero_ps(), \ (__mmask16)-1, (R)); }) -static __inline __m512d __attribute__ (( __always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_cvtepi32_pd(__m256i __A) { return (__m512d) __builtin_ia32_cvtdq2pd512_mask ((__v8si) __A, @@ -1113,7 +1116,7 @@ _mm512_cvtepi32_pd(__m256i __A) (__mmask8) -1); } -static __inline __m512d __attribute__ (( __always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_cvtepu32_pd(__m256i __A) { return (__m512d) __builtin_ia32_cvtudq2pd512_mask ((__v8si) __A, @@ -1132,7 +1135,7 @@ _mm512_cvtepu32_pd(__m256i __A) (__v16hi)_mm256_setzero_si256(), \ -1); }) -static __inline __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_cvtph_ps(__m256i __A) { return (__m512) __builtin_ia32_vcvtph2ps512_mask ((__v16hi) __A, @@ -1142,7 +1145,7 @@ _mm512_cvtph_ps(__m256i __A) _MM_FROUND_CUR_DIRECTION); } -static __inline __m512i __attribute__((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_cvttps_epi32(__m512 a) { return (__m512i) @@ -1151,7 +1154,7 @@ _mm512_cvttps_epi32(__m512 a) (__mmask16) -1, _MM_FROUND_CUR_DIRECTION); } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm512_cvttpd_epi32(__m512d a) { return (__m256i)__builtin_ia32_cvttpd2dq512_mask((__v8df) a, @@ -1191,19 +1194,19 @@ _mm512_cvttpd_epi32(__m512d a) (__mmask8) -1, (R)); }) /* Unpack and Interleave */ -static __inline __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_unpackhi_pd(__m512d __a, __m512d __b) { return __builtin_shufflevector(__a, __b, 1, 9, 1+2, 9+2, 1+4, 9+4, 1+6, 9+6); } -static __inline __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_unpacklo_pd(__m512d __a, __m512d __b) { return __builtin_shufflevector(__a, __b, 0, 8, 0+2, 8+2, 0+4, 8+4, 0+6, 8+6); } -static __inline __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_unpackhi_ps(__m512 __a, __m512 __b) { return __builtin_shufflevector(__a, __b, @@ -1213,7 +1216,7 @@ _mm512_unpackhi_ps(__m512 __a, __m512 __b) 2+12, 18+12, 3+12, 19+12); } -static __inline __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_unpacklo_ps(__m512 __a, __m512 __b) { return __builtin_shufflevector(__a, __b, @@ -1225,7 +1228,7 @@ _mm512_unpacklo_ps(__m512 __a, __m512 __b) /* Bit Test */ -static __inline __mmask16 __attribute__ ((__always_inline__, __nodebug__)) +static __inline __mmask16 DEFAULT_FN_ATTRS _mm512_test_epi32_mask(__m512i __A, __m512i __B) { return (__mmask16) __builtin_ia32_ptestmd512 ((__v16si) __A, @@ -1233,7 +1236,7 @@ _mm512_test_epi32_mask(__m512i __A, __m512i __B) (__mmask16) -1); } -static __inline __mmask8 __attribute__ ((__always_inline__, __nodebug__)) +static __inline __mmask8 DEFAULT_FN_ATTRS _mm512_test_epi64_mask(__m512i __A, __m512i __B) { return (__mmask8) __builtin_ia32_ptestmq512 ((__v8di) __A, @@ -1243,7 +1246,7 @@ _mm512_test_epi64_mask(__m512i __A, __m512i __B) /* SIMD load ops */ -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_maskz_loadu_epi32(__mmask16 __U, void const *__P) { return (__m512i) __builtin_ia32_loaddqusi512_mask ((const __v16si *)__P, @@ -1252,7 +1255,7 @@ _mm512_maskz_loadu_epi32(__mmask16 __U, void const *__P) (__mmask16) __U); } -static __inline __m512i __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512i DEFAULT_FN_ATTRS _mm512_maskz_loadu_epi64(__mmask8 __U, void const *__P) { return (__m512i) __builtin_ia32_loaddqudi512_mask ((const __v8di *)__P, @@ -1261,7 +1264,7 @@ _mm512_maskz_loadu_epi64(__mmask8 __U, void const *__P) (__mmask8) __U); } -static __inline __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_maskz_loadu_ps(__mmask16 __U, void const *__P) { return (__m512) __builtin_ia32_loadups512_mask ((const __v16sf *)__P, @@ -1270,7 +1273,7 @@ _mm512_maskz_loadu_ps(__mmask16 __U, void const *__P) (__mmask16) __U); } -static __inline __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_maskz_loadu_pd(__mmask8 __U, void const *__P) { return (__m512d) __builtin_ia32_loadupd512_mask ((const __v8df *)__P, @@ -1279,7 +1282,7 @@ _mm512_maskz_loadu_pd(__mmask8 __U, void const *__P) (__mmask8) __U); } -static __inline __m512 __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_maskz_load_ps(__mmask16 __U, void const *__P) { return (__m512) __builtin_ia32_loadaps512_mask ((const __v16sf *)__P, @@ -1288,7 +1291,7 @@ _mm512_maskz_load_ps(__mmask16 __U, void const *__P) (__mmask16) __U); } -static __inline __m512d __attribute__ ((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_maskz_load_pd(__mmask8 __U, void const *__P) { return (__m512d) __builtin_ia32_loadapd512_mask ((const __v8df *)__P, @@ -1297,7 +1300,7 @@ _mm512_maskz_load_pd(__mmask8 __U, void const *__P) (__mmask8) __U); } -static __inline __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_loadu_pd(double const *__p) { struct __loadu_pd { @@ -1306,7 +1309,7 @@ _mm512_loadu_pd(double const *__p) return ((struct __loadu_pd*)__p)->__v; } -static __inline __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_loadu_ps(float const *__p) { struct __loadu_ps { @@ -1315,7 +1318,7 @@ _mm512_loadu_ps(float const *__p) return ((struct __loadu_ps*)__p)->__v; } -static __inline __m512 __attribute__((__always_inline__, __nodebug__)) +static __inline __m512 DEFAULT_FN_ATTRS _mm512_load_ps(double const *__p) { return (__m512) __builtin_ia32_loadaps512_mask ((const __v16sf *)__p, @@ -1324,7 +1327,7 @@ _mm512_load_ps(double const *__p) (__mmask16) -1); } -static __inline __m512d __attribute__((__always_inline__, __nodebug__)) +static __inline __m512d DEFAULT_FN_ATTRS _mm512_load_pd(float const *__p) { return (__m512d) __builtin_ia32_loadapd512_mask ((const __v8df *)__p, @@ -1335,65 +1338,65 @@ _mm512_load_pd(float const *__p) /* SIMD store ops */ -static __inline void __attribute__ ((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm512_mask_storeu_epi64(void *__P, __mmask8 __U, __m512i __A) { __builtin_ia32_storedqudi512_mask ((__v8di *)__P, (__v8di) __A, (__mmask8) __U); } -static __inline void __attribute__ ((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm512_mask_storeu_epi32(void *__P, __mmask16 __U, __m512i __A) { __builtin_ia32_storedqusi512_mask ((__v16si *)__P, (__v16si) __A, (__mmask16) __U); } -static __inline void __attribute__ ((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm512_mask_storeu_pd(void *__P, __mmask8 __U, __m512d __A) { __builtin_ia32_storeupd512_mask ((__v8df *)__P, (__v8df) __A, (__mmask8) __U); } -static __inline void __attribute__ ((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm512_storeu_pd(void *__P, __m512d __A) { __builtin_ia32_storeupd512_mask((__v8df *)__P, (__v8df)__A, (__mmask8)-1); } -static __inline void __attribute__ ((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm512_mask_storeu_ps(void *__P, __mmask16 __U, __m512 __A) { __builtin_ia32_storeups512_mask ((__v16sf *)__P, (__v16sf) __A, (__mmask16) __U); } -static __inline void __attribute__ ((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm512_storeu_ps(void *__P, __m512 __A) { __builtin_ia32_storeups512_mask((__v16sf *)__P, (__v16sf)__A, (__mmask16)-1); } -static __inline void __attribute__ ((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm512_mask_store_pd(void *__P, __mmask8 __U, __m512d __A) { __builtin_ia32_storeapd512_mask ((__v8df *)__P, (__v8df) __A, (__mmask8) __U); } -static __inline void __attribute__ ((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm512_store_pd(void *__P, __m512d __A) { *(__m512d*)__P = __A; } -static __inline void __attribute__ ((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm512_mask_store_ps(void *__P, __mmask16 __U, __m512 __A) { __builtin_ia32_storeaps512_mask ((__v16sf *)__P, (__v16sf) __A, (__mmask16) __U); } -static __inline void __attribute__ ((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm512_store_ps(void *__P, __m512 __A) { *(__m512*)__P = __A; @@ -1401,7 +1404,7 @@ _mm512_store_ps(void *__P, __m512 __A) /* Mask ops */ -static __inline __mmask16 __attribute__ ((__always_inline__, __nodebug__)) +static __inline __mmask16 DEFAULT_FN_ATTRS _mm512_knot(__mmask16 __M) { return __builtin_ia32_knothi(__M); @@ -1409,289 +1412,289 @@ _mm512_knot(__mmask16 __M) /* Integer compare */ -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_cmpeq_epi32_mask(__m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_pcmpeqd512_mask((__v16si)__a, (__v16si)__b, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_mask_cmpeq_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_pcmpeqd512_mask((__v16si)__a, (__v16si)__b, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_cmpeq_epu32_mask(__m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)__a, (__v16si)__b, 0, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_mask_cmpeq_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)__a, (__v16si)__b, 0, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_mask_cmpeq_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_pcmpeqq512_mask((__v8di)__a, (__v8di)__b, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_cmpeq_epi64_mask(__m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_pcmpeqq512_mask((__v8di)__a, (__v8di)__b, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_cmpeq_epu64_mask(__m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, 0, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_mask_cmpeq_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, 0, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_cmpge_epi32_mask(__m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_cmpd512_mask((__v16si)__a, (__v16si)__b, 5, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_mask_cmpge_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_cmpd512_mask((__v16si)__a, (__v16si)__b, 5, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_cmpge_epu32_mask(__m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)__a, (__v16si)__b, 5, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_mask_cmpge_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)__a, (__v16si)__b, 5, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_cmpge_epi64_mask(__m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_cmpq512_mask((__v8di)__a, (__v8di)__b, 5, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_mask_cmpge_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_cmpq512_mask((__v8di)__a, (__v8di)__b, 5, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_cmpge_epu64_mask(__m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, 5, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_mask_cmpge_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, 5, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_cmpgt_epi32_mask(__m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_pcmpgtd512_mask((__v16si)__a, (__v16si)__b, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_mask_cmpgt_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_pcmpgtd512_mask((__v16si)__a, (__v16si)__b, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_cmpgt_epu32_mask(__m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)__a, (__v16si)__b, 6, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_mask_cmpgt_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)__a, (__v16si)__b, 6, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_mask_cmpgt_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_pcmpgtq512_mask((__v8di)__a, (__v8di)__b, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_cmpgt_epi64_mask(__m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_pcmpgtq512_mask((__v8di)__a, (__v8di)__b, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_cmpgt_epu64_mask(__m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, 6, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_mask_cmpgt_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, 6, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_cmple_epi32_mask(__m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_cmpd512_mask((__v16si)__a, (__v16si)__b, 2, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_mask_cmple_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_cmpd512_mask((__v16si)__a, (__v16si)__b, 2, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_cmple_epu32_mask(__m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)__a, (__v16si)__b, 2, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_mask_cmple_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)__a, (__v16si)__b, 2, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_cmple_epi64_mask(__m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_cmpq512_mask((__v8di)__a, (__v8di)__b, 2, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_mask_cmple_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_cmpq512_mask((__v8di)__a, (__v8di)__b, 2, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_cmple_epu64_mask(__m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, 2, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_mask_cmple_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, 2, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_cmplt_epi32_mask(__m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_cmpd512_mask((__v16si)__a, (__v16si)__b, 1, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_mask_cmplt_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_cmpd512_mask((__v16si)__a, (__v16si)__b, 1, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_cmplt_epu32_mask(__m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)__a, (__v16si)__b, 1, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_mask_cmplt_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)__a, (__v16si)__b, 1, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_cmplt_epi64_mask(__m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_cmpq512_mask((__v8di)__a, (__v8di)__b, 1, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_mask_cmplt_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_cmpq512_mask((__v8di)__a, (__v8di)__b, 1, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_cmplt_epu64_mask(__m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, 1, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_mask_cmplt_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, 1, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_cmpneq_epi32_mask(__m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_cmpd512_mask((__v16si)__a, (__v16si)__b, 4, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_mask_cmpneq_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_cmpd512_mask((__v16si)__a, (__v16si)__b, 4, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_cmpneq_epu32_mask(__m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)__a, (__v16si)__b, 4, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm512_mask_cmpneq_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { return (__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)__a, (__v16si)__b, 4, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_cmpneq_epi64_mask(__m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_cmpq512_mask((__v8di)__a, (__v8di)__b, 4, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_mask_cmpneq_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_cmpq512_mask((__v8di)__a, (__v8di)__b, 4, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_cmpneq_epu64_mask(__m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, 4, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm512_mask_cmpneq_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { return (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, 4, __u); @@ -1744,4 +1747,7 @@ _mm512_mask_cmpneq_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { __m512i __b = (b); \ (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, (p), \ (__mmask8)(m)); }) + +#undef DEFAULT_FN_ATTRS + #endif // __AVX512FINTRIN_H diff --git a/lib/Headers/avx512vlbwintrin.h b/lib/Headers/avx512vlbwintrin.h index c3b087e303b4..1fbffd42cf0c 100644 --- a/lib/Headers/avx512vlbwintrin.h +++ b/lib/Headers/avx512vlbwintrin.h @@ -28,585 +28,588 @@ #ifndef __AVX512VLBWINTRIN_H #define __AVX512VLBWINTRIN_H +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512vl,avx512bw"))) + /* Integer compare */ -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_cmpeq_epi8_mask(__m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_pcmpeqb128_mask((__v16qi)__a, (__v16qi)__b, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_mask_cmpeq_epi8_mask(__mmask16 __u, __m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_pcmpeqb128_mask((__v16qi)__a, (__v16qi)__b, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_cmpeq_epu8_mask(__m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)__a, (__v16qi)__b, 0, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_mask_cmpeq_epu8_mask(__mmask16 __u, __m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)__a, (__v16qi)__b, 0, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_cmpeq_epi8_mask(__m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_pcmpeqb256_mask((__v32qi)__a, (__v32qi)__b, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_mask_cmpeq_epi8_mask(__mmask32 __u, __m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_pcmpeqb256_mask((__v32qi)__a, (__v32qi)__b, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_cmpeq_epu8_mask(__m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)__a, (__v32qi)__b, 0, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_mask_cmpeq_epu8_mask(__mmask32 __u, __m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)__a, (__v32qi)__b, 0, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpeq_epi16_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_pcmpeqw128_mask((__v8hi)__a, (__v8hi)__b, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpeq_epi16_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_pcmpeqw128_mask((__v8hi)__a, (__v8hi)__b, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpeq_epu16_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)__a, (__v8hi)__b, 0, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpeq_epu16_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)__a, (__v8hi)__b, 0, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_cmpeq_epi16_mask(__m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_pcmpeqw256_mask((__v16hi)__a, (__v16hi)__b, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_mask_cmpeq_epi16_mask(__mmask16 __u, __m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_pcmpeqw256_mask((__v16hi)__a, (__v16hi)__b, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_cmpeq_epu16_mask(__m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)__a, (__v16hi)__b, 0, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_mask_cmpeq_epu16_mask(__mmask16 __u, __m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)__a, (__v16hi)__b, 0, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_cmpge_epi8_mask(__m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_cmpb128_mask((__v16qi)__a, (__v16qi)__b, 5, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_mask_cmpge_epi8_mask(__mmask16 __u, __m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_cmpb128_mask((__v16qi)__a, (__v16qi)__b, 5, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_cmpge_epu8_mask(__m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)__a, (__v16qi)__b, 5, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_mask_cmpge_epu8_mask(__mmask16 __u, __m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)__a, (__v16qi)__b, 5, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_cmpge_epi8_mask(__m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_cmpb256_mask((__v32qi)__a, (__v32qi)__b, 5, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_mask_cmpge_epi8_mask(__mmask32 __u, __m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_cmpb256_mask((__v32qi)__a, (__v32qi)__b, 5, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_cmpge_epu8_mask(__m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)__a, (__v32qi)__b, 5, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_mask_cmpge_epu8_mask(__mmask32 __u, __m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)__a, (__v32qi)__b, 5, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpge_epi16_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpw128_mask((__v8hi)__a, (__v8hi)__b, 5, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpge_epi16_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpw128_mask((__v8hi)__a, (__v8hi)__b, 5, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpge_epu16_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)__a, (__v8hi)__b, 5, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpge_epu16_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)__a, (__v8hi)__b, 5, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_cmpge_epi16_mask(__m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_cmpw256_mask((__v16hi)__a, (__v16hi)__b, 5, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_mask_cmpge_epi16_mask(__mmask16 __u, __m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_cmpw256_mask((__v16hi)__a, (__v16hi)__b, 5, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_cmpge_epu16_mask(__m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)__a, (__v16hi)__b, 5, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_mask_cmpge_epu16_mask(__mmask16 __u, __m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)__a, (__v16hi)__b, 5, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_cmpgt_epi8_mask(__m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_pcmpgtb128_mask((__v16qi)__a, (__v16qi)__b, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_mask_cmpgt_epi8_mask(__mmask16 __u, __m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_pcmpgtb128_mask((__v16qi)__a, (__v16qi)__b, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_cmpgt_epu8_mask(__m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)__a, (__v16qi)__b, 6, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_mask_cmpgt_epu8_mask(__mmask16 __u, __m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)__a, (__v16qi)__b, 6, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_cmpgt_epi8_mask(__m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_pcmpgtb256_mask((__v32qi)__a, (__v32qi)__b, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_mask_cmpgt_epi8_mask(__mmask32 __u, __m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_pcmpgtb256_mask((__v32qi)__a, (__v32qi)__b, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_cmpgt_epu8_mask(__m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)__a, (__v32qi)__b, 6, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_mask_cmpgt_epu8_mask(__mmask32 __u, __m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)__a, (__v32qi)__b, 6, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpgt_epi16_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_pcmpgtw128_mask((__v8hi)__a, (__v8hi)__b, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpgt_epi16_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_pcmpgtw128_mask((__v8hi)__a, (__v8hi)__b, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpgt_epu16_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)__a, (__v8hi)__b, 6, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpgt_epu16_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)__a, (__v8hi)__b, 6, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_cmpgt_epi16_mask(__m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_pcmpgtw256_mask((__v16hi)__a, (__v16hi)__b, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_mask_cmpgt_epi16_mask(__mmask16 __u, __m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_pcmpgtw256_mask((__v16hi)__a, (__v16hi)__b, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_cmpgt_epu16_mask(__m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)__a, (__v16hi)__b, 6, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_mask_cmpgt_epu16_mask(__mmask16 __u, __m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)__a, (__v16hi)__b, 6, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_cmple_epi8_mask(__m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_cmpb128_mask((__v16qi)__a, (__v16qi)__b, 2, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_mask_cmple_epi8_mask(__mmask16 __u, __m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_cmpb128_mask((__v16qi)__a, (__v16qi)__b, 2, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_cmple_epu8_mask(__m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)__a, (__v16qi)__b, 2, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_mask_cmple_epu8_mask(__mmask16 __u, __m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)__a, (__v16qi)__b, 2, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_cmple_epi8_mask(__m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_cmpb256_mask((__v32qi)__a, (__v32qi)__b, 2, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_mask_cmple_epi8_mask(__mmask32 __u, __m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_cmpb256_mask((__v32qi)__a, (__v32qi)__b, 2, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_cmple_epu8_mask(__m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)__a, (__v32qi)__b, 2, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_mask_cmple_epu8_mask(__mmask32 __u, __m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)__a, (__v32qi)__b, 2, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmple_epi16_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpw128_mask((__v8hi)__a, (__v8hi)__b, 2, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmple_epi16_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpw128_mask((__v8hi)__a, (__v8hi)__b, 2, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmple_epu16_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)__a, (__v8hi)__b, 2, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmple_epu16_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)__a, (__v8hi)__b, 2, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_cmple_epi16_mask(__m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_cmpw256_mask((__v16hi)__a, (__v16hi)__b, 2, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_mask_cmple_epi16_mask(__mmask16 __u, __m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_cmpw256_mask((__v16hi)__a, (__v16hi)__b, 2, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_cmple_epu16_mask(__m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)__a, (__v16hi)__b, 2, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_mask_cmple_epu16_mask(__mmask16 __u, __m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)__a, (__v16hi)__b, 2, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_cmplt_epi8_mask(__m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_cmpb128_mask((__v16qi)__a, (__v16qi)__b, 1, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_mask_cmplt_epi8_mask(__mmask16 __u, __m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_cmpb128_mask((__v16qi)__a, (__v16qi)__b, 1, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_cmplt_epu8_mask(__m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)__a, (__v16qi)__b, 1, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_mask_cmplt_epu8_mask(__mmask16 __u, __m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)__a, (__v16qi)__b, 1, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_cmplt_epi8_mask(__m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_cmpb256_mask((__v32qi)__a, (__v32qi)__b, 1, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_mask_cmplt_epi8_mask(__mmask32 __u, __m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_cmpb256_mask((__v32qi)__a, (__v32qi)__b, 1, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_cmplt_epu8_mask(__m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)__a, (__v32qi)__b, 1, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_mask_cmplt_epu8_mask(__mmask32 __u, __m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)__a, (__v32qi)__b, 1, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmplt_epi16_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpw128_mask((__v8hi)__a, (__v8hi)__b, 1, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmplt_epi16_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpw128_mask((__v8hi)__a, (__v8hi)__b, 1, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmplt_epu16_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)__a, (__v8hi)__b, 1, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmplt_epu16_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)__a, (__v8hi)__b, 1, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_cmplt_epi16_mask(__m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_cmpw256_mask((__v16hi)__a, (__v16hi)__b, 1, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_mask_cmplt_epi16_mask(__mmask16 __u, __m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_cmpw256_mask((__v16hi)__a, (__v16hi)__b, 1, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_cmplt_epu16_mask(__m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)__a, (__v16hi)__b, 1, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_mask_cmplt_epu16_mask(__mmask16 __u, __m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)__a, (__v16hi)__b, 1, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_cmpneq_epi8_mask(__m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_cmpb128_mask((__v16qi)__a, (__v16qi)__b, 4, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_mask_cmpneq_epi8_mask(__mmask16 __u, __m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_cmpb128_mask((__v16qi)__a, (__v16qi)__b, 4, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_cmpneq_epu8_mask(__m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)__a, (__v16qi)__b, 4, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm_mask_cmpneq_epu8_mask(__mmask16 __u, __m128i __a, __m128i __b) { return (__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)__a, (__v16qi)__b, 4, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_cmpneq_epi8_mask(__m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_cmpb256_mask((__v32qi)__a, (__v32qi)__b, 4, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_mask_cmpneq_epi8_mask(__mmask32 __u, __m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_cmpb256_mask((__v32qi)__a, (__v32qi)__b, 4, __u); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_cmpneq_epu8_mask(__m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)__a, (__v32qi)__b, 4, (__mmask32)-1); } -static __inline__ __mmask32 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask32 DEFAULT_FN_ATTRS _mm256_mask_cmpneq_epu8_mask(__mmask32 __u, __m256i __a, __m256i __b) { return (__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)__a, (__v32qi)__b, 4, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpneq_epi16_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpw128_mask((__v8hi)__a, (__v8hi)__b, 4, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpneq_epi16_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpw128_mask((__v8hi)__a, (__v8hi)__b, 4, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpneq_epu16_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)__a, (__v8hi)__b, 4, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpneq_epu16_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)__a, (__v8hi)__b, 4, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_cmpneq_epi16_mask(__m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_cmpw256_mask((__v16hi)__a, (__v16hi)__b, 4, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_mask_cmpneq_epi16_mask(__mmask16 __u, __m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_cmpw256_mask((__v16hi)__a, (__v16hi)__b, 4, __u); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_cmpneq_epu16_mask(__m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)__a, (__v16hi)__b, 4, (__mmask16)-1); } -static __inline__ __mmask16 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask16 DEFAULT_FN_ATTRS _mm256_mask_cmpneq_epu16_mask(__mmask16 __u, __m256i __a, __m256i __b) { return (__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)__a, (__v16hi)__b, 4, __u); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_add_epi8 (__m256i __W, __mmask32 __U, __m256i __A, __m256i __B){ return (__m256i) __builtin_ia32_paddb256_mask ((__v32qi) __A, (__v32qi) __B, @@ -614,7 +617,7 @@ _mm256_mask_add_epi8 (__m256i __W, __mmask32 __U, __m256i __A, __m256i __B){ (__mmask32) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_add_epi8 (__mmask32 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_paddb256_mask ((__v32qi) __A, (__v32qi) __B, @@ -623,7 +626,7 @@ _mm256_maskz_add_epi8 (__mmask32 __U, __m256i __A, __m256i __B) { (__mmask32) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_add_epi16 (__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_paddw256_mask ((__v16hi) __A, (__v16hi) __B, @@ -631,7 +634,7 @@ _mm256_mask_add_epi16 (__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { (__mmask16) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_add_epi16 (__mmask16 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_paddw256_mask ((__v16hi) __A, (__v16hi) __B, @@ -640,7 +643,7 @@ _mm256_maskz_add_epi16 (__mmask16 __U, __m256i __A, __m256i __B) { (__mmask16) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_sub_epi8 (__m256i __W, __mmask32 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_psubb256_mask ((__v32qi) __A, (__v32qi) __B, @@ -648,7 +651,7 @@ _mm256_mask_sub_epi8 (__m256i __W, __mmask32 __U, __m256i __A, __m256i __B) { (__mmask32) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_sub_epi8 (__mmask32 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_psubb256_mask ((__v32qi) __A, (__v32qi) __B, @@ -657,7 +660,7 @@ _mm256_maskz_sub_epi8 (__mmask32 __U, __m256i __A, __m256i __B) { (__mmask32) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_sub_epi16 (__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_psubw256_mask ((__v16hi) __A, (__v16hi) __B, @@ -665,7 +668,7 @@ _mm256_mask_sub_epi16 (__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { (__mmask16) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_sub_epi16 (__mmask16 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_psubw256_mask ((__v16hi) __A, (__v16hi) __B, @@ -673,7 +676,7 @@ _mm256_maskz_sub_epi16 (__mmask16 __U, __m256i __A, __m256i __B) { _mm256_setzero_si256 (), (__mmask16) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_add_epi8 (__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_paddb128_mask ((__v16qi) __A, (__v16qi) __B, @@ -681,7 +684,7 @@ _mm_mask_add_epi8 (__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) { (__mmask16) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_add_epi8 (__mmask16 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_paddb128_mask ((__v16qi) __A, (__v16qi) __B, @@ -690,7 +693,7 @@ _mm_maskz_add_epi8 (__mmask16 __U, __m128i __A, __m128i __B) { (__mmask16) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_add_epi16 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_paddw128_mask ((__v8hi) __A, (__v8hi) __B, @@ -698,7 +701,7 @@ _mm_mask_add_epi16 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_add_epi16 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_paddw128_mask ((__v8hi) __A, (__v8hi) __B, @@ -707,7 +710,7 @@ _mm_maskz_add_epi16 (__mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_sub_epi8 (__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_psubb128_mask ((__v16qi) __A, (__v16qi) __B, @@ -715,7 +718,7 @@ _mm_mask_sub_epi8 (__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) { (__mmask16) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_sub_epi8 (__mmask16 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_psubb128_mask ((__v16qi) __A, (__v16qi) __B, @@ -724,7 +727,7 @@ _mm_maskz_sub_epi8 (__mmask16 __U, __m128i __A, __m128i __B) { (__mmask16) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_sub_epi16 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_psubw128_mask ((__v8hi) __A, (__v8hi) __B, @@ -732,7 +735,7 @@ _mm_mask_sub_epi16 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_sub_epi16 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_psubw128_mask ((__v8hi) __A, (__v8hi) __B, @@ -741,7 +744,7 @@ _mm_maskz_sub_epi16 (__mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_mullo_epi16 (__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pmullw256_mask ((__v16hi) __A, (__v16hi) __B, @@ -749,7 +752,7 @@ _mm256_mask_mullo_epi16 (__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { (__mmask16) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_mullo_epi16 (__mmask16 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pmullw256_mask ((__v16hi) __A, (__v16hi) __B, @@ -758,7 +761,7 @@ _mm256_maskz_mullo_epi16 (__mmask16 __U, __m256i __A, __m256i __B) { (__mmask16) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_mullo_epi16 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pmullw128_mask ((__v8hi) __A, (__v8hi) __B, @@ -766,7 +769,7 @@ _mm_mask_mullo_epi16 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_mullo_epi16 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pmullw128_mask ((__v8hi) __A, (__v8hi) __B, @@ -854,4 +857,6 @@ _mm_maskz_mullo_epi16 (__mmask8 __U, __m128i __A, __m128i __B) { (__v16hi)(__m256i)(b), \ (p), (__mmask16)(m)); }) +#undef DEFAULT_FN_ATTRS + #endif /* __AVX512VLBWINTRIN_H */ diff --git a/lib/Headers/avx512vldqintrin.h b/lib/Headers/avx512vldqintrin.h index 4024446a3a6a..2a32edd1ad81 100644 --- a/lib/Headers/avx512vldqintrin.h +++ b/lib/Headers/avx512vldqintrin.h @@ -28,13 +28,15 @@ #ifndef __AVX512VLDQINTRIN_H #define __AVX512VLDQINTRIN_H +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512vl,avx512dq"))) -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mullo_epi64 (__m256i __A, __m256i __B) { return (__m256i) ((__v4di) __A * (__v4di) __B); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_mullo_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pmullq256_mask ((__v4di) __A, (__v4di) __B, @@ -42,7 +44,7 @@ _mm256_mask_mullo_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_mullo_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pmullq256_mask ((__v4di) __A, (__v4di) __B, @@ -51,12 +53,12 @@ _mm256_maskz_mullo_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mullo_epi64 (__m128i __A, __m128i __B) { return (__m128i) ((__v2di) __A * (__v2di) __B); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_mullo_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pmullq128_mask ((__v2di) __A, (__v2di) __B, @@ -64,7 +66,7 @@ _mm_mask_mullo_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_mullo_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pmullq128_mask ((__v2di) __A, (__v2di) __B, @@ -73,7 +75,7 @@ _mm_maskz_mullo_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m256d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_mask_andnot_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) { return (__m256d) __builtin_ia32_andnpd256_mask ((__v4df) __A, (__v4df) __B, @@ -81,7 +83,7 @@ _mm256_mask_andnot_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m256d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_maskz_andnot_pd (__mmask8 __U, __m256d __A, __m256d __B) { return (__m256d) __builtin_ia32_andnpd256_mask ((__v4df) __A, (__v4df) __B, @@ -90,7 +92,7 @@ _mm256_maskz_andnot_pd (__mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m128d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_mask_andnot_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { return (__m128d) __builtin_ia32_andnpd128_mask ((__v2df) __A, (__v2df) __B, @@ -98,7 +100,7 @@ _mm_mask_andnot_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m128d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_maskz_andnot_pd (__mmask8 __U, __m128d __A, __m128d __B) { return (__m128d) __builtin_ia32_andnpd128_mask ((__v2df) __A, (__v2df) __B, @@ -107,7 +109,7 @@ _mm_maskz_andnot_pd (__mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m256 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_mask_andnot_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) { return (__m256) __builtin_ia32_andnps256_mask ((__v8sf) __A, (__v8sf) __B, @@ -115,7 +117,7 @@ _mm256_mask_andnot_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m256 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_maskz_andnot_ps (__mmask8 __U, __m256 __A, __m256 __B) { return (__m256) __builtin_ia32_andnps256_mask ((__v8sf) __A, (__v8sf) __B, @@ -124,7 +126,7 @@ _mm256_maskz_andnot_ps (__mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m128 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_mask_andnot_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { return (__m128) __builtin_ia32_andnps128_mask ((__v4sf) __A, (__v4sf) __B, @@ -132,7 +134,7 @@ _mm_mask_andnot_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m128 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_maskz_andnot_ps (__mmask8 __U, __m128 __A, __m128 __B) { return (__m128) __builtin_ia32_andnps128_mask ((__v4sf) __A, (__v4sf) __B, @@ -141,7 +143,7 @@ _mm_maskz_andnot_ps (__mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m256d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_mask_and_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) { return (__m256d) __builtin_ia32_andpd256_mask ((__v4df) __A, (__v4df) __B, @@ -149,7 +151,7 @@ _mm256_mask_and_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m256d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_maskz_and_pd (__mmask8 __U, __m256d __A, __m256d __B) { return (__m256d) __builtin_ia32_andpd256_mask ((__v4df) __A, (__v4df) __B, @@ -158,7 +160,7 @@ _mm256_maskz_and_pd (__mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m128d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_mask_and_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { return (__m128d) __builtin_ia32_andpd128_mask ((__v2df) __A, (__v2df) __B, @@ -166,7 +168,7 @@ _mm_mask_and_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m128d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_maskz_and_pd (__mmask8 __U, __m128d __A, __m128d __B) { return (__m128d) __builtin_ia32_andpd128_mask ((__v2df) __A, (__v2df) __B, @@ -175,7 +177,7 @@ _mm_maskz_and_pd (__mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m256 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_mask_and_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) { return (__m256) __builtin_ia32_andps256_mask ((__v8sf) __A, (__v8sf) __B, @@ -183,7 +185,7 @@ _mm256_mask_and_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m256 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_maskz_and_ps (__mmask8 __U, __m256 __A, __m256 __B) { return (__m256) __builtin_ia32_andps256_mask ((__v8sf) __A, (__v8sf) __B, @@ -192,7 +194,7 @@ _mm256_maskz_and_ps (__mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m128 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_mask_and_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { return (__m128) __builtin_ia32_andps128_mask ((__v4sf) __A, (__v4sf) __B, @@ -200,7 +202,7 @@ _mm_mask_and_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m128 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_maskz_and_ps (__mmask8 __U, __m128 __A, __m128 __B) { return (__m128) __builtin_ia32_andps128_mask ((__v4sf) __A, (__v4sf) __B, @@ -209,7 +211,7 @@ _mm_maskz_and_ps (__mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m256d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_mask_xor_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) { return (__m256d) __builtin_ia32_xorpd256_mask ((__v4df) __A, @@ -218,7 +220,7 @@ _mm256_mask_xor_pd (__m256d __W, __mmask8 __U, __m256d __A, (__mmask8) __U); } -static __inline__ __m256d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_maskz_xor_pd (__mmask8 __U, __m256d __A, __m256d __B) { return (__m256d) __builtin_ia32_xorpd256_mask ((__v4df) __A, (__v4df) __B, @@ -227,7 +229,7 @@ _mm256_maskz_xor_pd (__mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m128d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_mask_xor_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { return (__m128d) __builtin_ia32_xorpd128_mask ((__v2df) __A, (__v2df) __B, @@ -235,7 +237,7 @@ _mm_mask_xor_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m128d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_maskz_xor_pd (__mmask8 __U, __m128d __A, __m128d __B) { return (__m128d) __builtin_ia32_xorpd128_mask ((__v2df) __A, (__v2df) __B, @@ -244,7 +246,7 @@ _mm_maskz_xor_pd (__mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m256 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_mask_xor_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) { return (__m256) __builtin_ia32_xorps256_mask ((__v8sf) __A, (__v8sf) __B, @@ -252,7 +254,7 @@ _mm256_mask_xor_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m256 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_maskz_xor_ps (__mmask8 __U, __m256 __A, __m256 __B) { return (__m256) __builtin_ia32_xorps256_mask ((__v8sf) __A, (__v8sf) __B, @@ -261,7 +263,7 @@ _mm256_maskz_xor_ps (__mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m128 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_mask_xor_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { return (__m128) __builtin_ia32_xorps128_mask ((__v4sf) __A, (__v4sf) __B, @@ -269,7 +271,7 @@ _mm_mask_xor_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m128 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_maskz_xor_ps (__mmask8 __U, __m128 __A, __m128 __B) { return (__m128) __builtin_ia32_xorps128_mask ((__v4sf) __A, (__v4sf) __B, @@ -278,7 +280,7 @@ _mm_maskz_xor_ps (__mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m256d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_mask_or_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) { return (__m256d) __builtin_ia32_orpd256_mask ((__v4df) __A, (__v4df) __B, @@ -286,7 +288,7 @@ _mm256_mask_or_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m256d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_maskz_or_pd (__mmask8 __U, __m256d __A, __m256d __B) { return (__m256d) __builtin_ia32_orpd256_mask ((__v4df) __A, (__v4df) __B, @@ -295,7 +297,7 @@ _mm256_maskz_or_pd (__mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m128d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_mask_or_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { return (__m128d) __builtin_ia32_orpd128_mask ((__v2df) __A, (__v2df) __B, @@ -303,7 +305,7 @@ _mm_mask_or_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m128d __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_maskz_or_pd (__mmask8 __U, __m128d __A, __m128d __B) { return (__m128d) __builtin_ia32_orpd128_mask ((__v2df) __A, (__v2df) __B, @@ -312,7 +314,7 @@ _mm_maskz_or_pd (__mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m256 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_mask_or_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) { return (__m256) __builtin_ia32_orps256_mask ((__v8sf) __A, (__v8sf) __B, @@ -320,7 +322,7 @@ _mm256_mask_or_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m256 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_maskz_or_ps (__mmask8 __U, __m256 __A, __m256 __B) { return (__m256) __builtin_ia32_orps256_mask ((__v8sf) __A, (__v8sf) __B, @@ -329,7 +331,7 @@ _mm256_maskz_or_ps (__mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m128 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_mask_or_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { return (__m128) __builtin_ia32_orps128_mask ((__v4sf) __A, (__v4sf) __B, @@ -337,7 +339,7 @@ _mm_mask_or_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m128 __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_maskz_or_ps (__mmask8 __U, __m128 __A, __m128 __B) { return (__m128) __builtin_ia32_orps128_mask ((__v4sf) __A, (__v4sf) __B, @@ -346,4 +348,6 @@ _mm_maskz_or_ps (__mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } +#undef DEFAULT_FN_ATTRS + #endif diff --git a/lib/Headers/avx512vlintrin.h b/lib/Headers/avx512vlintrin.h index 9de0cf418b78..59ff5ebfd574 100644 --- a/lib/Headers/avx512vlintrin.h +++ b/lib/Headers/avx512vlintrin.h @@ -28,196 +28,199 @@ #ifndef __AVX512VLINTRIN_H #define __AVX512VLINTRIN_H +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512vl"))) + /* Integer compare */ -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpeq_epi32_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_pcmpeqd128_mask((__v4si)__a, (__v4si)__b, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpeq_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_pcmpeqd128_mask((__v4si)__a, (__v4si)__b, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpeq_epu32_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)__a, (__v4si)__b, 0, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpeq_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)__a, (__v4si)__b, 0, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpeq_epi32_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_pcmpeqd256_mask((__v8si)__a, (__v8si)__b, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpeq_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_pcmpeqd256_mask((__v8si)__a, (__v8si)__b, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpeq_epu32_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)__a, (__v8si)__b, 0, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpeq_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)__a, (__v8si)__b, 0, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpeq_epi64_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_pcmpeqq128_mask((__v2di)__a, (__v2di)__b, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpeq_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_pcmpeqq128_mask((__v2di)__a, (__v2di)__b, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpeq_epu64_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)__a, (__v2di)__b, 0, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpeq_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)__a, (__v2di)__b, 0, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpeq_epi64_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_pcmpeqq256_mask((__v4di)__a, (__v4di)__b, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpeq_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_pcmpeqq256_mask((__v4di)__a, (__v4di)__b, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpeq_epu64_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)__a, (__v4di)__b, 0, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpeq_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)__a, (__v4di)__b, 0, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpge_epi32_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpd128_mask((__v4si)__a, (__v4si)__b, 5, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpge_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpd128_mask((__v4si)__a, (__v4si)__b, 5, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpge_epu32_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)__a, (__v4si)__b, 5, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpge_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)__a, (__v4si)__b, 5, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpge_epi32_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpd256_mask((__v8si)__a, (__v8si)__b, 5, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpge_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpd256_mask((__v8si)__a, (__v8si)__b, 5, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpge_epu32_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)__a, (__v8si)__b, 5, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpge_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)__a, (__v8si)__b, 5, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpge_epi64_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpq128_mask((__v2di)__a, (__v2di)__b, 5, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpge_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpq128_mask((__v2di)__a, (__v2di)__b, 5, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpge_epu64_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)__a, (__v2di)__b, 5, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpge_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)__a, (__v2di)__b, 5, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpge_epi64_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpq256_mask((__v4di)__a, (__v4di)__b, 5, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpge_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpq256_mask((__v4di)__a, (__v4di)__b, 5, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpge_epu64_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)__a, (__v4di)__b, 5, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpge_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)__a, (__v4di)__b, 5, __u); @@ -226,391 +229,391 @@ _mm256_mask_cmpge_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpgt_epi32_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_pcmpgtd128_mask((__v4si)__a, (__v4si)__b, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpgt_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_pcmpgtd128_mask((__v4si)__a, (__v4si)__b, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpgt_epu32_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)__a, (__v4si)__b, 6, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpgt_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)__a, (__v4si)__b, 6, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpgt_epi32_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_pcmpgtd256_mask((__v8si)__a, (__v8si)__b, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpgt_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_pcmpgtd256_mask((__v8si)__a, (__v8si)__b, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpgt_epu32_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)__a, (__v8si)__b, 6, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpgt_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)__a, (__v8si)__b, 6, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpgt_epi64_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_pcmpgtq128_mask((__v2di)__a, (__v2di)__b, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpgt_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_pcmpgtq128_mask((__v2di)__a, (__v2di)__b, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpgt_epu64_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)__a, (__v2di)__b, 6, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpgt_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)__a, (__v2di)__b, 6, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpgt_epi64_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_pcmpgtq256_mask((__v4di)__a, (__v4di)__b, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpgt_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_pcmpgtq256_mask((__v4di)__a, (__v4di)__b, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpgt_epu64_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)__a, (__v4di)__b, 6, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpgt_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)__a, (__v4di)__b, 6, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmple_epi32_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpd128_mask((__v4si)__a, (__v4si)__b, 2, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmple_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpd128_mask((__v4si)__a, (__v4si)__b, 2, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmple_epu32_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)__a, (__v4si)__b, 2, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmple_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)__a, (__v4si)__b, 2, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmple_epi32_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpd256_mask((__v8si)__a, (__v8si)__b, 2, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmple_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpd256_mask((__v8si)__a, (__v8si)__b, 2, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmple_epu32_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)__a, (__v8si)__b, 2, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmple_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)__a, (__v8si)__b, 2, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmple_epi64_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpq128_mask((__v2di)__a, (__v2di)__b, 2, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmple_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpq128_mask((__v2di)__a, (__v2di)__b, 2, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmple_epu64_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)__a, (__v2di)__b, 2, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmple_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)__a, (__v2di)__b, 2, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmple_epi64_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpq256_mask((__v4di)__a, (__v4di)__b, 2, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmple_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpq256_mask((__v4di)__a, (__v4di)__b, 2, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmple_epu64_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)__a, (__v4di)__b, 2, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmple_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)__a, (__v4di)__b, 2, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmplt_epi32_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpd128_mask((__v4si)__a, (__v4si)__b, 1, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmplt_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpd128_mask((__v4si)__a, (__v4si)__b, 1, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmplt_epu32_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)__a, (__v4si)__b, 1, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmplt_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)__a, (__v4si)__b, 1, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmplt_epi32_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpd256_mask((__v8si)__a, (__v8si)__b, 1, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmplt_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpd256_mask((__v8si)__a, (__v8si)__b, 1, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmplt_epu32_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)__a, (__v8si)__b, 1, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmplt_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)__a, (__v8si)__b, 1, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmplt_epi64_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpq128_mask((__v2di)__a, (__v2di)__b, 1, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmplt_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpq128_mask((__v2di)__a, (__v2di)__b, 1, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmplt_epu64_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)__a, (__v2di)__b, 1, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmplt_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)__a, (__v2di)__b, 1, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmplt_epi64_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpq256_mask((__v4di)__a, (__v4di)__b, 1, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmplt_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpq256_mask((__v4di)__a, (__v4di)__b, 1, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmplt_epu64_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)__a, (__v4di)__b, 1, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmplt_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)__a, (__v4di)__b, 1, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpneq_epi32_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpd128_mask((__v4si)__a, (__v4si)__b, 4, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpneq_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpd128_mask((__v4si)__a, (__v4si)__b, 4, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpneq_epu32_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)__a, (__v4si)__b, 4, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpneq_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)__a, (__v4si)__b, 4, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpneq_epi32_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpd256_mask((__v8si)__a, (__v8si)__b, 4, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpneq_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpd256_mask((__v8si)__a, (__v8si)__b, 4, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpneq_epu32_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)__a, (__v8si)__b, 4, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpneq_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)__a, (__v8si)__b, 4, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpneq_epi64_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpq128_mask((__v2di)__a, (__v2di)__b, 4, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpneq_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_cmpq128_mask((__v2di)__a, (__v2di)__b, 4, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_cmpneq_epu64_mask(__m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)__a, (__v2di)__b, 4, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm_mask_cmpneq_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { return (__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)__a, (__v2di)__b, 4, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpneq_epi64_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpq256_mask((__v4di)__a, (__v4di)__b, 4, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpneq_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_cmpq256_mask((__v4di)__a, (__v4di)__b, 4, __u); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_cmpneq_epu64_mask(__m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)__a, (__v4di)__b, 4, (__mmask8)-1); } -static __inline__ __mmask8 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __mmask8 DEFAULT_FN_ATTRS _mm256_mask_cmpneq_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { return (__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)__a, (__v4di)__b, 4, __u); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_add_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -620,7 +623,7 @@ _mm256_mask_add_epi32 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_add_epi32 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_paddd256_mask ((__v8si) __A, @@ -630,7 +633,7 @@ _mm256_maskz_add_epi32 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_add_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -640,7 +643,7 @@ _mm256_mask_add_epi64 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_add_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_paddq256_mask ((__v4di) __A, @@ -650,7 +653,7 @@ _mm256_maskz_add_epi64 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_sub_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -660,7 +663,7 @@ _mm256_mask_sub_epi32 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_sub_epi32 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_psubd256_mask ((__v8si) __A, @@ -670,7 +673,7 @@ _mm256_maskz_sub_epi32 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_sub_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -680,7 +683,7 @@ _mm256_mask_sub_epi64 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_sub_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_psubq256_mask ((__v4di) __A, @@ -690,7 +693,7 @@ _mm256_maskz_sub_epi64 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_add_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -700,7 +703,7 @@ _mm_mask_add_epi32 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_add_epi32 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_paddd128_mask ((__v4si) __A, @@ -710,7 +713,7 @@ _mm_maskz_add_epi32 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_add_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -720,7 +723,7 @@ _mm_mask_add_epi64 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_add_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_paddq128_mask ((__v2di) __A, @@ -730,7 +733,7 @@ _mm_maskz_add_epi64 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_sub_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -740,7 +743,7 @@ _mm_mask_sub_epi32 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_sub_epi32 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_psubd128_mask ((__v4si) __A, @@ -750,7 +753,7 @@ _mm_maskz_sub_epi32 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_sub_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -760,7 +763,7 @@ _mm_mask_sub_epi64 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_sub_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_psubq128_mask ((__v2di) __A, @@ -770,7 +773,7 @@ _mm_maskz_sub_epi64 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_mul_epi32 (__m256i __W, __mmask8 __M, __m256i __X, __m256i __Y) { @@ -779,7 +782,7 @@ _mm256_mask_mul_epi32 (__m256i __W, __mmask8 __M, __m256i __X, (__v4di) __W, __M); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_mul_epi32 (__mmask8 __M, __m256i __X, __m256i __Y) { return (__m256i) __builtin_ia32_pmuldq256_mask ((__v8si) __X, @@ -789,7 +792,7 @@ _mm256_maskz_mul_epi32 (__mmask8 __M, __m256i __X, __m256i __Y) __M); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_mul_epi32 (__m128i __W, __mmask8 __M, __m128i __X, __m128i __Y) { @@ -798,7 +801,7 @@ _mm_mask_mul_epi32 (__m128i __W, __mmask8 __M, __m128i __X, (__v2di) __W, __M); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_mul_epi32 (__mmask8 __M, __m128i __X, __m128i __Y) { return (__m128i) __builtin_ia32_pmuldq128_mask ((__v4si) __X, @@ -808,7 +811,7 @@ _mm_maskz_mul_epi32 (__mmask8 __M, __m128i __X, __m128i __Y) __M); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_mul_epu32 (__m256i __W, __mmask8 __M, __m256i __X, __m256i __Y) { @@ -817,7 +820,7 @@ _mm256_mask_mul_epu32 (__m256i __W, __mmask8 __M, __m256i __X, (__v4di) __W, __M); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_mul_epu32 (__mmask8 __M, __m256i __X, __m256i __Y) { return (__m256i) __builtin_ia32_pmuludq256_mask ((__v8si) __X, @@ -827,7 +830,7 @@ _mm256_maskz_mul_epu32 (__mmask8 __M, __m256i __X, __m256i __Y) __M); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_mul_epu32 (__m128i __W, __mmask8 __M, __m128i __X, __m128i __Y) { @@ -836,7 +839,7 @@ _mm_mask_mul_epu32 (__m128i __W, __mmask8 __M, __m128i __X, (__v2di) __W, __M); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_mul_epu32 (__mmask8 __M, __m128i __X, __m128i __Y) { return (__m128i) __builtin_ia32_pmuludq128_mask ((__v4si) __X, @@ -846,7 +849,7 @@ _mm_maskz_mul_epu32 (__mmask8 __M, __m128i __X, __m128i __Y) __M); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_mullo_epi32 (__mmask8 __M, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pmulld256_mask ((__v8si) __A, @@ -856,7 +859,7 @@ _mm256_maskz_mullo_epi32 (__mmask8 __M, __m256i __A, __m256i __B) __M); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_mullo_epi32 (__m256i __W, __mmask8 __M, __m256i __A, __m256i __B) { @@ -865,7 +868,7 @@ _mm256_mask_mullo_epi32 (__m256i __W, __mmask8 __M, __m256i __A, (__v8si) __W, __M); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_mullo_epi32 (__mmask8 __M, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pmulld128_mask ((__v4si) __A, @@ -875,7 +878,7 @@ _mm_maskz_mullo_epi32 (__mmask8 __M, __m128i __A, __m128i __B) __M); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_mullo_epi32 (__m128i __W, __mmask16 __M, __m128i __A, __m128i __B) { @@ -884,7 +887,7 @@ _mm_mask_mullo_epi32 (__m128i __W, __mmask16 __M, __m128i __A, (__v4si) __W, __M); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_and_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -894,7 +897,7 @@ _mm256_mask_and_epi32 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_and_epi32 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pandd256_mask ((__v8si) __A, @@ -904,7 +907,7 @@ _mm256_maskz_and_epi32 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_and_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pandd128_mask ((__v4si) __A, @@ -913,7 +916,7 @@ _mm_mask_and_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_and_epi32 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pandd128_mask ((__v4si) __A, @@ -923,7 +926,7 @@ _mm_maskz_and_epi32 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_andnot_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -933,7 +936,7 @@ _mm256_mask_andnot_epi32 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_andnot_epi32 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pandnd256_mask ((__v8si) __A, @@ -943,7 +946,7 @@ _mm256_maskz_andnot_epi32 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_andnot_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -953,7 +956,7 @@ _mm_mask_andnot_epi32 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_andnot_epi32 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pandnd128_mask ((__v4si) __A, @@ -963,7 +966,7 @@ _mm_maskz_andnot_epi32 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_or_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -973,7 +976,7 @@ _mm256_mask_or_epi32 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_or_epi32 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pord256_mask ((__v8si) __A, @@ -983,7 +986,7 @@ _mm256_maskz_or_epi32 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_or_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pord128_mask ((__v4si) __A, @@ -992,7 +995,7 @@ _mm_mask_or_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_or_epi32 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pord128_mask ((__v4si) __A, @@ -1002,7 +1005,7 @@ _mm_maskz_or_epi32 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_xor_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -1012,7 +1015,7 @@ _mm256_mask_xor_epi32 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_xor_epi32 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pxord256_mask ((__v8si) __A, @@ -1022,7 +1025,7 @@ _mm256_maskz_xor_epi32 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_xor_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -1032,7 +1035,7 @@ _mm_mask_xor_epi32 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_xor_epi32 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pxord128_mask ((__v4si) __A, @@ -1042,7 +1045,7 @@ _mm_maskz_xor_epi32 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_and_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -1051,7 +1054,7 @@ _mm256_mask_and_epi64 (__m256i __W, __mmask8 __U, __m256i __A, (__v4di) __W, __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_and_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pandq256_mask ((__v4di) __A, @@ -1061,7 +1064,7 @@ _mm256_maskz_and_epi64 (__mmask8 __U, __m256i __A, __m256i __B) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_and_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -1070,7 +1073,7 @@ _mm_mask_and_epi64 (__m128i __W, __mmask8 __U, __m128i __A, (__v2di) __W, __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_and_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pandq128_mask ((__v2di) __A, @@ -1080,7 +1083,7 @@ _mm_maskz_and_epi64 (__mmask8 __U, __m128i __A, __m128i __B) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_andnot_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -1089,7 +1092,7 @@ _mm256_mask_andnot_epi64 (__m256i __W, __mmask8 __U, __m256i __A, (__v4di) __W, __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_andnot_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pandnq256_mask ((__v4di) __A, @@ -1099,7 +1102,7 @@ _mm256_maskz_andnot_epi64 (__mmask8 __U, __m256i __A, __m256i __B) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_andnot_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -1108,7 +1111,7 @@ _mm_mask_andnot_epi64 (__m128i __W, __mmask8 __U, __m128i __A, (__v2di) __W, __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_andnot_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pandnq128_mask ((__v2di) __A, @@ -1118,7 +1121,7 @@ _mm_maskz_andnot_epi64 (__mmask8 __U, __m128i __A, __m128i __B) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_or_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -1128,7 +1131,7 @@ _mm256_mask_or_epi64 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_or_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_porq256_mask ((__v4di) __A, @@ -1138,7 +1141,7 @@ _mm256_maskz_or_epi64 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_or_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_porq128_mask ((__v2di) __A, @@ -1147,7 +1150,7 @@ _mm_mask_or_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_or_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_porq128_mask ((__v2di) __A, @@ -1157,7 +1160,7 @@ _mm_maskz_or_epi64 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_mask_xor_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -1167,7 +1170,7 @@ _mm256_mask_xor_epi64 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_maskz_xor_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pxorq256_mask ((__v4di) __A, @@ -1177,7 +1180,7 @@ _mm256_maskz_xor_epi64 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mask_xor_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -1187,7 +1190,7 @@ _mm_mask_xor_epi64 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i __attribute__ ((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maskz_xor_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pxorq128_mask ((__v2di) __A, @@ -1316,4 +1319,7 @@ _mm_maskz_xor_epi64 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8)__builtin_ia32_cmppd128_mask((__v2df)(__m128)(a), \ (__v2df)(__m128)(b), \ (p), (__mmask8)(m)); }) + +#undef DEFAULT_FN_ATTRS + #endif /* __AVX512VLINTRIN_H */ diff --git a/lib/Headers/avxintrin.h b/lib/Headers/avxintrin.h index 4907965861d4..d28a9155266a 100644 --- a/lib/Headers/avxintrin.h +++ b/lib/Headers/avxintrin.h @@ -39,110 +39,113 @@ typedef float __m256 __attribute__ ((__vector_size__ (32))); typedef double __m256d __attribute__((__vector_size__(32))); typedef long long __m256i __attribute__((__vector_size__(32))); +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx"))) + /* Arithmetic */ -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_add_pd(__m256d __a, __m256d __b) { return __a+__b; } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_add_ps(__m256 __a, __m256 __b) { return __a+__b; } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_sub_pd(__m256d __a, __m256d __b) { return __a-__b; } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_sub_ps(__m256 __a, __m256 __b) { return __a-__b; } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_addsub_pd(__m256d __a, __m256d __b) { return (__m256d)__builtin_ia32_addsubpd256((__v4df)__a, (__v4df)__b); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_addsub_ps(__m256 __a, __m256 __b) { return (__m256)__builtin_ia32_addsubps256((__v8sf)__a, (__v8sf)__b); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_div_pd(__m256d __a, __m256d __b) { return __a / __b; } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_div_ps(__m256 __a, __m256 __b) { return __a / __b; } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_max_pd(__m256d __a, __m256d __b) { return (__m256d)__builtin_ia32_maxpd256((__v4df)__a, (__v4df)__b); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_max_ps(__m256 __a, __m256 __b) { return (__m256)__builtin_ia32_maxps256((__v8sf)__a, (__v8sf)__b); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_min_pd(__m256d __a, __m256d __b) { return (__m256d)__builtin_ia32_minpd256((__v4df)__a, (__v4df)__b); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_min_ps(__m256 __a, __m256 __b) { return (__m256)__builtin_ia32_minps256((__v8sf)__a, (__v8sf)__b); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_mul_pd(__m256d __a, __m256d __b) { return __a * __b; } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_mul_ps(__m256 __a, __m256 __b) { return __a * __b; } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_sqrt_pd(__m256d __a) { return (__m256d)__builtin_ia32_sqrtpd256((__v4df)__a); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_sqrt_ps(__m256 __a) { return (__m256)__builtin_ia32_sqrtps256((__v8sf)__a); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_rsqrt_ps(__m256 __a) { return (__m256)__builtin_ia32_rsqrtps256((__v8sf)__a); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_rcp_ps(__m256 __a) { return (__m256)__builtin_ia32_rcpps256((__v8sf)__a); @@ -162,99 +165,99 @@ _mm256_rcp_ps(__m256 __a) #define _mm256_floor_ps(V) _mm256_round_ps((V), _MM_FROUND_FLOOR) /* Logical */ -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_and_pd(__m256d __a, __m256d __b) { return (__m256d)((__v4di)__a & (__v4di)__b); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_and_ps(__m256 __a, __m256 __b) { return (__m256)((__v8si)__a & (__v8si)__b); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_andnot_pd(__m256d __a, __m256d __b) { return (__m256d)(~(__v4di)__a & (__v4di)__b); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_andnot_ps(__m256 __a, __m256 __b) { return (__m256)(~(__v8si)__a & (__v8si)__b); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_or_pd(__m256d __a, __m256d __b) { return (__m256d)((__v4di)__a | (__v4di)__b); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_or_ps(__m256 __a, __m256 __b) { return (__m256)((__v8si)__a | (__v8si)__b); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_xor_pd(__m256d __a, __m256d __b) { return (__m256d)((__v4di)__a ^ (__v4di)__b); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_xor_ps(__m256 __a, __m256 __b) { return (__m256)((__v8si)__a ^ (__v8si)__b); } /* Horizontal arithmetic */ -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_hadd_pd(__m256d __a, __m256d __b) { return (__m256d)__builtin_ia32_haddpd256((__v4df)__a, (__v4df)__b); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_hadd_ps(__m256 __a, __m256 __b) { return (__m256)__builtin_ia32_haddps256((__v8sf)__a, (__v8sf)__b); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_hsub_pd(__m256d __a, __m256d __b) { return (__m256d)__builtin_ia32_hsubpd256((__v4df)__a, (__v4df)__b); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_hsub_ps(__m256 __a, __m256 __b) { return (__m256)__builtin_ia32_hsubps256((__v8sf)__a, (__v8sf)__b); } /* Vector permutations */ -static __inline __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline __m128d DEFAULT_FN_ATTRS _mm_permutevar_pd(__m128d __a, __m128i __c) { return (__m128d)__builtin_ia32_vpermilvarpd((__v2df)__a, (__v2di)__c); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_permutevar_pd(__m256d __a, __m256i __c) { return (__m256d)__builtin_ia32_vpermilvarpd256((__v4df)__a, (__v4di)__c); } -static __inline __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline __m128 DEFAULT_FN_ATTRS _mm_permutevar_ps(__m128 __a, __m128i __c) { return (__m128)__builtin_ia32_vpermilvarps((__v4sf)__a, (__v4si)__c); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_permutevar_ps(__m256 __a, __m256i __c) { return (__m256)__builtin_ia32_vpermilvarps256((__v8sf)__a, (__v8si)__c); @@ -326,14 +329,14 @@ _mm256_permutevar_ps(__m256 __a, __m256i __c) (((M) & 0x40) ? 14 : 6), \ (((M) & 0x80) ? 15 : 7)); }) -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_blendv_pd(__m256d __a, __m256d __b, __m256d __c) { return (__m256d)__builtin_ia32_blendvpd256( (__v4df)__a, (__v4df)__b, (__v4df)__c); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c) { return (__m256)__builtin_ia32_blendvps256( @@ -429,21 +432,21 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c) __m128 __b = (b); \ (__m128)__builtin_ia32_cmpss((__v4sf)__a, (__v4sf)__b, (c)); }) -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_extract_epi32(__m256i __a, const int __imm) { __v8si __b = (__v8si)__a; return __b[__imm & 7]; } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_extract_epi16(__m256i __a, const int __imm) { __v16hi __b = (__v16hi)__a; return __b[__imm & 15]; } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_extract_epi8(__m256i __a, const int __imm) { __v32qi __b = (__v32qi)__a; @@ -451,7 +454,7 @@ _mm256_extract_epi8(__m256i __a, const int __imm) } #ifdef __x86_64__ -static __inline long long __attribute__((__always_inline__, __nodebug__)) +static __inline long long DEFAULT_FN_ATTRS _mm256_extract_epi64(__m256i __a, const int __imm) { __v4di __b = (__v4di)__a; @@ -459,7 +462,7 @@ _mm256_extract_epi64(__m256i __a, const int __imm) } #endif -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_insert_epi32(__m256i __a, int __b, int const __imm) { __v8si __c = (__v8si)__a; @@ -467,7 +470,7 @@ _mm256_insert_epi32(__m256i __a, int __b, int const __imm) return (__m256i)__c; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_insert_epi16(__m256i __a, int __b, int const __imm) { __v16hi __c = (__v16hi)__a; @@ -475,7 +478,7 @@ _mm256_insert_epi16(__m256i __a, int __b, int const __imm) return (__m256i)__c; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_insert_epi8(__m256i __a, int __b, int const __imm) { __v32qi __c = (__v32qi)__a; @@ -484,7 +487,7 @@ _mm256_insert_epi8(__m256i __a, int __b, int const __imm) } #ifdef __x86_64__ -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_insert_epi64(__m256i __a, long long __b, int const __imm) { __v4di __c = (__v4di)__a; @@ -494,263 +497,263 @@ _mm256_insert_epi64(__m256i __a, long long __b, int const __imm) #endif /* Conversion */ -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_cvtepi32_pd(__m128i __a) { return (__m256d)__builtin_ia32_cvtdq2pd256((__v4si) __a); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_cvtepi32_ps(__m256i __a) { return (__m256)__builtin_ia32_cvtdq2ps256((__v8si) __a); } -static __inline __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline __m128 DEFAULT_FN_ATTRS _mm256_cvtpd_ps(__m256d __a) { return (__m128)__builtin_ia32_cvtpd2ps256((__v4df) __a); } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_cvtps_epi32(__m256 __a) { return (__m256i)__builtin_ia32_cvtps2dq256((__v8sf) __a); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_cvtps_pd(__m128 __a) { return (__m256d)__builtin_ia32_cvtps2pd256((__v4sf) __a); } -static __inline __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline __m128i DEFAULT_FN_ATTRS _mm256_cvttpd_epi32(__m256d __a) { return (__m128i)__builtin_ia32_cvttpd2dq256((__v4df) __a); } -static __inline __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline __m128i DEFAULT_FN_ATTRS _mm256_cvtpd_epi32(__m256d __a) { return (__m128i)__builtin_ia32_cvtpd2dq256((__v4df) __a); } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_cvttps_epi32(__m256 __a) { return (__m256i)__builtin_ia32_cvttps2dq256((__v8sf) __a); } /* Vector replicate */ -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_movehdup_ps(__m256 __a) { return __builtin_shufflevector(__a, __a, 1, 1, 3, 3, 5, 5, 7, 7); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_moveldup_ps(__m256 __a) { return __builtin_shufflevector(__a, __a, 0, 0, 2, 2, 4, 4, 6, 6); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_movedup_pd(__m256d __a) { return __builtin_shufflevector(__a, __a, 0, 0, 2, 2); } /* Unpack and Interleave */ -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_unpackhi_pd(__m256d __a, __m256d __b) { return __builtin_shufflevector(__a, __b, 1, 5, 1+2, 5+2); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_unpacklo_pd(__m256d __a, __m256d __b) { return __builtin_shufflevector(__a, __b, 0, 4, 0+2, 4+2); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_unpackhi_ps(__m256 __a, __m256 __b) { return __builtin_shufflevector(__a, __b, 2, 10, 2+1, 10+1, 6, 14, 6+1, 14+1); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_unpacklo_ps(__m256 __a, __m256 __b) { return __builtin_shufflevector(__a, __b, 0, 8, 0+1, 8+1, 4, 12, 4+1, 12+1); } /* Bit Test */ -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm_testz_pd(__m128d __a, __m128d __b) { return __builtin_ia32_vtestzpd((__v2df)__a, (__v2df)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm_testc_pd(__m128d __a, __m128d __b) { return __builtin_ia32_vtestcpd((__v2df)__a, (__v2df)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm_testnzc_pd(__m128d __a, __m128d __b) { return __builtin_ia32_vtestnzcpd((__v2df)__a, (__v2df)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm_testz_ps(__m128 __a, __m128 __b) { return __builtin_ia32_vtestzps((__v4sf)__a, (__v4sf)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm_testc_ps(__m128 __a, __m128 __b) { return __builtin_ia32_vtestcps((__v4sf)__a, (__v4sf)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm_testnzc_ps(__m128 __a, __m128 __b) { return __builtin_ia32_vtestnzcps((__v4sf)__a, (__v4sf)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_testz_pd(__m256d __a, __m256d __b) { return __builtin_ia32_vtestzpd256((__v4df)__a, (__v4df)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_testc_pd(__m256d __a, __m256d __b) { return __builtin_ia32_vtestcpd256((__v4df)__a, (__v4df)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_testnzc_pd(__m256d __a, __m256d __b) { return __builtin_ia32_vtestnzcpd256((__v4df)__a, (__v4df)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_testz_ps(__m256 __a, __m256 __b) { return __builtin_ia32_vtestzps256((__v8sf)__a, (__v8sf)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_testc_ps(__m256 __a, __m256 __b) { return __builtin_ia32_vtestcps256((__v8sf)__a, (__v8sf)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_testnzc_ps(__m256 __a, __m256 __b) { return __builtin_ia32_vtestnzcps256((__v8sf)__a, (__v8sf)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_testz_si256(__m256i __a, __m256i __b) { return __builtin_ia32_ptestz256((__v4di)__a, (__v4di)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_testc_si256(__m256i __a, __m256i __b) { return __builtin_ia32_ptestc256((__v4di)__a, (__v4di)__b); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_testnzc_si256(__m256i __a, __m256i __b) { return __builtin_ia32_ptestnzc256((__v4di)__a, (__v4di)__b); } /* Vector extract sign mask */ -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_movemask_pd(__m256d __a) { return __builtin_ia32_movmskpd256((__v4df)__a); } -static __inline int __attribute__((__always_inline__, __nodebug__)) +static __inline int DEFAULT_FN_ATTRS _mm256_movemask_ps(__m256 __a) { return __builtin_ia32_movmskps256((__v8sf)__a); } /* Vector __zero */ -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_zeroall(void) { __builtin_ia32_vzeroall(); } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_zeroupper(void) { __builtin_ia32_vzeroupper(); } /* Vector load with broadcast */ -static __inline __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline __m128 DEFAULT_FN_ATTRS _mm_broadcast_ss(float const *__a) { float __f = *__a; return (__m128)(__v4sf){ __f, __f, __f, __f }; } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_broadcast_sd(double const *__a) { double __d = *__a; return (__m256d)(__v4df){ __d, __d, __d, __d }; } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_broadcast_ss(float const *__a) { float __f = *__a; return (__m256)(__v8sf){ __f, __f, __f, __f, __f, __f, __f, __f }; } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_broadcast_pd(__m128d const *__a) { return (__m256d)__builtin_ia32_vbroadcastf128_pd256(__a); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_broadcast_ps(__m128 const *__a) { return (__m256)__builtin_ia32_vbroadcastf128_ps256(__a); } /* SIMD load ops */ -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_load_pd(double const *__p) { return *(__m256d *)__p; } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_load_ps(float const *__p) { return *(__m256 *)__p; } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_loadu_pd(double const *__p) { struct __loadu_pd { @@ -759,7 +762,7 @@ _mm256_loadu_pd(double const *__p) return ((struct __loadu_pd*)__p)->__v; } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_loadu_ps(float const *__p) { struct __loadu_ps { @@ -768,13 +771,13 @@ _mm256_loadu_ps(float const *__p) return ((struct __loadu_ps*)__p)->__v; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_load_si256(__m256i const *__p) { return *__p; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_loadu_si256(__m256i const *__p) { struct __loadu_si256 { @@ -783,141 +786,141 @@ _mm256_loadu_si256(__m256i const *__p) return ((struct __loadu_si256*)__p)->__v; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_lddqu_si256(__m256i const *__p) { return (__m256i)__builtin_ia32_lddqu256((char const *)__p); } /* SIMD store ops */ -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_store_pd(double *__p, __m256d __a) { *(__m256d *)__p = __a; } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_store_ps(float *__p, __m256 __a) { *(__m256 *)__p = __a; } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_storeu_pd(double *__p, __m256d __a) { __builtin_ia32_storeupd256(__p, (__v4df)__a); } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_storeu_ps(float *__p, __m256 __a) { __builtin_ia32_storeups256(__p, (__v8sf)__a); } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_store_si256(__m256i *__p, __m256i __a) { *__p = __a; } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_storeu_si256(__m256i *__p, __m256i __a) { __builtin_ia32_storedqu256((char *)__p, (__v32qi)__a); } /* Conditional load ops */ -static __inline __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline __m128d DEFAULT_FN_ATTRS _mm_maskload_pd(double const *__p, __m128d __m) { return (__m128d)__builtin_ia32_maskloadpd((const __v2df *)__p, (__v2df)__m); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_maskload_pd(double const *__p, __m256d __m) { return (__m256d)__builtin_ia32_maskloadpd256((const __v4df *)__p, (__v4df)__m); } -static __inline __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline __m128 DEFAULT_FN_ATTRS _mm_maskload_ps(float const *__p, __m128 __m) { return (__m128)__builtin_ia32_maskloadps((const __v4sf *)__p, (__v4sf)__m); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_maskload_ps(float const *__p, __m256 __m) { return (__m256)__builtin_ia32_maskloadps256((const __v8sf *)__p, (__v8sf)__m); } /* Conditional store ops */ -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_maskstore_ps(float *__p, __m256 __m, __m256 __a) { __builtin_ia32_maskstoreps256((__v8sf *)__p, (__v8sf)__m, (__v8sf)__a); } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm_maskstore_pd(double *__p, __m128d __m, __m128d __a) { __builtin_ia32_maskstorepd((__v2df *)__p, (__v2df)__m, (__v2df)__a); } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_maskstore_pd(double *__p, __m256d __m, __m256d __a) { __builtin_ia32_maskstorepd256((__v4df *)__p, (__v4df)__m, (__v4df)__a); } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm_maskstore_ps(float *__p, __m128 __m, __m128 __a) { __builtin_ia32_maskstoreps((__v4sf *)__p, (__v4sf)__m, (__v4sf)__a); } /* Cacheability support ops */ -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_stream_si256(__m256i *__a, __m256i __b) { __builtin_ia32_movntdq256((__v4di *)__a, (__v4di)__b); } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_stream_pd(double *__a, __m256d __b) { __builtin_ia32_movntpd256(__a, (__v4df)__b); } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_stream_ps(float *__p, __m256 __a) { __builtin_ia32_movntps256(__p, (__v8sf)__a); } /* Create vectors */ -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_set_pd(double __a, double __b, double __c, double __d) { return (__m256d){ __d, __c, __b, __a }; } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_set_ps(float __a, float __b, float __c, float __d, float __e, float __f, float __g, float __h) { return (__m256){ __h, __g, __f, __e, __d, __c, __b, __a }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_set_epi32(int __i0, int __i1, int __i2, int __i3, int __i4, int __i5, int __i6, int __i7) { return (__m256i)(__v8si){ __i7, __i6, __i5, __i4, __i3, __i2, __i1, __i0 }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_set_epi16(short __w15, short __w14, short __w13, short __w12, short __w11, short __w10, short __w09, short __w08, short __w07, short __w06, short __w05, short __w04, @@ -927,7 +930,7 @@ _mm256_set_epi16(short __w15, short __w14, short __w13, short __w12, __w07, __w08, __w09, __w10, __w11, __w12, __w13, __w14, __w15 }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_set_epi8(char __b31, char __b30, char __b29, char __b28, char __b27, char __b26, char __b25, char __b24, char __b23, char __b22, char __b21, char __b20, @@ -945,34 +948,34 @@ _mm256_set_epi8(char __b31, char __b30, char __b29, char __b28, }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_set_epi64x(long long __a, long long __b, long long __c, long long __d) { return (__m256i)(__v4di){ __d, __c, __b, __a }; } /* Create vectors with elements in reverse order */ -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_setr_pd(double __a, double __b, double __c, double __d) { return (__m256d){ __a, __b, __c, __d }; } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_setr_ps(float __a, float __b, float __c, float __d, float __e, float __f, float __g, float __h) { return (__m256){ __a, __b, __c, __d, __e, __f, __g, __h }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_setr_epi32(int __i0, int __i1, int __i2, int __i3, int __i4, int __i5, int __i6, int __i7) { return (__m256i)(__v8si){ __i0, __i1, __i2, __i3, __i4, __i5, __i6, __i7 }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_setr_epi16(short __w15, short __w14, short __w13, short __w12, short __w11, short __w10, short __w09, short __w08, short __w07, short __w06, short __w05, short __w04, @@ -982,7 +985,7 @@ _mm256_setr_epi16(short __w15, short __w14, short __w13, short __w12, __w08, __w07, __w06, __w05, __w04, __w03, __w02, __w01, __w00 }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_setr_epi8(char __b31, char __b30, char __b29, char __b28, char __b27, char __b26, char __b25, char __b24, char __b23, char __b22, char __b21, char __b20, @@ -999,39 +1002,39 @@ _mm256_setr_epi8(char __b31, char __b30, char __b29, char __b28, __b07, __b06, __b05, __b04, __b03, __b02, __b01, __b00 }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_setr_epi64x(long long __a, long long __b, long long __c, long long __d) { return (__m256i)(__v4di){ __a, __b, __c, __d }; } /* Create vectors with repeated elements */ -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_set1_pd(double __w) { return (__m256d){ __w, __w, __w, __w }; } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_set1_ps(float __w) { return (__m256){ __w, __w, __w, __w, __w, __w, __w, __w }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_set1_epi32(int __i) { return (__m256i)(__v8si){ __i, __i, __i, __i, __i, __i, __i, __i }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_set1_epi16(short __w) { return (__m256i)(__v16hi){ __w, __w, __w, __w, __w, __w, __w, __w, __w, __w, __w, __w, __w, __w, __w, __w }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_set1_epi8(char __b) { return (__m256i)(__v32qi){ __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, @@ -1039,99 +1042,99 @@ _mm256_set1_epi8(char __b) __b, __b, __b, __b, __b, __b, __b }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_set1_epi64x(long long __q) { return (__m256i)(__v4di){ __q, __q, __q, __q }; } /* Create __zeroed vectors */ -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_setzero_pd(void) { return (__m256d){ 0, 0, 0, 0 }; } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_setzero_ps(void) { return (__m256){ 0, 0, 0, 0, 0, 0, 0, 0 }; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_setzero_si256(void) { return (__m256i){ 0LL, 0LL, 0LL, 0LL }; } /* Cast between vector types */ -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_castpd_ps(__m256d __a) { return (__m256)__a; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_castpd_si256(__m256d __a) { return (__m256i)__a; } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_castps_pd(__m256 __a) { return (__m256d)__a; } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_castps_si256(__m256 __a) { return (__m256i)__a; } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_castsi256_ps(__m256i __a) { return (__m256)__a; } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_castsi256_pd(__m256i __a) { return (__m256d)__a; } -static __inline __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline __m128d DEFAULT_FN_ATTRS _mm256_castpd256_pd128(__m256d __a) { return __builtin_shufflevector(__a, __a, 0, 1); } -static __inline __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline __m128 DEFAULT_FN_ATTRS _mm256_castps256_ps128(__m256 __a) { return __builtin_shufflevector(__a, __a, 0, 1, 2, 3); } -static __inline __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline __m128i DEFAULT_FN_ATTRS _mm256_castsi256_si128(__m256i __a) { return __builtin_shufflevector(__a, __a, 0, 1); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_castpd128_pd256(__m128d __a) { return __builtin_shufflevector(__a, __a, 0, 1, -1, -1); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_castps128_ps256(__m128 __a) { return __builtin_shufflevector(__a, __a, 0, 1, 2, 3, -1, -1, -1, -1); } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_castsi128_si256(__m128i __a) { return __builtin_shufflevector(__a, __a, 0, 1, -1, -1); @@ -1202,7 +1205,7 @@ _mm256_castsi128_si256(__m128i __a) (((M) & 1) ? 3 : 1) );}) /* SIMD load ops (unaligned) */ -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_loadu2_m128(float const *__addr_hi, float const *__addr_lo) { struct __loadu_ps { @@ -1213,7 +1216,7 @@ _mm256_loadu2_m128(float const *__addr_hi, float const *__addr_lo) return _mm256_insertf128_ps(__v256, ((struct __loadu_ps*)__addr_hi)->__v, 1); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_loadu2_m128d(double const *__addr_hi, double const *__addr_lo) { struct __loadu_pd { @@ -1224,7 +1227,7 @@ _mm256_loadu2_m128d(double const *__addr_hi, double const *__addr_lo) return _mm256_insertf128_pd(__v256, ((struct __loadu_pd*)__addr_hi)->__v, 1); } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_loadu2_m128i(__m128i const *__addr_hi, __m128i const *__addr_lo) { struct __loadu_si128 { @@ -1237,7 +1240,7 @@ _mm256_loadu2_m128i(__m128i const *__addr_hi, __m128i const *__addr_lo) } /* SIMD store ops (unaligned) */ -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_storeu2_m128(float *__addr_hi, float *__addr_lo, __m256 __a) { __m128 __v128; @@ -1248,7 +1251,7 @@ _mm256_storeu2_m128(float *__addr_hi, float *__addr_lo, __m256 __a) __builtin_ia32_storeups(__addr_hi, __v128); } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_storeu2_m128d(double *__addr_hi, double *__addr_lo, __m256d __a) { __m128d __v128; @@ -1259,7 +1262,7 @@ _mm256_storeu2_m128d(double *__addr_hi, double *__addr_lo, __m256d __a) __builtin_ia32_storeupd(__addr_hi, __v128); } -static __inline void __attribute__((__always_inline__, __nodebug__)) +static __inline void DEFAULT_FN_ATTRS _mm256_storeu2_m128i(__m128i *__addr_hi, __m128i *__addr_lo, __m256i __a) { __m128i __v128; @@ -1270,34 +1273,36 @@ _mm256_storeu2_m128i(__m128i *__addr_hi, __m128i *__addr_lo, __m256i __a) __builtin_ia32_storedqu((char *)__addr_hi, (__v16qi)__v128); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_set_m128 (__m128 __hi, __m128 __lo) { return (__m256) __builtin_shufflevector(__lo, __hi, 0, 1, 2, 3, 4, 5, 6, 7); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_set_m128d (__m128d __hi, __m128d __lo) { return (__m256d)_mm256_set_m128((__m128)__hi, (__m128)__lo); } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_set_m128i (__m128i __hi, __m128i __lo) { return (__m256i)_mm256_set_m128((__m128)__hi, (__m128)__lo); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_setr_m128 (__m128 __lo, __m128 __hi) { return _mm256_set_m128(__hi, __lo); } -static __inline __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline __m256d DEFAULT_FN_ATTRS _mm256_setr_m128d (__m128d __lo, __m128d __hi) { return (__m256d)_mm256_set_m128((__m128)__hi, (__m128)__lo); } -static __inline __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline __m256i DEFAULT_FN_ATTRS _mm256_setr_m128i (__m128i __lo, __m128i __hi) { return (__m256i)_mm256_set_m128((__m128)__hi, (__m128)__lo); } +#undef DEFAULT_FN_ATTRS + #endif /* __AVXINTRIN_H */ diff --git a/lib/Headers/bmi2intrin.h b/lib/Headers/bmi2intrin.h index a05cfad3d027..7818934e17c2 100644 --- a/lib/Headers/bmi2intrin.h +++ b/lib/Headers/bmi2intrin.h @@ -25,26 +25,25 @@ #error "Never use <bmi2intrin.h> directly; include <x86intrin.h> instead." #endif -#ifndef __BMI2__ -# error "BMI2 instruction set not enabled" -#endif /* __BMI2__ */ - #ifndef __BMI2INTRIN_H #define __BMI2INTRIN_H -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi2"))) + +static __inline__ unsigned int DEFAULT_FN_ATTRS _bzhi_u32(unsigned int __X, unsigned int __Y) { return __builtin_ia32_bzhi_si(__X, __Y); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS _pdep_u32(unsigned int __X, unsigned int __Y) { return __builtin_ia32_pdep_si(__X, __Y); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS _pext_u32(unsigned int __X, unsigned int __Y) { return __builtin_ia32_pext_si(__X, __Y); @@ -52,25 +51,25 @@ _pext_u32(unsigned int __X, unsigned int __Y) #ifdef __x86_64__ -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS _bzhi_u64(unsigned long long __X, unsigned long long __Y) { return __builtin_ia32_bzhi_di(__X, __Y); } -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS _pdep_u64(unsigned long long __X, unsigned long long __Y) { return __builtin_ia32_pdep_di(__X, __Y); } -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS _pext_u64(unsigned long long __X, unsigned long long __Y) { return __builtin_ia32_pext_di(__X, __Y); } -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS _mulx_u64 (unsigned long long __X, unsigned long long __Y, unsigned long long *__P) { @@ -81,7 +80,7 @@ _mulx_u64 (unsigned long long __X, unsigned long long __Y, #else /* !__x86_64__ */ -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS _mulx_u32 (unsigned int __X, unsigned int __Y, unsigned int *__P) { unsigned long long __res = (unsigned long long) __X * __Y; @@ -91,4 +90,6 @@ _mulx_u32 (unsigned int __X, unsigned int __Y, unsigned int *__P) #endif /* !__x86_64__ */ +#undef DEFAULT_FN_ATTRS + #endif /* __BMI2INTRIN_H */ diff --git a/lib/Headers/bmiintrin.h b/lib/Headers/bmiintrin.h index 0e5fd5551fb3..0aad8f24ea00 100644 --- a/lib/Headers/bmiintrin.h +++ b/lib/Headers/bmiintrin.h @@ -25,10 +25,6 @@ #error "Never use <bmiintrin.h> directly; include <x86intrin.h> instead." #endif -#ifndef __BMI__ -# error "BMI instruction set not enabled" -#endif /* __BMI__ */ - #ifndef __BMIINTRIN_H #define __BMIINTRIN_H @@ -40,51 +36,54 @@ #define _blsr_u32(a) (__blsr_u32((a))) #define _tzcnt_u32(a) (__tzcnt_u32((a))) -static __inline__ unsigned short __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi"))) + +static __inline__ unsigned short DEFAULT_FN_ATTRS __tzcnt_u16(unsigned short __X) { return __X ? __builtin_ctzs(__X) : 16; } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __andn_u32(unsigned int __X, unsigned int __Y) { return ~__X & __Y; } /* AMD-specified, double-leading-underscore version of BEXTR */ -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __bextr_u32(unsigned int __X, unsigned int __Y) { return __builtin_ia32_bextr_u32(__X, __Y); } /* Intel-specified, single-leading-underscore version of BEXTR */ -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS _bextr_u32(unsigned int __X, unsigned int __Y, unsigned int __Z) { return __builtin_ia32_bextr_u32 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8))); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __blsi_u32(unsigned int __X) { return __X & -__X; } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __blsmsk_u32(unsigned int __X) { return __X ^ (__X - 1); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __blsr_u32(unsigned int __X) { return __X & (__X - 1); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __tzcnt_u32(unsigned int __X) { return __X ? __builtin_ctz(__X) : 32; @@ -99,45 +98,45 @@ __tzcnt_u32(unsigned int __X) #define _blsr_u64(a) (__blsr_u64((a))) #define _tzcnt_u64(a) (__tzcnt_u64((a))) -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __andn_u64 (unsigned long long __X, unsigned long long __Y) { return ~__X & __Y; } /* AMD-specified, double-leading-underscore version of BEXTR */ -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __bextr_u64(unsigned long long __X, unsigned long long __Y) { return __builtin_ia32_bextr_u64(__X, __Y); } /* Intel-specified, single-leading-underscore version of BEXTR */ -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS _bextr_u64(unsigned long long __X, unsigned int __Y, unsigned int __Z) { return __builtin_ia32_bextr_u64 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8))); } -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __blsi_u64(unsigned long long __X) { return __X & -__X; } -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __blsmsk_u64(unsigned long long __X) { return __X ^ (__X - 1); } -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __blsr_u64(unsigned long long __X) { return __X & (__X - 1); } -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __tzcnt_u64(unsigned long long __X) { return __X ? __builtin_ctzll(__X) : 64; @@ -145,4 +144,6 @@ __tzcnt_u64(unsigned long long __X) #endif /* __x86_64__ */ +#undef DEFAULT_FN_ATTRS + #endif /* __BMIINTRIN_H */ diff --git a/lib/Headers/emmintrin.h b/lib/Headers/emmintrin.h index c764d68a185d..eee2428d41a0 100644 --- a/lib/Headers/emmintrin.h +++ b/lib/Headers/emmintrin.h @@ -24,10 +24,6 @@ #ifndef __EMMINTRIN_H #define __EMMINTRIN_H -#ifndef __SSE2__ -#error "SSE2 instruction set not enabled" -#else - #include <xmmintrin.h> typedef double __m128d __attribute__((__vector_size__(16))); @@ -39,433 +35,436 @@ typedef long long __v2di __attribute__ ((__vector_size__ (16))); typedef short __v8hi __attribute__((__vector_size__(16))); typedef char __v16qi __attribute__((__vector_size__(16))); -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse2"))) + +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_add_sd(__m128d __a, __m128d __b) { __a[0] += __b[0]; return __a; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_add_pd(__m128d __a, __m128d __b) { return __a + __b; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_sub_sd(__m128d __a, __m128d __b) { __a[0] -= __b[0]; return __a; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_sub_pd(__m128d __a, __m128d __b) { return __a - __b; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_mul_sd(__m128d __a, __m128d __b) { __a[0] *= __b[0]; return __a; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_mul_pd(__m128d __a, __m128d __b) { return __a * __b; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_div_sd(__m128d __a, __m128d __b) { __a[0] /= __b[0]; return __a; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_div_pd(__m128d __a, __m128d __b) { return __a / __b; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_sqrt_sd(__m128d __a, __m128d __b) { __m128d __c = __builtin_ia32_sqrtsd(__b); return (__m128d) { __c[0], __a[1] }; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_sqrt_pd(__m128d __a) { return __builtin_ia32_sqrtpd(__a); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_min_sd(__m128d __a, __m128d __b) { return __builtin_ia32_minsd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_min_pd(__m128d __a, __m128d __b) { return __builtin_ia32_minpd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_max_sd(__m128d __a, __m128d __b) { return __builtin_ia32_maxsd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_max_pd(__m128d __a, __m128d __b) { return __builtin_ia32_maxpd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_and_pd(__m128d __a, __m128d __b) { return (__m128d)((__v4si)__a & (__v4si)__b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_andnot_pd(__m128d __a, __m128d __b) { return (__m128d)(~(__v4si)__a & (__v4si)__b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_or_pd(__m128d __a, __m128d __b) { return (__m128d)((__v4si)__a | (__v4si)__b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_xor_pd(__m128d __a, __m128d __b) { return (__m128d)((__v4si)__a ^ (__v4si)__b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpeq_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpeqpd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmplt_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpltpd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmple_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmplepd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpgt_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpltpd(__b, __a); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpge_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmplepd(__b, __a); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpord_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpordpd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpunord_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpunordpd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpneq_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpneqpd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpnlt_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpnltpd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpnle_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpnlepd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpngt_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpnltpd(__b, __a); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpnge_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpnlepd(__b, __a); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpeq_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpeqsd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmplt_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpltsd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmple_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmplesd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpgt_sd(__m128d __a, __m128d __b) { __m128d __c = __builtin_ia32_cmpltsd(__b, __a); return (__m128d) { __c[0], __a[1] }; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpge_sd(__m128d __a, __m128d __b) { __m128d __c = __builtin_ia32_cmplesd(__b, __a); return (__m128d) { __c[0], __a[1] }; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpord_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpordsd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpunord_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpunordsd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpneq_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpneqsd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpnlt_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpnltsd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpnle_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpnlesd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpngt_sd(__m128d __a, __m128d __b) { __m128d __c = __builtin_ia32_cmpnltsd(__b, __a); return (__m128d) { __c[0], __a[1] }; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cmpnge_sd(__m128d __a, __m128d __b) { __m128d __c = __builtin_ia32_cmpnlesd(__b, __a); return (__m128d) { __c[0], __a[1] }; } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_comieq_sd(__m128d __a, __m128d __b) { return __builtin_ia32_comisdeq(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_comilt_sd(__m128d __a, __m128d __b) { return __builtin_ia32_comisdlt(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_comile_sd(__m128d __a, __m128d __b) { return __builtin_ia32_comisdle(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_comigt_sd(__m128d __a, __m128d __b) { return __builtin_ia32_comisdgt(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_comige_sd(__m128d __a, __m128d __b) { return __builtin_ia32_comisdge(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_comineq_sd(__m128d __a, __m128d __b) { return __builtin_ia32_comisdneq(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_ucomieq_sd(__m128d __a, __m128d __b) { return __builtin_ia32_ucomisdeq(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_ucomilt_sd(__m128d __a, __m128d __b) { return __builtin_ia32_ucomisdlt(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_ucomile_sd(__m128d __a, __m128d __b) { return __builtin_ia32_ucomisdle(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_ucomigt_sd(__m128d __a, __m128d __b) { return __builtin_ia32_ucomisdgt(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_ucomige_sd(__m128d __a, __m128d __b) { return __builtin_ia32_ucomisdge(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_ucomineq_sd(__m128d __a, __m128d __b) { return __builtin_ia32_ucomisdneq(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvtpd_ps(__m128d __a) { return __builtin_ia32_cvtpd2ps(__a); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cvtps_pd(__m128 __a) { return __builtin_ia32_cvtps2pd(__a); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cvtepi32_pd(__m128i __a) { return __builtin_ia32_cvtdq2pd((__v4si)__a); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtpd_epi32(__m128d __a) { return __builtin_ia32_cvtpd2dq(__a); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_cvtsd_si32(__m128d __a) { return __builtin_ia32_cvtsd2si(__a); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvtsd_ss(__m128 __a, __m128d __b) { __a[0] = __b[0]; return __a; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cvtsi32_sd(__m128d __a, int __b) { __a[0] = __b; return __a; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cvtss_sd(__m128d __a, __m128 __b) { __a[0] = __b[0]; return __a; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvttpd_epi32(__m128d __a) { return (__m128i)__builtin_ia32_cvttpd2dq(__a); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_cvttsd_si32(__m128d __a) { return __a[0]; } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cvtpd_pi32(__m128d __a) { return (__m64)__builtin_ia32_cvtpd2pi(__a); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cvttpd_pi32(__m128d __a) { return (__m64)__builtin_ia32_cvttpd2pi(__a); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cvtpi32_pd(__m64 __a) { return __builtin_ia32_cvtpi2pd((__v2si)__a); } -static __inline__ double __attribute__((__always_inline__, __nodebug__)) +static __inline__ double DEFAULT_FN_ATTRS _mm_cvtsd_f64(__m128d __a) { return __a[0]; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_load_pd(double const *__dp) { return *(__m128d*)__dp; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_load1_pd(double const *__dp) { struct __mm_load1_pd_struct { @@ -477,14 +476,14 @@ _mm_load1_pd(double const *__dp) #define _mm_load_pd1(dp) _mm_load1_pd(dp) -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_loadr_pd(double const *__dp) { __m128d __u = *(__m128d*)__dp; return __builtin_shufflevector(__u, __u, 1, 0); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_loadu_pd(double const *__dp) { struct __loadu_pd { @@ -493,7 +492,7 @@ _mm_loadu_pd(double const *__dp) return ((struct __loadu_pd*)__dp)->__v; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_load_sd(double const *__dp) { struct __mm_load_sd_struct { @@ -503,7 +502,7 @@ _mm_load_sd(double const *__dp) return (__m128d){ __u, 0 }; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_loadh_pd(__m128d __a, double const *__dp) { struct __mm_loadh_pd_struct { @@ -513,7 +512,7 @@ _mm_loadh_pd(__m128d __a, double const *__dp) return (__m128d){ __a[0], __u }; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_loadl_pd(__m128d __a, double const *__dp) { struct __mm_loadl_pd_struct { @@ -523,43 +522,43 @@ _mm_loadl_pd(__m128d __a, double const *__dp) return (__m128d){ __u, __a[1] }; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_set_sd(double __w) { return (__m128d){ __w, 0 }; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_set1_pd(double __w) { return (__m128d){ __w, __w }; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_set_pd(double __w, double __x) { return (__m128d){ __x, __w }; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_setr_pd(double __w, double __x) { return (__m128d){ __w, __x }; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_setzero_pd(void) { return (__m128d){ 0, 0 }; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_move_sd(__m128d __a, __m128d __b) { return (__m128d){ __b[0], __a[1] }; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_store_sd(double *__dp, __m128d __a) { struct __mm_store_sd_struct { @@ -568,7 +567,7 @@ _mm_store_sd(double *__dp, __m128d __a) ((struct __mm_store_sd_struct*)__dp)->__u = __a[0]; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_store1_pd(double *__dp, __m128d __a) { struct __mm_store1_pd_struct { @@ -578,26 +577,26 @@ _mm_store1_pd(double *__dp, __m128d __a) ((struct __mm_store1_pd_struct*)__dp)->__u[1] = __a[0]; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_store_pd(double *__dp, __m128d __a) { *(__m128d *)__dp = __a; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_storeu_pd(double *__dp, __m128d __a) { __builtin_ia32_storeupd(__dp, __a); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_storer_pd(double *__dp, __m128d __a) { __a = __builtin_shufflevector(__a, __a, 1, 0); *(__m128d *)__dp = __a; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_storeh_pd(double *__dp, __m128d __a) { struct __mm_storeh_pd_struct { @@ -606,7 +605,7 @@ _mm_storeh_pd(double *__dp, __m128d __a) ((struct __mm_storeh_pd_struct*)__dp)->__u = __a[1]; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_storel_pd(double *__dp, __m128d __a) { struct __mm_storeh_pd_struct { @@ -615,211 +614,211 @@ _mm_storel_pd(double *__dp, __m128d __a) ((struct __mm_storeh_pd_struct*)__dp)->__u = __a[0]; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_add_epi8(__m128i __a, __m128i __b) { return (__m128i)((__v16qi)__a + (__v16qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_add_epi16(__m128i __a, __m128i __b) { return (__m128i)((__v8hi)__a + (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_add_epi32(__m128i __a, __m128i __b) { return (__m128i)((__v4si)__a + (__v4si)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_add_si64(__m64 __a, __m64 __b) { return __a + __b; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_add_epi64(__m128i __a, __m128i __b) { return __a + __b; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_adds_epi8(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_paddsb128((__v16qi)__a, (__v16qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_adds_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_paddsw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_adds_epu8(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_paddusb128((__v16qi)__a, (__v16qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_adds_epu16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_paddusw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_avg_epu8(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pavgb128((__v16qi)__a, (__v16qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_avg_epu16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pavgw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_madd_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pmaddwd128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_max_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pmaxsw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_max_epu8(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pmaxub128((__v16qi)__a, (__v16qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_min_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pminsw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_min_epu8(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pminub128((__v16qi)__a, (__v16qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mulhi_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pmulhw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mulhi_epu16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pmulhuw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mullo_epi16(__m128i __a, __m128i __b) { return (__m128i)((__v8hi)__a * (__v8hi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_mul_su32(__m64 __a, __m64 __b) { return __builtin_ia32_pmuludq((__v2si)__a, (__v2si)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mul_epu32(__m128i __a, __m128i __b) { return __builtin_ia32_pmuludq128((__v4si)__a, (__v4si)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sad_epu8(__m128i __a, __m128i __b) { return __builtin_ia32_psadbw128((__v16qi)__a, (__v16qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sub_epi8(__m128i __a, __m128i __b) { return (__m128i)((__v16qi)__a - (__v16qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sub_epi16(__m128i __a, __m128i __b) { return (__m128i)((__v8hi)__a - (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sub_epi32(__m128i __a, __m128i __b) { return (__m128i)((__v4si)__a - (__v4si)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sub_si64(__m64 __a, __m64 __b) { return __a - __b; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sub_epi64(__m128i __a, __m128i __b) { return __a - __b; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_subs_epi8(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_psubsb128((__v16qi)__a, (__v16qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_subs_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_psubsw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_subs_epu8(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_psubusb128((__v16qi)__a, (__v16qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_subs_epu16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_psubusw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_and_si128(__m128i __a, __m128i __b) { return __a & __b; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_andnot_si128(__m128i __a, __m128i __b) { return ~__a & __b; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_or_si128(__m128i __a, __m128i __b) { return __a | __b; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_xor_si128(__m128i __a, __m128i __b) { return __a ^ __b; @@ -848,61 +847,61 @@ _mm_xor_si128(__m128i __a, __m128i __b) #define _mm_bslli_si128(a, imm) \ _mm_slli_si128((a), (imm)) -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_slli_epi16(__m128i __a, int __count) { return (__m128i)__builtin_ia32_psllwi128((__v8hi)__a, __count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sll_epi16(__m128i __a, __m128i __count) { return (__m128i)__builtin_ia32_psllw128((__v8hi)__a, (__v8hi)__count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_slli_epi32(__m128i __a, int __count) { return (__m128i)__builtin_ia32_pslldi128((__v4si)__a, __count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sll_epi32(__m128i __a, __m128i __count) { return (__m128i)__builtin_ia32_pslld128((__v4si)__a, (__v4si)__count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_slli_epi64(__m128i __a, int __count) { return __builtin_ia32_psllqi128(__a, __count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sll_epi64(__m128i __a, __m128i __count) { return __builtin_ia32_psllq128(__a, __count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_srai_epi16(__m128i __a, int __count) { return (__m128i)__builtin_ia32_psrawi128((__v8hi)__a, __count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sra_epi16(__m128i __a, __m128i __count) { return (__m128i)__builtin_ia32_psraw128((__v8hi)__a, (__v8hi)__count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_srai_epi32(__m128i __a, int __count) { return (__m128i)__builtin_ia32_psradi128((__v4si)__a, __count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sra_epi32(__m128i __a, __m128i __count) { return (__m128i)__builtin_ia32_psrad128((__v4si)__a, (__v4si)__count); @@ -931,61 +930,61 @@ _mm_sra_epi32(__m128i __a, __m128i __count) #define _mm_bsrli_si128(a, imm) \ _mm_srli_si128((a), (imm)) -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_srli_epi16(__m128i __a, int __count) { return (__m128i)__builtin_ia32_psrlwi128((__v8hi)__a, __count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_srl_epi16(__m128i __a, __m128i __count) { return (__m128i)__builtin_ia32_psrlw128((__v8hi)__a, (__v8hi)__count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_srli_epi32(__m128i __a, int __count) { return (__m128i)__builtin_ia32_psrldi128((__v4si)__a, __count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_srl_epi32(__m128i __a, __m128i __count) { return (__m128i)__builtin_ia32_psrld128((__v4si)__a, (__v4si)__count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_srli_epi64(__m128i __a, int __count) { return __builtin_ia32_psrlqi128(__a, __count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_srl_epi64(__m128i __a, __m128i __count) { return __builtin_ia32_psrlq128(__a, __count); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cmpeq_epi8(__m128i __a, __m128i __b) { return (__m128i)((__v16qi)__a == (__v16qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cmpeq_epi16(__m128i __a, __m128i __b) { return (__m128i)((__v8hi)__a == (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cmpeq_epi32(__m128i __a, __m128i __b) { return (__m128i)((__v4si)__a == (__v4si)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cmpgt_epi8(__m128i __a, __m128i __b) { /* This function always performs a signed comparison, but __v16qi is a char @@ -994,90 +993,90 @@ _mm_cmpgt_epi8(__m128i __a, __m128i __b) return (__m128i)((__v16qs)__a > (__v16qs)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cmpgt_epi16(__m128i __a, __m128i __b) { return (__m128i)((__v8hi)__a > (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cmpgt_epi32(__m128i __a, __m128i __b) { return (__m128i)((__v4si)__a > (__v4si)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cmplt_epi8(__m128i __a, __m128i __b) { return _mm_cmpgt_epi8(__b, __a); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cmplt_epi16(__m128i __a, __m128i __b) { return _mm_cmpgt_epi16(__b, __a); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cmplt_epi32(__m128i __a, __m128i __b) { return _mm_cmpgt_epi32(__b, __a); } #ifdef __x86_64__ -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_cvtsi64_sd(__m128d __a, long long __b) { __a[0] = __b; return __a; } -static __inline__ long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ long long DEFAULT_FN_ATTRS _mm_cvtsd_si64(__m128d __a) { return __builtin_ia32_cvtsd2si64(__a); } -static __inline__ long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ long long DEFAULT_FN_ATTRS _mm_cvttsd_si64(__m128d __a) { return __a[0]; } #endif -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvtepi32_ps(__m128i __a) { return __builtin_ia32_cvtdq2ps((__v4si)__a); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtps_epi32(__m128 __a) { return (__m128i)__builtin_ia32_cvtps2dq(__a); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvttps_epi32(__m128 __a) { return (__m128i)__builtin_ia32_cvttps2dq(__a); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtsi32_si128(int __a) { return (__m128i)(__v4si){ __a, 0, 0, 0 }; } #ifdef __x86_64__ -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtsi64_si128(long long __a) { return (__m128i){ __a, 0 }; } #endif -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_cvtsi128_si32(__m128i __a) { __v4si __b = (__v4si)__a; @@ -1085,20 +1084,20 @@ _mm_cvtsi128_si32(__m128i __a) } #ifdef __x86_64__ -static __inline__ long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ long long DEFAULT_FN_ATTRS _mm_cvtsi128_si64(__m128i __a) { return __a[0]; } #endif -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_load_si128(__m128i const *__p) { return *__p; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_loadu_si128(__m128i const *__p) { struct __loadu_si128 { @@ -1107,7 +1106,7 @@ _mm_loadu_si128(__m128i const *__p) return ((struct __loadu_si128*)__p)->__v; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_loadl_epi64(__m128i const *__p) { struct __mm_loadl_epi64_struct { @@ -1116,115 +1115,115 @@ _mm_loadl_epi64(__m128i const *__p) return (__m128i) { ((struct __mm_loadl_epi64_struct*)__p)->__u, 0}; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_set_epi64x(long long q1, long long q0) { return (__m128i){ q0, q1 }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_set_epi64(__m64 q1, __m64 q0) { return (__m128i){ (long long)q0, (long long)q1 }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_set_epi32(int i3, int i2, int i1, int i0) { return (__m128i)(__v4si){ i0, i1, i2, i3}; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_set_epi16(short w7, short w6, short w5, short w4, short w3, short w2, short w1, short w0) { return (__m128i)(__v8hi){ w0, w1, w2, w3, w4, w5, w6, w7 }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_set_epi8(char b15, char b14, char b13, char b12, char b11, char b10, char b9, char b8, char b7, char b6, char b5, char b4, char b3, char b2, char b1, char b0) { return (__m128i)(__v16qi){ b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15 }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_set1_epi64x(long long __q) { return (__m128i){ __q, __q }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_set1_epi64(__m64 __q) { return (__m128i){ (long long)__q, (long long)__q }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_set1_epi32(int __i) { return (__m128i)(__v4si){ __i, __i, __i, __i }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_set1_epi16(short __w) { return (__m128i)(__v8hi){ __w, __w, __w, __w, __w, __w, __w, __w }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_set1_epi8(char __b) { return (__m128i)(__v16qi){ __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_setr_epi64(__m64 q0, __m64 q1) { return (__m128i){ (long long)q0, (long long)q1 }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_setr_epi32(int i0, int i1, int i2, int i3) { return (__m128i)(__v4si){ i0, i1, i2, i3}; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_setr_epi16(short w0, short w1, short w2, short w3, short w4, short w5, short w6, short w7) { return (__m128i)(__v8hi){ w0, w1, w2, w3, w4, w5, w6, w7 }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_setr_epi8(char b0, char b1, char b2, char b3, char b4, char b5, char b6, char b7, char b8, char b9, char b10, char b11, char b12, char b13, char b14, char b15) { return (__m128i)(__v16qi){ b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15 }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_setzero_si128(void) { return (__m128i){ 0LL, 0LL }; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_store_si128(__m128i *__p, __m128i __b) { *__p = __b; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_storeu_si128(__m128i *__p, __m128i __b) { __builtin_ia32_storedqu((char *)__p, (__v16qi)__b); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_maskmoveu_si128(__m128i __d, __m128i __n, char *__p) { __builtin_ia32_maskmovdqu((__v16qi)__d, (__v16qi)__n, __p); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_storel_epi64(__m128i *__p, __m128i __a) { struct __mm_storel_epi64_struct { @@ -1233,76 +1232,76 @@ _mm_storel_epi64(__m128i *__p, __m128i __a) ((struct __mm_storel_epi64_struct*)__p)->__u = __a[0]; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_stream_pd(double *__p, __m128d __a) { __builtin_ia32_movntpd(__p, __a); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_stream_si128(__m128i *__p, __m128i __a) { __builtin_ia32_movntdq(__p, __a); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_stream_si32(int *__p, int __a) { __builtin_ia32_movnti(__p, __a); } #ifdef __x86_64__ -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_stream_si64(long long *__p, long long __a) { __builtin_ia32_movnti64(__p, __a); } #endif -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_clflush(void const *__p) { __builtin_ia32_clflush(__p); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_lfence(void) { __builtin_ia32_lfence(); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_mfence(void) { __builtin_ia32_mfence(); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_packs_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_packsswb128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_packs_epi32(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_packssdw128((__v4si)__a, (__v4si)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_packus_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_packuswb128((__v8hi)__a, (__v8hi)__b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_extract_epi16(__m128i __a, int __imm) { __v8hi __b = (__v8hi)__a; return (unsigned short)__b[__imm & 7]; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_insert_epi16(__m128i __a, int __b, int __imm) { __v8hi __c = (__v8hi)__a; @@ -1310,7 +1309,7 @@ _mm_insert_epi16(__m128i __a, int __b, int __imm) return (__m128i)__c; } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_movemask_epi8(__m128i __a) { return __builtin_ia32_pmovmskb128((__v16qi)__a); @@ -1338,85 +1337,85 @@ _mm_movemask_epi8(__m128i __a) 4 + (((imm) & 0x30) >> 4), \ 4 + (((imm) & 0xc0) >> 6)); }) -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_unpackhi_epi8(__m128i __a, __m128i __b) { return (__m128i)__builtin_shufflevector((__v16qi)__a, (__v16qi)__b, 8, 16+8, 9, 16+9, 10, 16+10, 11, 16+11, 12, 16+12, 13, 16+13, 14, 16+14, 15, 16+15); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_unpackhi_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_shufflevector((__v8hi)__a, (__v8hi)__b, 4, 8+4, 5, 8+5, 6, 8+6, 7, 8+7); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_unpackhi_epi32(__m128i __a, __m128i __b) { return (__m128i)__builtin_shufflevector((__v4si)__a, (__v4si)__b, 2, 4+2, 3, 4+3); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_unpackhi_epi64(__m128i __a, __m128i __b) { return (__m128i)__builtin_shufflevector(__a, __b, 1, 2+1); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_unpacklo_epi8(__m128i __a, __m128i __b) { return (__m128i)__builtin_shufflevector((__v16qi)__a, (__v16qi)__b, 0, 16+0, 1, 16+1, 2, 16+2, 3, 16+3, 4, 16+4, 5, 16+5, 6, 16+6, 7, 16+7); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_unpacklo_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_shufflevector((__v8hi)__a, (__v8hi)__b, 0, 8+0, 1, 8+1, 2, 8+2, 3, 8+3); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_unpacklo_epi32(__m128i __a, __m128i __b) { return (__m128i)__builtin_shufflevector((__v4si)__a, (__v4si)__b, 0, 4+0, 1, 4+1); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_unpacklo_epi64(__m128i __a, __m128i __b) { return (__m128i)__builtin_shufflevector(__a, __b, 0, 2+0); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_movepi64_pi64(__m128i __a) { return (__m64)__a[0]; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_movpi64_epi64(__m64 __a) { return (__m128i){ (long long)__a, 0 }; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_move_epi64(__m128i __a) { return __builtin_shufflevector(__a, (__m128i){ 0 }, 0, 2); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_unpackhi_pd(__m128d __a, __m128d __b) { return __builtin_shufflevector(__a, __b, 1, 2+1); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_unpacklo_pd(__m128d __a, __m128d __b) { return __builtin_shufflevector(__a, __b, 0, 2+0); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_movemask_pd(__m128d __a) { return __builtin_ia32_movmskpd(__a); @@ -1426,50 +1425,50 @@ _mm_movemask_pd(__m128d __a) __builtin_shufflevector((__m128d)(a), (__m128d)(b), \ (i) & 1, (((i) & 2) >> 1) + 2); }) -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_castpd_ps(__m128d __a) { return (__m128)__a; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_castpd_si128(__m128d __a) { return (__m128i)__a; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_castps_pd(__m128 __a) { return (__m128d)__a; } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_castps_si128(__m128 __a) { return (__m128i)__a; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_castsi128_ps(__m128i __a) { return (__m128)__a; } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_castsi128_pd(__m128i __a) { return (__m128d)__a; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_pause(void) { __asm__ volatile ("pause"); } -#define _MM_SHUFFLE2(x, y) (((x) << 1) | (y)) +#undef DEFAULT_FN_ATTRS -#endif /* __SSE2__ */ +#define _MM_SHUFFLE2(x, y) (((x) << 1) | (y)) #endif /* __EMMINTRIN_H */ diff --git a/lib/Headers/f16cintrin.h b/lib/Headers/f16cintrin.h index f3614c0e3912..c56960cf7b08 100644 --- a/lib/Headers/f16cintrin.h +++ b/lib/Headers/f16cintrin.h @@ -25,16 +25,15 @@ #error "Never use <f16cintrin.h> directly; include <x86intrin.h> instead." #endif -#ifndef __F16C__ -# error "F16C instruction is not enabled" -#endif /* __F16C__ */ - #ifndef __F16CINTRIN_H #define __F16CINTRIN_H typedef float __v8sf __attribute__ ((__vector_size__ (32))); typedef float __m256 __attribute__ ((__vector_size__ (32))); +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("f16c"))) + #define _mm_cvtps_ph(a, imm) __extension__ ({ \ __m128 __a = (a); \ (__m128i)__builtin_ia32_vcvtps2ph((__v4sf)__a, (imm)); }) @@ -43,16 +42,18 @@ typedef float __m256 __attribute__ ((__vector_size__ (32))); __m256 __a = (a); \ (__m128i)__builtin_ia32_vcvtps2ph256((__v8sf)__a, (imm)); }) -static __inline __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline __m128 DEFAULT_FN_ATTRS _mm_cvtph_ps(__m128i __a) { return (__m128)__builtin_ia32_vcvtph2ps((__v8hi)__a); } -static __inline __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline __m256 DEFAULT_FN_ATTRS _mm256_cvtph_ps(__m128i __a) { return (__m256)__builtin_ia32_vcvtph2ps256((__v8hi)__a); } +#undef DEFAULT_FN_ATTRS + #endif /* __F16CINTRIN_H */ diff --git a/lib/Headers/fma4intrin.h b/lib/Headers/fma4intrin.h index c30920df8b03..5268805605cc 100644 --- a/lib/Headers/fma4intrin.h +++ b/lib/Headers/fma4intrin.h @@ -28,204 +28,203 @@ #ifndef __FMA4INTRIN_H #define __FMA4INTRIN_H -#ifndef __FMA4__ -# error "FMA4 instruction set is not enabled" -#else - #include <pmmintrin.h> -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("fma4"))) + +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_macc_ps(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfmaddps(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_macc_pd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfmaddpd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_macc_ss(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfmaddss(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_macc_sd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfmaddsd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_msub_ps(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfmsubps(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_msub_pd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfmsubpd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_msub_ss(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfmsubss(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_msub_sd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfmsubsd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_nmacc_ps(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfnmaddps(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_nmacc_pd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfnmaddpd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_nmacc_ss(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfnmaddss(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_nmacc_sd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfnmaddsd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_nmsub_ps(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfnmsubps(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_nmsub_pd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfnmsubpd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_nmsub_ss(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfnmsubss(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_nmsub_sd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfnmsubsd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_maddsub_ps(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfmaddsubps(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_maddsub_pd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfmaddsubpd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_msubadd_ps(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfmsubaddps(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_msubadd_pd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfmsubaddpd(__A, __B, __C); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_macc_ps(__m256 __A, __m256 __B, __m256 __C) { return (__m256)__builtin_ia32_vfmaddps256(__A, __B, __C); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_macc_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfmaddpd256(__A, __B, __C); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_msub_ps(__m256 __A, __m256 __B, __m256 __C) { return (__m256)__builtin_ia32_vfmsubps256(__A, __B, __C); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_msub_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfmsubpd256(__A, __B, __C); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_nmacc_ps(__m256 __A, __m256 __B, __m256 __C) { return (__m256)__builtin_ia32_vfnmaddps256(__A, __B, __C); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_nmacc_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfnmaddpd256(__A, __B, __C); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_nmsub_ps(__m256 __A, __m256 __B, __m256 __C) { return (__m256)__builtin_ia32_vfnmsubps256(__A, __B, __C); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_nmsub_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfnmsubpd256(__A, __B, __C); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_maddsub_ps(__m256 __A, __m256 __B, __m256 __C) { return (__m256)__builtin_ia32_vfmaddsubps256(__A, __B, __C); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_maddsub_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfmaddsubpd256(__A, __B, __C); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_msubadd_ps(__m256 __A, __m256 __B, __m256 __C) { return (__m256)__builtin_ia32_vfmsubaddps256(__A, __B, __C); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_msubadd_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfmsubaddpd256(__A, __B, __C); } -#endif /* __FMA4__ */ +#undef DEFAULT_FN_ATTRS #endif /* __FMA4INTRIN_H */ diff --git a/lib/Headers/fmaintrin.h b/lib/Headers/fmaintrin.h index 6bfd5a88b3ce..6f5d1b907a38 100644 --- a/lib/Headers/fmaintrin.h +++ b/lib/Headers/fmaintrin.h @@ -28,202 +28,201 @@ #ifndef __FMAINTRIN_H #define __FMAINTRIN_H -#ifndef __FMA__ -# error "FMA instruction set is not enabled" -#else +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("fma"))) -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_fmadd_ps(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfmaddps(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_fmadd_pd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfmaddpd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_fmadd_ss(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfmaddss(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_fmadd_sd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfmaddsd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_fmsub_ps(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfmsubps(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_fmsub_pd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfmsubpd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_fmsub_ss(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfmsubss(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_fmsub_sd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfmsubsd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_fnmadd_ps(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfnmaddps(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_fnmadd_pd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfnmaddpd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_fnmadd_ss(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfnmaddss(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_fnmadd_sd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfnmaddsd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_fnmsub_ps(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfnmsubps(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_fnmsub_pd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfnmsubpd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_fnmsub_ss(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfnmsubss(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_fnmsub_sd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfnmsubsd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_fmaddsub_ps(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfmaddsubps(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_fmaddsub_pd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfmaddsubpd(__A, __B, __C); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_fmsubadd_ps(__m128 __A, __m128 __B, __m128 __C) { return (__m128)__builtin_ia32_vfmsubaddps(__A, __B, __C); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_fmsubadd_pd(__m128d __A, __m128d __B, __m128d __C) { return (__m128d)__builtin_ia32_vfmsubaddpd(__A, __B, __C); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_fmadd_ps(__m256 __A, __m256 __B, __m256 __C) { return (__m256)__builtin_ia32_vfmaddps256(__A, __B, __C); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_fmadd_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfmaddpd256(__A, __B, __C); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_fmsub_ps(__m256 __A, __m256 __B, __m256 __C) { return (__m256)__builtin_ia32_vfmsubps256(__A, __B, __C); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_fmsub_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfmsubpd256(__A, __B, __C); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_fnmadd_ps(__m256 __A, __m256 __B, __m256 __C) { return (__m256)__builtin_ia32_vfnmaddps256(__A, __B, __C); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_fnmadd_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfnmaddpd256(__A, __B, __C); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_fnmsub_ps(__m256 __A, __m256 __B, __m256 __C) { return (__m256)__builtin_ia32_vfnmsubps256(__A, __B, __C); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_fnmsub_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfnmsubpd256(__A, __B, __C); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_fmaddsub_ps(__m256 __A, __m256 __B, __m256 __C) { return (__m256)__builtin_ia32_vfmaddsubps256(__A, __B, __C); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_fmaddsub_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfmaddsubpd256(__A, __B, __C); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_fmsubadd_ps(__m256 __A, __m256 __B, __m256 __C) { return (__m256)__builtin_ia32_vfmsubaddps256(__A, __B, __C); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_fmsubadd_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfmsubaddpd256(__A, __B, __C); } -#endif /* __FMA__ */ +#undef DEFAULT_FN_ATTRS #endif /* __FMAINTRIN_H */ diff --git a/lib/Headers/immintrin.h b/lib/Headers/immintrin.h index ac7d54a41db8..4af407dfc7e8 100644 --- a/lib/Headers/immintrin.h +++ b/lib/Headers/immintrin.h @@ -24,179 +24,124 @@ #ifndef __IMMINTRIN_H #define __IMMINTRIN_H -#ifdef __MMX__ #include <mmintrin.h> -#endif -#ifdef __SSE__ #include <xmmintrin.h> -#endif -#ifdef __SSE2__ #include <emmintrin.h> -#endif -#ifdef __SSE3__ #include <pmmintrin.h> -#endif -#ifdef __SSSE3__ #include <tmmintrin.h> -#endif -#if defined (__SSE4_2__) || defined (__SSE4_1__) #include <smmintrin.h> -#endif -#if defined (__AES__) || defined (__PCLMUL__) #include <wmmintrin.h> -#endif -#ifdef __AVX__ #include <avxintrin.h> -#endif -#ifdef __AVX2__ #include <avx2intrin.h> -#endif -#ifdef __BMI__ #include <bmiintrin.h> -#endif -#ifdef __BMI2__ #include <bmi2intrin.h> -#endif -#ifdef __LZCNT__ #include <lzcntintrin.h> -#endif -#ifdef __FMA__ #include <fmaintrin.h> -#endif -#ifdef __AVX512F__ #include <avx512fintrin.h> -#endif -#ifdef __AVX512VL__ #include <avx512vlintrin.h> -#endif -#ifdef __AVX512BW__ #include <avx512bwintrin.h> -#endif -#ifdef __AVX512DQ__ #include <avx512dqintrin.h> -#endif -#if defined (__AVX512VL__) && defined (__AVX512BW__) #include <avx512vlbwintrin.h> -#endif -#if defined (__AVX512VL__) && defined (__AVX512DQ__) #include <avx512vldqintrin.h> -#endif -#ifdef __AVX512ER__ #include <avx512erintrin.h> -#endif -#ifdef __RDRND__ -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("rdrnd"))) _rdrand16_step(unsigned short *__p) { return __builtin_ia32_rdrand16_step(__p); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("rdrnd"))) _rdrand32_step(unsigned int *__p) { return __builtin_ia32_rdrand32_step(__p); } #ifdef __x86_64__ -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("rdrnd"))) _rdrand64_step(unsigned long long *__p) { return __builtin_ia32_rdrand64_step(__p); } #endif -#endif /* __RDRND__ */ -#ifdef __FSGSBASE__ #ifdef __x86_64__ -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase"))) _readfsbase_u32(void) { return __builtin_ia32_rdfsbase32(); } -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase"))) _readfsbase_u64(void) { return __builtin_ia32_rdfsbase64(); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase"))) _readgsbase_u32(void) { return __builtin_ia32_rdgsbase32(); } -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase"))) _readgsbase_u64(void) { return __builtin_ia32_rdgsbase64(); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase"))) _writefsbase_u32(unsigned int __V) { return __builtin_ia32_wrfsbase32(__V); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase"))) _writefsbase_u64(unsigned long long __V) { return __builtin_ia32_wrfsbase64(__V); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase"))) _writegsbase_u32(unsigned int __V) { return __builtin_ia32_wrgsbase32(__V); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase"))) _writegsbase_u64(unsigned long long __V) { return __builtin_ia32_wrgsbase64(__V); } #endif -#endif /* __FSGSBASE__ */ -#ifdef __RTM__ #include <rtmintrin.h> -#endif -/* FIXME: check __HLE__ as well when HLE is supported. */ -#if defined (__RTM__) -static __inline__ int __attribute__((__always_inline__, __nodebug__)) -_xtest(void) -{ - return __builtin_ia32_xtest(); -} -#endif +#include <xtestintrin.h> -#ifdef __SHA__ #include <shaintrin.h> -#endif -/* Some intrinsics inside adxintrin.h are available only if __ADX__ defined, - * whereas others are also available if __ADX__ undefined */ +/* Some intrinsics inside adxintrin.h are available only on processors with ADX, + * whereas others are also available at all times. */ #include <adxintrin.h> #endif /* __IMMINTRIN_H */ diff --git a/lib/Headers/lzcntintrin.h b/lib/Headers/lzcntintrin.h index 35d6659d245b..41e61e9fdefa 100644 --- a/lib/Headers/lzcntintrin.h +++ b/lib/Headers/lzcntintrin.h @@ -25,43 +25,44 @@ #error "Never use <lzcntintrin.h> directly; include <x86intrin.h> instead." #endif -#ifndef __LZCNT__ -# error "LZCNT instruction is not enabled" -#endif /* __LZCNT__ */ - #ifndef __LZCNTINTRIN_H #define __LZCNTINTRIN_H -static __inline__ unsigned short __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("lzcnt"))) + +static __inline__ unsigned short DEFAULT_FN_ATTRS __lzcnt16(unsigned short __X) { return __X ? __builtin_clzs(__X) : 16; } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __lzcnt32(unsigned int __X) { return __X ? __builtin_clz(__X) : 32; } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS _lzcnt_u32(unsigned int __X) { return __X ? __builtin_clz(__X) : 32; } #ifdef __x86_64__ -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __lzcnt64(unsigned long long __X) { return __X ? __builtin_clzll(__X) : 64; } -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS _lzcnt_u64(unsigned long long __X) { return __X ? __builtin_clzll(__X) : 64; } #endif +#undef DEFAULT_FN_ATTRS + #endif /* __LZCNTINTRIN_H */ diff --git a/lib/Headers/mm3dnow.h b/lib/Headers/mm3dnow.h index 5242d99cbd75..70734e49682e 100644 --- a/lib/Headers/mm3dnow.h +++ b/lib/Headers/mm3dnow.h @@ -29,134 +29,139 @@ typedef float __v2sf __attribute__((__vector_size__(8))); -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("3dnow"))) + +static __inline__ void DEFAULT_FN_ATTRS _m_femms() { __builtin_ia32_femms(); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pavgusb(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pavgusb((__v8qi)__m1, (__v8qi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pf2id(__m64 __m) { return (__m64)__builtin_ia32_pf2id((__v2sf)__m); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfacc(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfacc((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfadd(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfadd((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfcmpeq(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfcmpeq((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfcmpge(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfcmpge((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfcmpgt(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfcmpgt((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfmax(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfmax((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfmin(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfmin((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfmul(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfmul((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfrcp(__m64 __m) { return (__m64)__builtin_ia32_pfrcp((__v2sf)__m); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfrcpit1(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfrcpit1((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfrcpit2(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfrcpit2((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfrsqrt(__m64 __m) { return (__m64)__builtin_ia32_pfrsqrt((__v2sf)__m); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfrsqrtit1(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfrsqit1((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfsub(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfsub((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfsubr(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfsubr((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pi2fd(__m64 __m) { return (__m64)__builtin_ia32_pi2fd((__v2si)__m); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pmulhrw(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pmulhrw((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pf2iw(__m64 __m) { return (__m64)__builtin_ia32_pf2iw((__v2sf)__m); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfnacc(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfnacc((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pfpnacc(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfpnacc((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pi2fw(__m64 __m) { return (__m64)__builtin_ia32_pi2fw((__v2si)__m); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pswapdsf(__m64 __m) { return (__m64)__builtin_ia32_pswapdsf((__v2sf)__m); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _m_pswapdsi(__m64 __m) { return (__m64)__builtin_ia32_pswapdsi((__v2si)__m); } +#undef DEFAULT_FN_ATTRS + #endif diff --git a/lib/Headers/mmintrin.h b/lib/Headers/mmintrin.h index 986870a96883..d1d729f26a38 100644 --- a/lib/Headers/mmintrin.h +++ b/lib/Headers/mmintrin.h @@ -24,377 +24,376 @@ #ifndef __MMINTRIN_H #define __MMINTRIN_H -#ifndef __MMX__ -#error "MMX instruction set not enabled" -#else - typedef long long __m64 __attribute__((__vector_size__(8))); typedef int __v2si __attribute__((__vector_size__(8))); typedef short __v4hi __attribute__((__vector_size__(8))); typedef char __v8qi __attribute__((__vector_size__(8))); -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("mmx"))) + +static __inline__ void DEFAULT_FN_ATTRS _mm_empty(void) { __builtin_ia32_emms(); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cvtsi32_si64(int __i) { return (__m64)__builtin_ia32_vec_init_v2si(__i, 0); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_cvtsi64_si32(__m64 __m) { return __builtin_ia32_vec_ext_v2si((__v2si)__m, 0); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cvtsi64_m64(long long __i) { return (__m64)__i; } -static __inline__ long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ long long DEFAULT_FN_ATTRS _mm_cvtm64_si64(__m64 __m) { return (long long)__m; } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_packs_pi16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_packsswb((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_packs_pi32(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_packssdw((__v2si)__m1, (__v2si)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_packs_pu16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_packuswb((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_unpackhi_pi8(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_punpckhbw((__v8qi)__m1, (__v8qi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_unpackhi_pi16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_punpckhwd((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_unpackhi_pi32(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_punpckhdq((__v2si)__m1, (__v2si)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_unpacklo_pi8(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_punpcklbw((__v8qi)__m1, (__v8qi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_unpacklo_pi16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_punpcklwd((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_unpacklo_pi32(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_punpckldq((__v2si)__m1, (__v2si)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_add_pi8(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_paddb((__v8qi)__m1, (__v8qi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_add_pi16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_paddw((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_add_pi32(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_paddd((__v2si)__m1, (__v2si)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_adds_pi8(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_paddsb((__v8qi)__m1, (__v8qi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_adds_pi16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_paddsw((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_adds_pu8(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_paddusb((__v8qi)__m1, (__v8qi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_adds_pu16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_paddusw((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sub_pi8(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_psubb((__v8qi)__m1, (__v8qi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sub_pi16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_psubw((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sub_pi32(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_psubd((__v2si)__m1, (__v2si)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_subs_pi8(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_psubsb((__v8qi)__m1, (__v8qi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_subs_pi16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_psubsw((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_subs_pu8(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_psubusb((__v8qi)__m1, (__v8qi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_subs_pu16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_psubusw((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_madd_pi16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pmaddwd((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_mulhi_pi16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pmulhw((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_mullo_pi16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pmullw((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sll_pi16(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psllw((__v4hi)__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_slli_pi16(__m64 __m, int __count) { return (__m64)__builtin_ia32_psllwi((__v4hi)__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sll_pi32(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_pslld((__v2si)__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_slli_pi32(__m64 __m, int __count) { return (__m64)__builtin_ia32_pslldi((__v2si)__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sll_si64(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psllq(__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_slli_si64(__m64 __m, int __count) { return (__m64)__builtin_ia32_psllqi(__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sra_pi16(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psraw((__v4hi)__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_srai_pi16(__m64 __m, int __count) { return (__m64)__builtin_ia32_psrawi((__v4hi)__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sra_pi32(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psrad((__v2si)__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_srai_pi32(__m64 __m, int __count) { return (__m64)__builtin_ia32_psradi((__v2si)__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_srl_pi16(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psrlw((__v4hi)__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_srli_pi16(__m64 __m, int __count) { return (__m64)__builtin_ia32_psrlwi((__v4hi)__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_srl_pi32(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psrld((__v2si)__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_srli_pi32(__m64 __m, int __count) { return (__m64)__builtin_ia32_psrldi((__v2si)__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_srl_si64(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psrlq(__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_srli_si64(__m64 __m, int __count) { return (__m64)__builtin_ia32_psrlqi(__m, __count); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_and_si64(__m64 __m1, __m64 __m2) { return __builtin_ia32_pand(__m1, __m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_andnot_si64(__m64 __m1, __m64 __m2) { return __builtin_ia32_pandn(__m1, __m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_or_si64(__m64 __m1, __m64 __m2) { return __builtin_ia32_por(__m1, __m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_xor_si64(__m64 __m1, __m64 __m2) { return __builtin_ia32_pxor(__m1, __m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cmpeq_pi8(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pcmpeqb((__v8qi)__m1, (__v8qi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cmpeq_pi16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pcmpeqw((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cmpeq_pi32(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pcmpeqd((__v2si)__m1, (__v2si)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cmpgt_pi8(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pcmpgtb((__v8qi)__m1, (__v8qi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cmpgt_pi16(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pcmpgtw((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cmpgt_pi32(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pcmpgtd((__v2si)__m1, (__v2si)__m2); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_setzero_si64(void) { return (__m64){ 0LL }; } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_set_pi32(int __i1, int __i0) { return (__m64)__builtin_ia32_vec_init_v2si(__i0, __i1); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_set_pi16(short __s3, short __s2, short __s1, short __s0) { return (__m64)__builtin_ia32_vec_init_v4hi(__s0, __s1, __s2, __s3); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_set_pi8(char __b7, char __b6, char __b5, char __b4, char __b3, char __b2, char __b1, char __b0) { @@ -402,43 +401,44 @@ _mm_set_pi8(char __b7, char __b6, char __b5, char __b4, char __b3, char __b2, __b4, __b5, __b6, __b7); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_set1_pi32(int __i) { return _mm_set_pi32(__i, __i); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_set1_pi16(short __w) { return _mm_set_pi16(__w, __w, __w, __w); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_set1_pi8(char __b) { return _mm_set_pi8(__b, __b, __b, __b, __b, __b, __b, __b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_setr_pi32(int __i0, int __i1) { return _mm_set_pi32(__i1, __i0); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_setr_pi16(short __w0, short __w1, short __w2, short __w3) { return _mm_set_pi16(__w3, __w2, __w1, __w0); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_setr_pi8(char __b0, char __b1, char __b2, char __b3, char __b4, char __b5, char __b6, char __b7) { return _mm_set_pi8(__b7, __b6, __b5, __b4, __b3, __b2, __b1, __b0); } +#undef DEFAULT_FN_ATTRS /* Aliases for compatibility. */ #define _m_empty _mm_empty @@ -497,7 +497,5 @@ _mm_setr_pi8(char __b0, char __b1, char __b2, char __b3, char __b4, char __b5, #define _m_pcmpgtw _mm_cmpgt_pi16 #define _m_pcmpgtd _mm_cmpgt_pi32 -#endif /* __MMX__ */ - #endif /* __MMINTRIN_H */ diff --git a/lib/Headers/nmmintrin.h b/lib/Headers/nmmintrin.h index f12622d7be68..57fec15963d1 100644 --- a/lib/Headers/nmmintrin.h +++ b/lib/Headers/nmmintrin.h @@ -24,12 +24,7 @@ #ifndef _NMMINTRIN_H #define _NMMINTRIN_H -#ifndef __SSE4_2__ -#error "SSE4.2 instruction set not enabled" -#else - /* To match expectations of gcc we put the sse4.2 definitions into smmintrin.h, just include it now then. */ #include <smmintrin.h> -#endif /* __SSE4_2__ */ #endif /* _NMMINTRIN_H */ diff --git a/lib/Headers/pmmintrin.h b/lib/Headers/pmmintrin.h index 6f1fc3294644..6e61539fb2ca 100644 --- a/lib/Headers/pmmintrin.h +++ b/lib/Headers/pmmintrin.h @@ -24,61 +24,60 @@ #ifndef __PMMINTRIN_H #define __PMMINTRIN_H -#ifndef __SSE3__ -#error "SSE3 instruction set not enabled" -#else - #include <emmintrin.h> -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse3"))) + +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_lddqu_si128(__m128i const *__p) { return (__m128i)__builtin_ia32_lddqu((char const *)__p); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_addsub_ps(__m128 __a, __m128 __b) { return __builtin_ia32_addsubps(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_hadd_ps(__m128 __a, __m128 __b) { return __builtin_ia32_haddps(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_hsub_ps(__m128 __a, __m128 __b) { return __builtin_ia32_hsubps(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_movehdup_ps(__m128 __a) { return __builtin_shufflevector(__a, __a, 1, 1, 3, 3); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_moveldup_ps(__m128 __a) { return __builtin_shufflevector(__a, __a, 0, 0, 2, 2); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_addsub_pd(__m128d __a, __m128d __b) { return __builtin_ia32_addsubpd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_hadd_pd(__m128d __a, __m128d __b) { return __builtin_ia32_haddpd(__a, __b); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_hsub_pd(__m128d __a, __m128d __b) { return __builtin_ia32_hsubpd(__a, __b); @@ -86,7 +85,7 @@ _mm_hsub_pd(__m128d __a, __m128d __b) #define _mm_loaddup_pd(dp) _mm_load1_pd(dp) -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_movedup_pd(__m128d __a) { return __builtin_shufflevector(__a, __a, 0, 0); @@ -100,18 +99,18 @@ _mm_movedup_pd(__m128d __a) #define _MM_GET_DENORMALS_ZERO_MODE() (_mm_getcsr() & _MM_DENORMALS_ZERO_MASK) #define _MM_SET_DENORMALS_ZERO_MODE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_DENORMALS_ZERO_MASK) | (x))) -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_monitor(void const *__p, unsigned __extensions, unsigned __hints) { __builtin_ia32_monitor((void *)__p, __extensions, __hints); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_mwait(unsigned __extensions, unsigned __hints) { __builtin_ia32_mwait(__extensions, __hints); } -#endif /* __SSE3__ */ +#undef DEFAULT_FN_ATTRS #endif /* __PMMINTRIN_H */ diff --git a/lib/Headers/popcntintrin.h b/lib/Headers/popcntintrin.h index d439daa8d6a7..fede8da2bdf5 100644 --- a/lib/Headers/popcntintrin.h +++ b/lib/Headers/popcntintrin.h @@ -21,25 +21,26 @@ *===-----------------------------------------------------------------------=== */ -#ifndef __POPCNT__ -#error "POPCNT instruction set not enabled" -#endif - #ifndef _POPCNTINTRIN_H #define _POPCNTINTRIN_H -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("popcnt"))) + +static __inline__ int DEFAULT_FN_ATTRS _mm_popcnt_u32(unsigned int __A) { return __builtin_popcount(__A); } #ifdef __x86_64__ -static __inline__ long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ long long DEFAULT_FN_ATTRS _mm_popcnt_u64(unsigned long long __A) { return __builtin_popcountll(__A); } #endif /* __x86_64__ */ +#undef DEFAULT_FN_ATTRS + #endif /* _POPCNTINTRIN_H */ diff --git a/lib/Headers/rdseedintrin.h b/lib/Headers/rdseedintrin.h index 0fef1fa49680..ac9ec4f9ba92 100644 --- a/lib/Headers/rdseedintrin.h +++ b/lib/Headers/rdseedintrin.h @@ -28,25 +28,29 @@ #ifndef __RDSEEDINTRIN_H #define __RDSEEDINTRIN_H -#ifdef __RDSEED__ -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("rdseed"))) + +static __inline__ int DEFAULT_FN_ATTRS _rdseed16_step(unsigned short *__p) { return __builtin_ia32_rdseed16_step(__p); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _rdseed32_step(unsigned int *__p) { return __builtin_ia32_rdseed32_step(__p); } #ifdef __x86_64__ -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _rdseed64_step(unsigned long long *__p) { return __builtin_ia32_rdseed64_step(__p); } #endif -#endif /* __RDSEED__ */ + +#undef DEFAULT_FN_ATTRS + #endif /* __RDSEEDINTRIN_H */ diff --git a/lib/Headers/rtmintrin.h b/lib/Headers/rtmintrin.h index 26149ca8522d..8709a125a7be 100644 --- a/lib/Headers/rtmintrin.h +++ b/lib/Headers/rtmintrin.h @@ -37,13 +37,16 @@ #define _XABORT_NESTED (1 << 5) #define _XABORT_CODE(x) (((x) >> 24) & 0xFF) -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("rtm"))) + +static __inline__ unsigned int DEFAULT_FN_ATTRS _xbegin(void) { return __builtin_ia32_xbegin(); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _xend(void) { __builtin_ia32_xend(); @@ -51,4 +54,6 @@ _xend(void) #define _xabort(imm) __builtin_ia32_xabort((imm)) +#undef DEFAULT_FN_ATTRS + #endif /* __RTMINTRIN_H */ diff --git a/lib/Headers/shaintrin.h b/lib/Headers/shaintrin.h index 391a4bbc4f0e..4b7429162783 100644 --- a/lib/Headers/shaintrin.h +++ b/lib/Headers/shaintrin.h @@ -28,47 +28,48 @@ #ifndef __SHAINTRIN_H #define __SHAINTRIN_H -#if !defined (__SHA__) -# error "SHA instructions not enabled" -#endif +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sha"))) #define _mm_sha1rnds4_epu32(V1, V2, M) __extension__ ({ \ __builtin_ia32_sha1rnds4((V1), (V2), (M)); }) -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sha1nexte_epu32(__m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_sha1nexte((__v4si)__X, (__v4si)__Y); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sha1msg1_epu32(__m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_sha1msg1((__v4si)__X, (__v4si)__Y); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sha1msg2_epu32(__m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_sha1msg2((__v4si)__X, (__v4si)__Y); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sha256rnds2_epu32(__m128i __X, __m128i __Y, __m128i __Z) { return (__m128i)__builtin_ia32_sha256rnds2((__v4si)__X, (__v4si)__Y, (__v4si)__Z); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sha256msg1_epu32(__m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_sha256msg1((__v4si)__X, (__v4si)__Y); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sha256msg2_epu32(__m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_sha256msg2((__v4si)__X, (__v4si)__Y); } +#undef DEFAULT_FN_ATTRS + #endif /* __SHAINTRIN_H */ diff --git a/lib/Headers/smmintrin.h b/lib/Headers/smmintrin.h index 6e35734f6e0d..f2cc909fe773 100644 --- a/lib/Headers/smmintrin.h +++ b/lib/Headers/smmintrin.h @@ -24,12 +24,11 @@ #ifndef _SMMINTRIN_H #define _SMMINTRIN_H -#ifndef __SSE4_1__ -#error "SSE4.1 instruction set not enabled" -#else - #include <tmmintrin.h> +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse4.1"))) + /* SSE4 Rounding macros. */ #define _MM_FROUND_TO_NEAREST_INT 0x00 #define _MM_FROUND_TO_NEG_INF 0x01 @@ -92,21 +91,21 @@ (((M) & 0x04) ? 6 : 2), \ (((M) & 0x08) ? 7 : 3)); }) -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_blendv_pd (__m128d __V1, __m128d __V2, __m128d __M) { return (__m128d) __builtin_ia32_blendvpd ((__v2df)__V1, (__v2df)__V2, (__v2df)__M); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_blendv_ps (__m128 __V1, __m128 __V2, __m128 __M) { return (__m128) __builtin_ia32_blendvps ((__v4sf)__V1, (__v4sf)__V2, (__v4sf)__M); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_blendv_epi8 (__m128i __V1, __m128i __V2, __m128i __M) { return (__m128i) __builtin_ia32_pblendvb128 ((__v16qi)__V1, (__v16qi)__V2, @@ -127,13 +126,13 @@ _mm_blendv_epi8 (__m128i __V1, __m128i __V2, __m128i __M) (((M) & 0x80) ? 15 : 7)); }) /* SSE4 Dword Multiply Instructions. */ -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mullo_epi32 (__m128i __V1, __m128i __V2) { return (__m128i) ((__v4si)__V1 * (__v4si)__V2); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mul_epi32 (__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_pmuldq128 ((__v4si)__V1, (__v4si)__V2); @@ -151,56 +150,56 @@ _mm_mul_epi32 (__m128i __V1, __m128i __V2) (__m128d) __builtin_ia32_dppd((__v2df)__X, (__v2df)__Y, (M)); }) /* SSE4 Streaming Load Hint Instruction. */ -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_stream_load_si128 (__m128i *__V) { return (__m128i) __builtin_ia32_movntdqa ((__v2di *) __V); } /* SSE4 Packed Integer Min/Max Instructions. */ -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_min_epi8 (__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_pminsb128 ((__v16qi) __V1, (__v16qi) __V2); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_max_epi8 (__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_pmaxsb128 ((__v16qi) __V1, (__v16qi) __V2); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_min_epu16 (__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_pminuw128 ((__v8hi) __V1, (__v8hi) __V2); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_max_epu16 (__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_pmaxuw128 ((__v8hi) __V1, (__v8hi) __V2); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_min_epi32 (__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_pminsd128 ((__v4si) __V1, (__v4si) __V2); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_max_epi32 (__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_pmaxsd128 ((__v4si) __V1, (__v4si) __V2); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_min_epu32 (__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_pminud128((__v4si) __V1, (__v4si) __V2); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_max_epu32 (__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_pmaxud128((__v4si) __V1, (__v4si) __V2); @@ -254,19 +253,19 @@ _mm_max_epu32 (__m128i __V1, __m128i __V2) #endif /* __x86_64 */ /* SSE4 128-bit Packed Integer Comparisons. */ -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_testz_si128(__m128i __M, __m128i __V) { return __builtin_ia32_ptestz128((__v2di)__M, (__v2di)__V); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_testc_si128(__m128i __M, __m128i __V) { return __builtin_ia32_ptestc128((__v2di)__M, (__v2di)__V); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_testnzc_si128(__m128i __M, __m128i __V) { return __builtin_ia32_ptestnzc128((__v2di)__M, (__v2di)__V); @@ -277,88 +276,88 @@ _mm_testnzc_si128(__m128i __M, __m128i __V) #define _mm_test_all_zeros(M, V) _mm_testz_si128 ((M), (V)) /* SSE4 64-bit Packed Integer Comparisons. */ -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cmpeq_epi64(__m128i __V1, __m128i __V2) { return (__m128i)((__v2di)__V1 == (__v2di)__V2); } /* SSE4 Packed Integer Sign-Extension. */ -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtepi8_epi16(__m128i __V) { return (__m128i) __builtin_ia32_pmovsxbw128((__v16qi) __V); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtepi8_epi32(__m128i __V) { return (__m128i) __builtin_ia32_pmovsxbd128((__v16qi) __V); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtepi8_epi64(__m128i __V) { return (__m128i) __builtin_ia32_pmovsxbq128((__v16qi) __V); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtepi16_epi32(__m128i __V) { return (__m128i) __builtin_ia32_pmovsxwd128((__v8hi) __V); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtepi16_epi64(__m128i __V) { return (__m128i) __builtin_ia32_pmovsxwq128((__v8hi)__V); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtepi32_epi64(__m128i __V) { return (__m128i) __builtin_ia32_pmovsxdq128((__v4si)__V); } /* SSE4 Packed Integer Zero-Extension. */ -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtepu8_epi16(__m128i __V) { return (__m128i) __builtin_ia32_pmovzxbw128((__v16qi) __V); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtepu8_epi32(__m128i __V) { return (__m128i) __builtin_ia32_pmovzxbd128((__v16qi)__V); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtepu8_epi64(__m128i __V) { return (__m128i) __builtin_ia32_pmovzxbq128((__v16qi)__V); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtepu16_epi32(__m128i __V) { return (__m128i) __builtin_ia32_pmovzxwd128((__v8hi)__V); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtepu16_epi64(__m128i __V) { return (__m128i) __builtin_ia32_pmovzxwq128((__v8hi)__V); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cvtepu32_epi64(__m128i __V) { return (__m128i) __builtin_ia32_pmovzxdq128((__v4si)__V); } /* SSE4 Pack with Unsigned Saturation. */ -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_packus_epi32(__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_packusdw128((__v4si)__V1, (__v4si)__V2); @@ -370,15 +369,19 @@ _mm_packus_epi32(__m128i __V1, __m128i __V2) __m128i __Y = (Y); \ (__m128i) __builtin_ia32_mpsadbw128((__v16qi)__X, (__v16qi)__Y, (M)); }) -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_minpos_epu16(__m128i __V) { return (__m128i) __builtin_ia32_phminposuw128((__v8hi)__V); } +/* Handle the sse4.2 definitions here. */ + /* These definitions are normally in nmmintrin.h, but gcc puts them in here so we'll do the same. */ -#ifdef __SSE4_2__ + +#undef DEFAULT_FN_ATTRS +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse4.2"))) /* These specify the type of data that we're comparing. */ #define _SIDD_UBYTE_OPS 0x00 @@ -439,44 +442,43 @@ _mm_minpos_epu16(__m128i __V) __builtin_ia32_pcmpestriz128((A), (LA), (B), (LB), (M)) /* SSE4.2 Compare Packed Data -- Greater Than. */ -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cmpgt_epi64(__m128i __V1, __m128i __V2) { return (__m128i)((__v2di)__V1 > (__v2di)__V2); } /* SSE4.2 Accumulate CRC32. */ -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS _mm_crc32_u8(unsigned int __C, unsigned char __D) { return __builtin_ia32_crc32qi(__C, __D); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS _mm_crc32_u16(unsigned int __C, unsigned short __D) { return __builtin_ia32_crc32hi(__C, __D); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS _mm_crc32_u32(unsigned int __C, unsigned int __D) { return __builtin_ia32_crc32si(__C, __D); } #ifdef __x86_64__ -static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS _mm_crc32_u64(unsigned long long __C, unsigned long long __D) { return __builtin_ia32_crc32di(__C, __D); } #endif /* __x86_64__ */ +#undef DEFAULT_FN_ATTRS + #ifdef __POPCNT__ #include <popcntintrin.h> #endif -#endif /* __SSE4_2__ */ -#endif /* __SSE4_1__ */ - #endif /* _SMMINTRIN_H */ diff --git a/lib/Headers/tbmintrin.h b/lib/Headers/tbmintrin.h index f95e34fbc185..1926df9f033c 100644 --- a/lib/Headers/tbmintrin.h +++ b/lib/Headers/tbmintrin.h @@ -21,10 +21,6 @@ *===-----------------------------------------------------------------------=== */ -#ifndef __TBM__ -#error "TBM instruction set is not enabled" -#endif - #ifndef __X86INTRIN_H #error "Never use <tbmintrin.h> directly; include <x86intrin.h> instead." #endif @@ -32,57 +28,60 @@ #ifndef __TBMINTRIN_H #define __TBMINTRIN_H +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("tbm"))) + #define __bextri_u32(a, b) (__builtin_ia32_bextri_u32((a), (b))) -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __blcfill_u32(unsigned int a) { return a & (a + 1); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __blci_u32(unsigned int a) { return a | ~(a + 1); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __blcic_u32(unsigned int a) { return ~a & (a + 1); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __blcmsk_u32(unsigned int a) { return a ^ (a + 1); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __blcs_u32(unsigned int a) { return a | (a + 1); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __blsfill_u32(unsigned int a) { return a | (a - 1); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __blsic_u32(unsigned int a) { return ~a | (a - 1); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __t1mskc_u32(unsigned int a) { return ~a | (a + 1); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS __tzmsk_u32(unsigned int a) { return ~a & (a - 1); @@ -91,68 +90,61 @@ __tzmsk_u32(unsigned int a) #ifdef __x86_64__ #define __bextri_u64(a, b) (__builtin_ia32_bextri_u64((a), (int)(b))) -static __inline__ unsigned long long __attribute__((__always_inline__, - __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __blcfill_u64(unsigned long long a) { return a & (a + 1); } -static __inline__ unsigned long long __attribute__((__always_inline__, - __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __blci_u64(unsigned long long a) { return a | ~(a + 1); } -static __inline__ unsigned long long __attribute__((__always_inline__, - __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __blcic_u64(unsigned long long a) { return ~a & (a + 1); } -static __inline__ unsigned long long __attribute__((__always_inline__, - __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __blcmsk_u64(unsigned long long a) { return a ^ (a + 1); } -static __inline__ unsigned long long __attribute__((__always_inline__, - __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __blcs_u64(unsigned long long a) { return a | (a + 1); } -static __inline__ unsigned long long __attribute__((__always_inline__, - __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __blsfill_u64(unsigned long long a) { return a | (a - 1); } -static __inline__ unsigned long long __attribute__((__always_inline__, - __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __blsic_u64(unsigned long long a) { return ~a | (a - 1); } -static __inline__ unsigned long long __attribute__((__always_inline__, - __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __t1mskc_u64(unsigned long long a) { return ~a | (a + 1); } -static __inline__ unsigned long long __attribute__((__always_inline__, - __nodebug__)) +static __inline__ unsigned long long DEFAULT_FN_ATTRS __tzmsk_u64(unsigned long long a) { return ~a & (a - 1); } #endif +#undef DEFAULT_FN_ATTRS + #endif /* __TBMINTRIN_H */ diff --git a/lib/Headers/tmmintrin.h b/lib/Headers/tmmintrin.h index 4238f5b38934..2474c9414fd3 100644 --- a/lib/Headers/tmmintrin.h +++ b/lib/Headers/tmmintrin.h @@ -24,43 +24,42 @@ #ifndef __TMMINTRIN_H #define __TMMINTRIN_H -#ifndef __SSSE3__ -#error "SSSE3 instruction set not enabled" -#else - #include <pmmintrin.h> -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("ssse3"))) + +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_abs_pi8(__m64 __a) { return (__m64)__builtin_ia32_pabsb((__v8qi)__a); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_abs_epi8(__m128i __a) { return (__m128i)__builtin_ia32_pabsb128((__v16qi)__a); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_abs_pi16(__m64 __a) { return (__m64)__builtin_ia32_pabsw((__v4hi)__a); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_abs_epi16(__m128i __a) { return (__m128i)__builtin_ia32_pabsw128((__v8hi)__a); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_abs_pi32(__m64 __a) { return (__m64)__builtin_ia32_pabsd((__v2si)__a); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_abs_epi32(__m128i __a) { return (__m128i)__builtin_ia32_pabsd128((__v4si)__a); @@ -76,150 +75,150 @@ _mm_abs_epi32(__m128i __a) __m64 __b = (b); \ (__m64)__builtin_ia32_palignr((__v8qi)__a, (__v8qi)__b, (n)); }) -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_hadd_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_phaddw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_hadd_epi32(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_phaddd128((__v4si)__a, (__v4si)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_hadd_pi16(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_phaddw((__v4hi)__a, (__v4hi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_hadd_pi32(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_phaddd((__v2si)__a, (__v2si)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_hadds_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_phaddsw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_hadds_pi16(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_phaddsw((__v4hi)__a, (__v4hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_hsub_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_phsubw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_hsub_epi32(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_phsubd128((__v4si)__a, (__v4si)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_hsub_pi16(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_phsubw((__v4hi)__a, (__v4hi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_hsub_pi32(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_phsubd((__v2si)__a, (__v2si)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_hsubs_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_phsubsw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_hsubs_pi16(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_phsubsw((__v4hi)__a, (__v4hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maddubs_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pmaddubsw128((__v16qi)__a, (__v16qi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_maddubs_pi16(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_pmaddubsw((__v8qi)__a, (__v8qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_mulhrs_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pmulhrsw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_mulhrs_pi16(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_pmulhrsw((__v4hi)__a, (__v4hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_shuffle_epi8(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pshufb128((__v16qi)__a, (__v16qi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_shuffle_pi8(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_pshufb((__v8qi)__a, (__v8qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sign_epi8(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_psignb128((__v16qi)__a, (__v16qi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sign_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_psignw128((__v8hi)__a, (__v8hi)__b); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sign_epi32(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_psignd128((__v4si)__a, (__v4si)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sign_pi8(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_psignb((__v8qi)__a, (__v8qi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sign_pi16(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_psignw((__v4hi)__a, (__v4hi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sign_pi32(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_psignd((__v2si)__a, (__v2si)__b); } -#endif /* __SSSE3__ */ +#undef DEFAULT_FN_ATTRS #endif /* __TMMINTRIN_H */ diff --git a/lib/Headers/wmmintrin.h b/lib/Headers/wmmintrin.h index 369e3c208e53..a2d931010aea 100644 --- a/lib/Headers/wmmintrin.h +++ b/lib/Headers/wmmintrin.h @@ -26,17 +26,8 @@ #include <emmintrin.h> -#if !defined (__AES__) && !defined (__PCLMUL__) -# error "AES/PCLMUL instructions not enabled" -#else - -#ifdef __AES__ #include <__wmmintrin_aes.h> -#endif /* __AES__ */ -#ifdef __PCLMUL__ #include <__wmmintrin_pclmul.h> -#endif /* __PCLMUL__ */ -#endif /* __AES__ || __PCLMUL__ */ #endif /* _WMMINTRIN_H */ diff --git a/lib/Headers/x86intrin.h b/lib/Headers/x86intrin.h index 21a43daf3c2d..4d8077e38291 100644 --- a/lib/Headers/x86intrin.h +++ b/lib/Headers/x86intrin.h @@ -28,53 +28,29 @@ #include <immintrin.h> -#ifdef __3dNOW__ #include <mm3dnow.h> -#endif -#ifdef __BMI__ #include <bmiintrin.h> -#endif -#ifdef __BMI2__ #include <bmi2intrin.h> -#endif -#ifdef __LZCNT__ #include <lzcntintrin.h> -#endif -#ifdef __POPCNT__ #include <popcntintrin.h> -#endif -#ifdef __RDSEED__ #include <rdseedintrin.h> -#endif -#ifdef __PRFCHW__ #include <prfchwintrin.h> -#endif -#ifdef __SSE4A__ #include <ammintrin.h> -#endif -#ifdef __FMA4__ #include <fma4intrin.h> -#endif -#ifdef __XOP__ #include <xopintrin.h> -#endif -#ifdef __TBM__ #include <tbmintrin.h> -#endif -#ifdef __F16C__ #include <f16cintrin.h> -#endif /* FIXME: LWP */ diff --git a/lib/Headers/xmmintrin.h b/lib/Headers/xmmintrin.h index 3a6b95e8bfea..0085eb4237c1 100644 --- a/lib/Headers/xmmintrin.h +++ b/lib/Headers/xmmintrin.h @@ -24,10 +24,6 @@ #ifndef __XMMINTRIN_H #define __XMMINTRIN_H -#ifndef __SSE__ -#error "SSE instruction set not enabled" -#else - #include <mmintrin.h> typedef int __v4si __attribute__((__vector_size__(16))); @@ -40,182 +36,185 @@ typedef float __m128 __attribute__((__vector_size__(16))); #include <mm_malloc.h> #endif -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse"))) + +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_add_ss(__m128 __a, __m128 __b) { __a[0] += __b[0]; return __a; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_add_ps(__m128 __a, __m128 __b) { return __a + __b; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_sub_ss(__m128 __a, __m128 __b) { __a[0] -= __b[0]; return __a; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_sub_ps(__m128 __a, __m128 __b) { return __a - __b; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_mul_ss(__m128 __a, __m128 __b) { __a[0] *= __b[0]; return __a; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_mul_ps(__m128 __a, __m128 __b) { return __a * __b; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_div_ss(__m128 __a, __m128 __b) { __a[0] /= __b[0]; return __a; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_div_ps(__m128 __a, __m128 __b) { return __a / __b; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_sqrt_ss(__m128 __a) { __m128 __c = __builtin_ia32_sqrtss(__a); return (__m128) { __c[0], __a[1], __a[2], __a[3] }; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_sqrt_ps(__m128 __a) { return __builtin_ia32_sqrtps(__a); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_rcp_ss(__m128 __a) { __m128 __c = __builtin_ia32_rcpss(__a); return (__m128) { __c[0], __a[1], __a[2], __a[3] }; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_rcp_ps(__m128 __a) { return __builtin_ia32_rcpps(__a); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_rsqrt_ss(__m128 __a) { __m128 __c = __builtin_ia32_rsqrtss(__a); return (__m128) { __c[0], __a[1], __a[2], __a[3] }; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_rsqrt_ps(__m128 __a) { return __builtin_ia32_rsqrtps(__a); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_min_ss(__m128 __a, __m128 __b) { return __builtin_ia32_minss(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_min_ps(__m128 __a, __m128 __b) { return __builtin_ia32_minps(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_max_ss(__m128 __a, __m128 __b) { return __builtin_ia32_maxss(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_max_ps(__m128 __a, __m128 __b) { return __builtin_ia32_maxps(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_and_ps(__m128 __a, __m128 __b) { return (__m128)((__v4si)__a & (__v4si)__b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_andnot_ps(__m128 __a, __m128 __b) { return (__m128)(~(__v4si)__a & (__v4si)__b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_or_ps(__m128 __a, __m128 __b) { return (__m128)((__v4si)__a | (__v4si)__b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_xor_ps(__m128 __a, __m128 __b) { return (__m128)((__v4si)__a ^ (__v4si)__b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpeq_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpeqss(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpeq_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpeqps(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmplt_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpltss(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmplt_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpltps(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmple_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpless(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmple_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpleps(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpgt_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_shufflevector(__a, @@ -223,13 +222,13 @@ _mm_cmpgt_ss(__m128 __a, __m128 __b) 4, 1, 2, 3); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpgt_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpltps(__b, __a); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpge_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_shufflevector(__a, @@ -237,49 +236,49 @@ _mm_cmpge_ss(__m128 __a, __m128 __b) 4, 1, 2, 3); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpge_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpleps(__b, __a); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpneq_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpneqss(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpneq_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpneqps(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpnlt_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpnltss(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpnlt_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpnltps(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpnle_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpnless(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpnle_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpnleps(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpngt_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_shufflevector(__a, @@ -287,13 +286,13 @@ _mm_cmpngt_ss(__m128 __a, __m128 __b) 4, 1, 2, 3); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpngt_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpnltps(__b, __a); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpnge_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_shufflevector(__a, @@ -301,115 +300,115 @@ _mm_cmpnge_ss(__m128 __a, __m128 __b) 4, 1, 2, 3); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpnge_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpnleps(__b, __a); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpord_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpordss(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpord_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpordps(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpunord_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpunordss(__a, __b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cmpunord_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpunordps(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_comieq_ss(__m128 __a, __m128 __b) { return __builtin_ia32_comieq(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_comilt_ss(__m128 __a, __m128 __b) { return __builtin_ia32_comilt(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_comile_ss(__m128 __a, __m128 __b) { return __builtin_ia32_comile(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_comigt_ss(__m128 __a, __m128 __b) { return __builtin_ia32_comigt(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_comige_ss(__m128 __a, __m128 __b) { return __builtin_ia32_comige(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_comineq_ss(__m128 __a, __m128 __b) { return __builtin_ia32_comineq(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_ucomieq_ss(__m128 __a, __m128 __b) { return __builtin_ia32_ucomieq(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_ucomilt_ss(__m128 __a, __m128 __b) { return __builtin_ia32_ucomilt(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_ucomile_ss(__m128 __a, __m128 __b) { return __builtin_ia32_ucomile(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_ucomigt_ss(__m128 __a, __m128 __b) { return __builtin_ia32_ucomigt(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_ucomige_ss(__m128 __a, __m128 __b) { return __builtin_ia32_ucomige(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_ucomineq_ss(__m128 __a, __m128 __b) { return __builtin_ia32_ucomineq(__a, __b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_cvtss_si32(__m128 __a) { return __builtin_ia32_cvtss2si(__a); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_cvt_ss2si(__m128 __a) { return _mm_cvtss_si32(__a); @@ -417,7 +416,7 @@ _mm_cvt_ss2si(__m128 __a) #ifdef __x86_64__ -static __inline__ long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ long long DEFAULT_FN_ATTRS _mm_cvtss_si64(__m128 __a) { return __builtin_ia32_cvtss2si64(__a); @@ -425,56 +424,56 @@ _mm_cvtss_si64(__m128 __a) #endif -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cvtps_pi32(__m128 __a) { return (__m64)__builtin_ia32_cvtps2pi(__a); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cvt_ps2pi(__m128 __a) { return _mm_cvtps_pi32(__a); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_cvttss_si32(__m128 __a) { return __a[0]; } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_cvtt_ss2si(__m128 __a) { return _mm_cvttss_si32(__a); } -static __inline__ long long __attribute__((__always_inline__, __nodebug__)) +static __inline__ long long DEFAULT_FN_ATTRS _mm_cvttss_si64(__m128 __a) { return __a[0]; } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cvttps_pi32(__m128 __a) { return (__m64)__builtin_ia32_cvttps2pi(__a); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cvtt_ps2pi(__m128 __a) { return _mm_cvttps_pi32(__a); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvtsi32_ss(__m128 __a, int __b) { __a[0] = __b; return __a; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvt_si2ss(__m128 __a, int __b) { return _mm_cvtsi32_ss(__a, __b); @@ -482,7 +481,7 @@ _mm_cvt_si2ss(__m128 __a, int __b) #ifdef __x86_64__ -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvtsi64_ss(__m128 __a, long long __b) { __a[0] = __b; @@ -491,25 +490,25 @@ _mm_cvtsi64_ss(__m128 __a, long long __b) #endif -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvtpi32_ps(__m128 __a, __m64 __b) { return __builtin_ia32_cvtpi2ps(__a, (__v2si)__b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvt_pi2ps(__m128 __a, __m64 __b) { return _mm_cvtpi32_ps(__a, __b); } -static __inline__ float __attribute__((__always_inline__, __nodebug__)) +static __inline__ float DEFAULT_FN_ATTRS _mm_cvtss_f32(__m128 __a) { return __a[0]; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_loadh_pi(__m128 __a, const __m64 *__p) { typedef float __mm_loadh_pi_v2f32 __attribute__((__vector_size__(8))); @@ -521,7 +520,7 @@ _mm_loadh_pi(__m128 __a, const __m64 *__p) return __builtin_shufflevector(__a, __bb, 0, 1, 4, 5); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_loadl_pi(__m128 __a, const __m64 *__p) { typedef float __mm_loadl_pi_v2f32 __attribute__((__vector_size__(8))); @@ -533,7 +532,7 @@ _mm_loadl_pi(__m128 __a, const __m64 *__p) return __builtin_shufflevector(__a, __bb, 4, 5, 2, 3); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_load_ss(const float *__p) { struct __mm_load_ss_struct { @@ -543,7 +542,7 @@ _mm_load_ss(const float *__p) return (__m128){ __u, 0, 0, 0 }; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_load1_ps(const float *__p) { struct __mm_load1_ps_struct { @@ -555,13 +554,13 @@ _mm_load1_ps(const float *__p) #define _mm_load_ps1(p) _mm_load1_ps(p) -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_load_ps(const float *__p) { return *(__m128*)__p; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_loadu_ps(const float *__p) { struct __loadu_ps { @@ -570,63 +569,63 @@ _mm_loadu_ps(const float *__p) return ((struct __loadu_ps*)__p)->__v; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_loadr_ps(const float *__p) { __m128 __a = _mm_load_ps(__p); return __builtin_shufflevector(__a, __a, 3, 2, 1, 0); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_set_ss(float __w) { return (__m128){ __w, 0, 0, 0 }; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_set1_ps(float __w) { return (__m128){ __w, __w, __w, __w }; } /* Microsoft specific. */ -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_set_ps1(float __w) { return _mm_set1_ps(__w); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_set_ps(float __z, float __y, float __x, float __w) { return (__m128){ __w, __x, __y, __z }; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_setr_ps(float __z, float __y, float __x, float __w) { return (__m128){ __z, __y, __x, __w }; } -static __inline__ __m128 __attribute__((__always_inline__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_setzero_ps(void) { return (__m128){ 0, 0, 0, 0 }; } -static __inline__ void __attribute__((__always_inline__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_storeh_pi(__m64 *__p, __m128 __a) { __builtin_ia32_storehps((__v2si *)__p, __a); } -static __inline__ void __attribute__((__always_inline__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_storel_pi(__m64 *__p, __m128 __a) { __builtin_ia32_storelps((__v2si *)__p, __a); } -static __inline__ void __attribute__((__always_inline__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_store_ss(float *__p, __m128 __a) { struct __mm_store_ss_struct { @@ -635,32 +634,32 @@ _mm_store_ss(float *__p, __m128 __a) ((struct __mm_store_ss_struct*)__p)->__u = __a[0]; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_storeu_ps(float *__p, __m128 __a) { __builtin_ia32_storeups(__p, __a); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_store1_ps(float *__p, __m128 __a) { __a = __builtin_shufflevector(__a, __a, 0, 0, 0, 0); _mm_storeu_ps(__p, __a); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_store_ps1(float *__p, __m128 __a) { return _mm_store1_ps(__p, __a); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_store_ps(float *__p, __m128 __a) { *(__m128 *)__p = __a; } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_storer_ps(float *__p, __m128 __a) { __a = __builtin_shufflevector(__a, __a, 3, 2, 1, 0); @@ -679,32 +678,32 @@ _mm_storer_ps(float *__p, __m128 __a) #define _mm_prefetch(a, sel) (__builtin_prefetch((void *)(a), 0, (sel))) #endif -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_stream_pi(__m64 *__p, __m64 __a) { __builtin_ia32_movntq(__p, __a); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_stream_ps(float *__p, __m128 __a) { __builtin_ia32_movntps(__p, __a); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_sfence(void) { __builtin_ia32_sfence(); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_extract_pi16(__m64 __a, int __n) { __v4hi __b = (__v4hi)__a; return (unsigned short)__b[__n & 3]; } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_insert_pi16(__m64 __a, int __d, int __n) { __v4hi __b = (__v4hi)__a; @@ -712,37 +711,37 @@ _mm_insert_pi16(__m64 __a, int __d, int __n) return (__m64)__b; } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_max_pi16(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_pmaxsw((__v4hi)__a, (__v4hi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_max_pu8(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_pmaxub((__v8qi)__a, (__v8qi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_min_pi16(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_pminsw((__v4hi)__a, (__v4hi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_min_pu8(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_pminub((__v8qi)__a, (__v8qi)__b); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_movemask_pi8(__m64 __a) { return __builtin_ia32_pmovmskb((__v8qi)__a); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_mulhi_pu16(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_pmulhuw((__v4hi)__a, (__v4hi)__b); @@ -752,37 +751,37 @@ _mm_mulhi_pu16(__m64 __a, __m64 __b) __m64 __a = (a); \ (__m64)__builtin_ia32_pshufw((__v4hi)__a, (n)); }) -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_maskmove_si64(__m64 __d, __m64 __n, char *__p) { __builtin_ia32_maskmovq((__v8qi)__d, (__v8qi)__n, __p); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_avg_pu8(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_pavgb((__v8qi)__a, (__v8qi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_avg_pu16(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_pavgw((__v4hi)__a, (__v4hi)__b); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_sad_pu8(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_psadbw((__v8qi)__a, (__v8qi)__b); } -static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__)) +static __inline__ unsigned int DEFAULT_FN_ATTRS _mm_getcsr(void) { return __builtin_ia32_stmxcsr(); } -static __inline__ void __attribute__((__always_inline__, __nodebug__)) +static __inline__ void DEFAULT_FN_ATTRS _mm_setcsr(unsigned int __i) { __builtin_ia32_ldmxcsr(__i); @@ -796,37 +795,37 @@ _mm_setcsr(unsigned int __i) (((mask) & 0x30) >> 4) + 4, \ (((mask) & 0xc0) >> 6) + 4); }) -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_unpackhi_ps(__m128 __a, __m128 __b) { return __builtin_shufflevector(__a, __b, 2, 6, 3, 7); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_unpacklo_ps(__m128 __a, __m128 __b) { return __builtin_shufflevector(__a, __b, 0, 4, 1, 5); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_move_ss(__m128 __a, __m128 __b) { return __builtin_shufflevector(__a, __b, 4, 1, 2, 3); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_movehl_ps(__m128 __a, __m128 __b) { return __builtin_shufflevector(__a, __b, 6, 7, 2, 3); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_movelh_ps(__m128 __a, __m128 __b) { return __builtin_shufflevector(__a, __b, 0, 1, 4, 5); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvtpi16_ps(__m64 __a) { __m64 __b, __c; @@ -844,7 +843,7 @@ _mm_cvtpi16_ps(__m64 __a) return __r; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvtpu16_ps(__m64 __a) { __m64 __b, __c; @@ -861,7 +860,7 @@ _mm_cvtpu16_ps(__m64 __a) return __r; } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvtpi8_ps(__m64 __a) { __m64 __b; @@ -873,7 +872,7 @@ _mm_cvtpi8_ps(__m64 __a) return _mm_cvtpi16_ps(__b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvtpu8_ps(__m64 __a) { __m64 __b; @@ -884,7 +883,7 @@ _mm_cvtpu8_ps(__m64 __a) return _mm_cvtpi16_ps(__b); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_cvtpi32x2_ps(__m64 __a, __m64 __b) { __m128 __c; @@ -896,7 +895,7 @@ _mm_cvtpi32x2_ps(__m64 __a, __m64 __b) return _mm_cvtpi32_ps(__c, __a); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cvtps_pi16(__m128 __a) { __m64 __b, __c; @@ -908,7 +907,7 @@ _mm_cvtps_pi16(__m128 __a) return _mm_packs_pi32(__b, __c); } -static __inline__ __m64 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m64 DEFAULT_FN_ATTRS _mm_cvtps_pi8(__m128 __a) { __m64 __b, __c; @@ -919,7 +918,7 @@ _mm_cvtps_pi8(__m128 __a) return _mm_packs_pi16(__b, __c); } -static __inline__ int __attribute__((__always_inline__, __nodebug__)) +static __inline__ int DEFAULT_FN_ATTRS _mm_movemask_ps(__m128 __a) { return __builtin_ia32_movmskps(__a); @@ -993,11 +992,11 @@ do { \ #define _m_ _mm_ #define _m_ _mm_ +#undef DEFAULT_FN_ATTRS + /* Ugly hack for backwards-compatibility (compatible with gcc) */ #if defined(__SSE2__) && !__has_feature(modules) #include <emmintrin.h> #endif -#endif /* __SSE__ */ - #endif /* __XMMINTRIN_H */ diff --git a/lib/Headers/xopintrin.h b/lib/Headers/xopintrin.h index cc94ca0264c0..8417d7826962 100644 --- a/lib/Headers/xopintrin.h +++ b/lib/Headers/xopintrin.h @@ -28,211 +28,210 @@ #ifndef __XOPINTRIN_H #define __XOPINTRIN_H -#ifndef __XOP__ -# error "XOP instruction set is not enabled" -#else - #include <fma4intrin.h> -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +/* Define the default attributes for the functions in this file. */ +#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("xop"))) + +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maccs_epi16(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpmacssww((__v8hi)__A, (__v8hi)__B, (__v8hi)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_macc_epi16(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpmacsww((__v8hi)__A, (__v8hi)__B, (__v8hi)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maccsd_epi16(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpmacsswd((__v8hi)__A, (__v8hi)__B, (__v4si)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maccd_epi16(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpmacswd((__v8hi)__A, (__v8hi)__B, (__v4si)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maccs_epi32(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpmacssdd((__v4si)__A, (__v4si)__B, (__v4si)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_macc_epi32(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpmacsdd((__v4si)__A, (__v4si)__B, (__v4si)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maccslo_epi32(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpmacssdql((__v4si)__A, (__v4si)__B, (__v2di)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_macclo_epi32(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpmacsdql((__v4si)__A, (__v4si)__B, (__v2di)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maccshi_epi32(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpmacssdqh((__v4si)__A, (__v4si)__B, (__v2di)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_macchi_epi32(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpmacsdqh((__v4si)__A, (__v4si)__B, (__v2di)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maddsd_epi16(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpmadcsswd((__v8hi)__A, (__v8hi)__B, (__v4si)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_maddd_epi16(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpmadcswd((__v8hi)__A, (__v8hi)__B, (__v4si)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_haddw_epi8(__m128i __A) { return (__m128i)__builtin_ia32_vphaddbw((__v16qi)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_haddd_epi8(__m128i __A) { return (__m128i)__builtin_ia32_vphaddbd((__v16qi)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_haddq_epi8(__m128i __A) { return (__m128i)__builtin_ia32_vphaddbq((__v16qi)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_haddd_epi16(__m128i __A) { return (__m128i)__builtin_ia32_vphaddwd((__v8hi)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_haddq_epi16(__m128i __A) { return (__m128i)__builtin_ia32_vphaddwq((__v8hi)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_haddq_epi32(__m128i __A) { return (__m128i)__builtin_ia32_vphadddq((__v4si)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_haddw_epu8(__m128i __A) { return (__m128i)__builtin_ia32_vphaddubw((__v16qi)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_haddd_epu8(__m128i __A) { return (__m128i)__builtin_ia32_vphaddubd((__v16qi)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_haddq_epu8(__m128i __A) { return (__m128i)__builtin_ia32_vphaddubq((__v16qi)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_haddd_epu16(__m128i __A) { return (__m128i)__builtin_ia32_vphadduwd((__v8hi)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_haddq_epu16(__m128i __A) { return (__m128i)__builtin_ia32_vphadduwq((__v8hi)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_haddq_epu32(__m128i __A) { return (__m128i)__builtin_ia32_vphaddudq((__v4si)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_hsubw_epi8(__m128i __A) { return (__m128i)__builtin_ia32_vphsubbw((__v16qi)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_hsubd_epi16(__m128i __A) { return (__m128i)__builtin_ia32_vphsubwd((__v8hi)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_hsubq_epi32(__m128i __A) { return (__m128i)__builtin_ia32_vphsubdq((__v4si)__A); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_cmov_si128(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpcmov(__A, __B, __C); } -static __inline__ __m256i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256i DEFAULT_FN_ATTRS _mm256_cmov_si256(__m256i __A, __m256i __B, __m256i __C) { return (__m256i)__builtin_ia32_vpcmov_256(__A, __B, __C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_perm_epi8(__m128i __A, __m128i __B, __m128i __C) { return (__m128i)__builtin_ia32_vpperm((__v16qi)__A, (__v16qi)__B, (__v16qi)__C); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_rot_epi8(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vprotb((__v16qi)__A, (__v16qi)__B); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_rot_epi16(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vprotw((__v8hi)__A, (__v8hi)__B); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_rot_epi32(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vprotd((__v4si)__A, (__v4si)__B); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_rot_epi64(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vprotq((__v2di)__A, (__v2di)__B); @@ -254,49 +253,49 @@ _mm_rot_epi64(__m128i __A, __m128i __B) __m128i __A = (A); \ (__m128i)__builtin_ia32_vprotqi((__v2di)__A, (N)); }) -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_shl_epi8(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vpshlb((__v16qi)__A, (__v16qi)__B); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_shl_epi16(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vpshlw((__v8hi)__A, (__v8hi)__B); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_shl_epi32(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vpshld((__v4si)__A, (__v4si)__B); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_shl_epi64(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vpshlq((__v2di)__A, (__v2di)__B); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sha_epi8(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vpshab((__v16qi)__A, (__v16qi)__B); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sha_epi16(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vpshaw((__v8hi)__A, (__v8hi)__B); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sha_epi32(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vpshad((__v4si)__A, (__v4si)__B); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_sha_epi64(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vpshaq((__v2di)__A, (__v2di)__B); @@ -351,385 +350,385 @@ _mm_sha_epi64(__m128i __A, __m128i __B) #define _MM_PCOMCTRL_FALSE 6 #define _MM_PCOMCTRL_TRUE 7 -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comlt_epu8(__m128i __A, __m128i __B) { return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_LT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comle_epu8(__m128i __A, __m128i __B) { return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_LE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comgt_epu8(__m128i __A, __m128i __B) { return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_GT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comge_epu8(__m128i __A, __m128i __B) { return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_GE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comeq_epu8(__m128i __A, __m128i __B) { return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_EQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comneq_epu8(__m128i __A, __m128i __B) { return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_NEQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comfalse_epu8(__m128i __A, __m128i __B) { return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_FALSE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comtrue_epu8(__m128i __A, __m128i __B) { return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_TRUE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comlt_epu16(__m128i __A, __m128i __B) { return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_LT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comle_epu16(__m128i __A, __m128i __B) { return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_LE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comgt_epu16(__m128i __A, __m128i __B) { return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_GT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comge_epu16(__m128i __A, __m128i __B) { return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_GE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comeq_epu16(__m128i __A, __m128i __B) { return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_EQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comneq_epu16(__m128i __A, __m128i __B) { return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_NEQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comfalse_epu16(__m128i __A, __m128i __B) { return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_FALSE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comtrue_epu16(__m128i __A, __m128i __B) { return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_TRUE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comlt_epu32(__m128i __A, __m128i __B) { return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_LT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comle_epu32(__m128i __A, __m128i __B) { return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_LE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comgt_epu32(__m128i __A, __m128i __B) { return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_GT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comge_epu32(__m128i __A, __m128i __B) { return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_GE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comeq_epu32(__m128i __A, __m128i __B) { return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_EQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comneq_epu32(__m128i __A, __m128i __B) { return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_NEQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comfalse_epu32(__m128i __A, __m128i __B) { return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_FALSE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comtrue_epu32(__m128i __A, __m128i __B) { return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_TRUE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comlt_epu64(__m128i __A, __m128i __B) { return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_LT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comle_epu64(__m128i __A, __m128i __B) { return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_LE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comgt_epu64(__m128i __A, __m128i __B) { return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_GT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comge_epu64(__m128i __A, __m128i __B) { return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_GE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comeq_epu64(__m128i __A, __m128i __B) { return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_EQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comneq_epu64(__m128i __A, __m128i __B) { return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_NEQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comfalse_epu64(__m128i __A, __m128i __B) { return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_FALSE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comtrue_epu64(__m128i __A, __m128i __B) { return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_TRUE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comlt_epi8(__m128i __A, __m128i __B) { return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_LT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comle_epi8(__m128i __A, __m128i __B) { return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_LE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comgt_epi8(__m128i __A, __m128i __B) { return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_GT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comge_epi8(__m128i __A, __m128i __B) { return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_GE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comeq_epi8(__m128i __A, __m128i __B) { return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_EQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comneq_epi8(__m128i __A, __m128i __B) { return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_NEQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comfalse_epi8(__m128i __A, __m128i __B) { return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_FALSE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comtrue_epi8(__m128i __A, __m128i __B) { return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_TRUE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comlt_epi16(__m128i __A, __m128i __B) { return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_LT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comle_epi16(__m128i __A, __m128i __B) { return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_LE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comgt_epi16(__m128i __A, __m128i __B) { return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_GT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comge_epi16(__m128i __A, __m128i __B) { return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_GE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comeq_epi16(__m128i __A, __m128i __B) { return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_EQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comneq_epi16(__m128i __A, __m128i __B) { return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_NEQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comfalse_epi16(__m128i __A, __m128i __B) { return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_FALSE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comtrue_epi16(__m128i __A, __m128i __B) { return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_TRUE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comlt_epi32(__m128i __A, __m128i __B) { return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_LT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comle_epi32(__m128i __A, __m128i __B) { return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_LE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comgt_epi32(__m128i __A, __m128i __B) { return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_GT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comge_epi32(__m128i __A, __m128i __B) { return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_GE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comeq_epi32(__m128i __A, __m128i __B) { return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_EQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comneq_epi32(__m128i __A, __m128i __B) { return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_NEQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comfalse_epi32(__m128i __A, __m128i __B) { return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_FALSE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comtrue_epi32(__m128i __A, __m128i __B) { return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_TRUE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comlt_epi64(__m128i __A, __m128i __B) { return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_LT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comle_epi64(__m128i __A, __m128i __B) { return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_LE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comgt_epi64(__m128i __A, __m128i __B) { return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_GT); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comge_epi64(__m128i __A, __m128i __B) { return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_GE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comeq_epi64(__m128i __A, __m128i __B) { return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_EQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comneq_epi64(__m128i __A, __m128i __B) { return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_NEQ); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comfalse_epi64(__m128i __A, __m128i __B) { return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_FALSE); } -static __inline__ __m128i __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128i DEFAULT_FN_ATTRS _mm_comtrue_epi64(__m128i __A, __m128i __B) { return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_TRUE); @@ -763,42 +762,42 @@ _mm_comtrue_epi64(__m128i __A, __m128i __B) (__m256)__builtin_ia32_vpermil2ps256((__v8sf)__X, (__v8sf)__Y, \ (__v8si)__C, (I)); }) -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_frcz_ss(__m128 __A) { return (__m128)__builtin_ia32_vfrczss((__v4sf)__A); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_frcz_sd(__m128d __A) { return (__m128d)__builtin_ia32_vfrczsd((__v2df)__A); } -static __inline__ __m128 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128 DEFAULT_FN_ATTRS _mm_frcz_ps(__m128 __A) { return (__m128)__builtin_ia32_vfrczps((__v4sf)__A); } -static __inline__ __m128d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m128d DEFAULT_FN_ATTRS _mm_frcz_pd(__m128d __A) { return (__m128d)__builtin_ia32_vfrczpd((__v2df)__A); } -static __inline__ __m256 __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256 DEFAULT_FN_ATTRS _mm256_frcz_ps(__m256 __A) { return (__m256)__builtin_ia32_vfrczps256((__v8sf)__A); } -static __inline__ __m256d __attribute__((__always_inline__, __nodebug__)) +static __inline__ __m256d DEFAULT_FN_ATTRS _mm256_frcz_pd(__m256d __A) { return (__m256d)__builtin_ia32_vfrczpd256((__v4df)__A); } -#endif /* __XOP__ */ +#undef DEFAULT_FN_ATTRS #endif /* __XOPINTRIN_H */ diff --git a/lib/Headers/xtestintrin.h b/lib/Headers/xtestintrin.h new file mode 100644 index 000000000000..9d3378fd1eea --- /dev/null +++ b/lib/Headers/xtestintrin.h @@ -0,0 +1,41 @@ +/*===---- xtestintrin.h - XTEST intrinsic ---------------------------------=== + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + *===-----------------------------------------------------------------------=== + */ + +#ifndef __IMMINTRIN_H +#error "Never use <xtestintrin.h> directly; include <immintrin.h> instead." +#endif + +#ifndef __XTESTINTRIN_H +#define __XTESTINTRIN_H + +/* xtest returns non-zero if the instruction is executed within an RTM or active + * HLE region. */ +/* FIXME: This can be an either or for RTM/HLE. Deal with this when HLE is + * supported. */ +static __inline__ int + __attribute__((__always_inline__, __nodebug__, __target__("rtm"))) + _xtest(void) { + return __builtin_ia32_xtest(); +} + +#endif diff --git a/lib/Lex/HeaderSearch.cpp b/lib/Lex/HeaderSearch.cpp index ad7d3449ac4a..7a98f5418334 100644 --- a/lib/Lex/HeaderSearch.cpp +++ b/lib/Lex/HeaderSearch.cpp @@ -158,7 +158,7 @@ std::string HeaderSearch::getModuleFileName(StringRef ModuleName, Module *HeaderSearch::lookupModule(StringRef ModuleName, bool AllowSearch) { // Look in the module map to determine if there is a module by this name. Module *Module = ModMap.findModule(ModuleName); - if (Module || !AllowSearch || !LangOpts.ModulesImplicitMaps) + if (Module || !AllowSearch || !HSOpts->ImplicitModuleMaps) return Module; // Look through the various header search paths to load any available module @@ -1076,7 +1076,7 @@ StringRef HeaderSearch::getUniqueFrameworkName(StringRef Framework) { bool HeaderSearch::hasModuleMap(StringRef FileName, const DirectoryEntry *Root, bool IsSystem) { - if (!HSOpts->ModuleMaps || !LangOpts.ModulesImplicitMaps) + if (!HSOpts->ImplicitModuleMaps) return false; SmallVector<const DirectoryEntry *, 2> FixUpDirectories; @@ -1203,7 +1203,7 @@ HeaderSearch::loadModuleMapFileImpl(const FileEntry *File, bool IsSystem, const FileEntry * HeaderSearch::lookupModuleMapFile(const DirectoryEntry *Dir, bool IsFramework) { - if (!LangOpts.ModulesImplicitMaps) + if (!HSOpts->ImplicitModuleMaps) return nullptr; // For frameworks, the preferred spelling is Modules/module.modulemap, but // module.map at the framework root is also accepted. @@ -1241,7 +1241,7 @@ Module *HeaderSearch::loadFrameworkModule(StringRef Name, // Try to infer a module map from the framework directory. - if (LangOpts.ModulesImplicitMaps) + if (HSOpts->ImplicitModuleMaps) return ModMap.inferFrameworkModule(Name, Dir, IsSystem, /*Parent=*/nullptr); return nullptr; @@ -1282,7 +1282,7 @@ HeaderSearch::loadModuleMapFile(const DirectoryEntry *Dir, bool IsSystem, void HeaderSearch::collectAllModules(SmallVectorImpl<Module *> &Modules) { Modules.clear(); - if (LangOpts.ModulesImplicitMaps) { + if (HSOpts->ImplicitModuleMaps) { // Load module maps for each of the header search directories. for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) { bool IsSystem = SearchDirs[Idx].isSystemHeaderDirectory(); @@ -1333,7 +1333,7 @@ void HeaderSearch::collectAllModules(SmallVectorImpl<Module *> &Modules) { } void HeaderSearch::loadTopLevelSystemModules() { - if (!LangOpts.ModulesImplicitMaps) + if (!HSOpts->ImplicitModuleMaps) return; // Load module maps for each of the header search directories. @@ -1351,7 +1351,7 @@ void HeaderSearch::loadTopLevelSystemModules() { } void HeaderSearch::loadSubdirectoryModuleMaps(DirectoryLookup &SearchDir) { - assert(LangOpts.ModulesImplicitMaps && + assert(HSOpts->ImplicitModuleMaps && "Should not be loading subdirectory module maps"); if (SearchDir.haveSearchedAllModuleMaps()) diff --git a/lib/Lex/ModuleMap.cpp b/lib/Lex/ModuleMap.cpp index addad59c5a3e..6c98d01c170b 100644 --- a/lib/Lex/ModuleMap.cpp +++ b/lib/Lex/ModuleMap.cpp @@ -165,7 +165,8 @@ static bool isBuiltinHeader(StringRef FileName) { ModuleMap::HeadersMap::iterator ModuleMap::findKnownHeader(const FileEntry *File) { HeadersMap::iterator Known = Headers.find(File); - if (Known == Headers.end() && File->getDir() == BuiltinIncludeDir && + if (HeaderInfo.getHeaderSearchOpts().ImplicitModuleMaps && + Known == Headers.end() && File->getDir() == BuiltinIncludeDir && isBuiltinHeader(llvm::sys::path::filename(File->getName()))) { HeaderInfo.loadTopLevelSystemModules(); return Headers.find(File); @@ -176,6 +177,9 @@ ModuleMap::findKnownHeader(const FileEntry *File) { ModuleMap::KnownHeader ModuleMap::findHeaderInUmbrellaDirs(const FileEntry *File, SmallVectorImpl<const DirectoryEntry *> &IntermediateDirs) { + if (UmbrellaDirs.empty()) + return KnownHeader(); + const DirectoryEntry *Dir = File->getDir(); assert(Dir && "file in no directory"); @@ -330,41 +334,23 @@ static bool isBetterKnownHeader(const ModuleMap::KnownHeader &New, return false; } -ModuleMap::KnownHeader -ModuleMap::findModuleForHeader(const FileEntry *File, - Module *RequestingModule) { - HeadersMap::iterator Known = findKnownHeader(File); - +ModuleMap::KnownHeader ModuleMap::findModuleForHeader(const FileEntry *File) { auto MakeResult = [&](ModuleMap::KnownHeader R) -> ModuleMap::KnownHeader { if (R.getRole() & ModuleMap::TextualHeader) return ModuleMap::KnownHeader(); return R; }; + HeadersMap::iterator Known = findKnownHeader(File); if (Known != Headers.end()) { ModuleMap::KnownHeader Result; - // Iterate over all modules that 'File' is part of to find the best fit. - for (SmallVectorImpl<KnownHeader>::iterator I = Known->second.begin(), - E = Known->second.end(); - I != E; ++I) { + for (KnownHeader &H : Known->second) { // Cannot use a module if it is unavailable. - if (!I->getModule()->isAvailable()) + if (!H.getModule()->isAvailable()) continue; - - // If 'File' is part of 'RequestingModule', 'RequestingModule' is the - // module we are looking for. - if (I->getModule() == RequestingModule) - return MakeResult(*I); - - // If uses need to be specified explicitly, we are only allowed to return - // modules that are explicitly used by the requesting module. - if (RequestingModule && LangOpts.ModulesDeclUse && - !RequestingModule->directlyUses(I->getModule())) - continue; - - if (!Result || isBetterKnownHeader(*I, Result)) - Result = *I; + if (!Result || isBetterKnownHeader(H, Result)) + Result = H; } return MakeResult(Result); } diff --git a/lib/Lex/PPDirectives.cpp b/lib/Lex/PPDirectives.cpp index ec06e790f018..33ce79922819 100644 --- a/lib/Lex/PPDirectives.cpp +++ b/lib/Lex/PPDirectives.cpp @@ -1575,6 +1575,15 @@ void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc, PragmaARCCFCodeAuditedLoc = SourceLocation(); } + // Complain about attempts to #include files in an assume-nonnull pragma. + if (PragmaAssumeNonNullLoc.isValid()) { + Diag(HashLoc, diag::err_pp_include_in_assume_nonnull); + Diag(PragmaAssumeNonNullLoc, diag::note_pragma_entered_here); + + // Immediately leave the pragma. + PragmaAssumeNonNullLoc = SourceLocation(); + } + if (HeaderInfo.HasIncludeAliasMap()) { // Map the filename with the brackets still attached. If the name doesn't // map to anything, fall back on the filename we've already gotten the @@ -1603,7 +1612,7 @@ void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc, FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled, LookupFrom, LookupFromFile, CurDir, Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr, - HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule : nullptr); + &SuggestedModule); if (!File) { if (Callbacks) { @@ -1620,9 +1629,7 @@ void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc, FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled, LookupFrom, LookupFromFile, CurDir, nullptr, nullptr, - HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule - : nullptr, - /*SkipCache*/ true); + &SuggestedModule, /*SkipCache*/ true); } } } @@ -1638,8 +1645,7 @@ void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc, LookupFrom, LookupFromFile, CurDir, Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr, - HeaderInfo.getHeaderSearchOpts().ModuleMaps ? &SuggestedModule - : nullptr); + &SuggestedModule); if (File) { SourceRange Range(FilenameTok.getLocation(), CharEnd); Diag(FilenameTok, diag::err_pp_file_not_found_not_fatal) << @@ -2012,8 +2018,8 @@ static bool isConfigurationPattern(Token &MacroName, MacroInfo *MI, } // #define inline - if ((MacroName.is(tok::kw_extern) || MacroName.is(tok::kw_inline) || - MacroName.is(tok::kw_static) || MacroName.is(tok::kw_const)) && + if (MacroName.isOneOf(tok::kw_extern, tok::kw_inline, tok::kw_static, + tok::kw_const) && MI->getNumTokens() == 0) { return true; } diff --git a/lib/Lex/PPLexerChange.cpp b/lib/Lex/PPLexerChange.cpp index e68fb7df8e88..1a35d32dedb5 100644 --- a/lib/Lex/PPLexerChange.cpp +++ b/lib/Lex/PPLexerChange.cpp @@ -355,6 +355,17 @@ bool Preprocessor::HandleEndOfFile(Token &Result, bool isEndOfMacro) { PragmaARCCFCodeAuditedLoc = SourceLocation(); } + // Complain about reaching a true EOF within assume_nonnull. + // We don't want to complain about reaching the end of a macro + // instantiation or a _Pragma. + if (PragmaAssumeNonNullLoc.isValid() && + !isEndOfMacro && !(CurLexer && CurLexer->Is_PragmaLexer)) { + Diag(PragmaAssumeNonNullLoc, diag::err_pp_eof_in_assume_nonnull); + + // Recover by leaving immediately. + PragmaAssumeNonNullLoc = SourceLocation(); + } + // If this is a #include'd file, pop it off the include stack and continue // lexing the #includer file. if (!IncludeMacroStack.empty()) { diff --git a/lib/Lex/PPMacroExpansion.cpp b/lib/Lex/PPMacroExpansion.cpp index 03784e204503..5e0b283bd77d 100644 --- a/lib/Lex/PPMacroExpansion.cpp +++ b/lib/Lex/PPMacroExpansion.cpp @@ -726,10 +726,10 @@ MacroArgs *Preprocessor::ReadFunctionLikeMacroArgs(Token &MacroName, unsigned NumActuals = 0; while (Tok.isNot(tok::r_paren)) { - if (ContainsCodeCompletionTok && (Tok.is(tok::eof) || Tok.is(tok::eod))) + if (ContainsCodeCompletionTok && Tok.isOneOf(tok::eof, tok::eod)) break; - assert((Tok.is(tok::l_paren) || Tok.is(tok::comma)) && + assert(Tok.isOneOf(tok::l_paren, tok::comma) && "only expect argument separators here"); unsigned ArgTokenStart = ArgTokens.size(); @@ -744,7 +744,7 @@ MacroArgs *Preprocessor::ReadFunctionLikeMacroArgs(Token &MacroName, // an argument value in a macro could expand to ',' or '(' or ')'. LexUnexpandedToken(Tok); - if (Tok.is(tok::eof) || Tok.is(tok::eod)) { // "#if f(<eof>" & "#if f(\n" + if (Tok.isOneOf(tok::eof, tok::eod)) { // "#if f(<eof>" & "#if f(\n" if (!ContainsCodeCompletionTok) { Diag(MacroName, diag::err_unterm_macro_invoc); Diag(MI->getDefinitionLoc(), diag::note_macro_here) @@ -1049,13 +1049,17 @@ static bool HasFeature(const Preprocessor &PP, const IdentifierInfo *II) { Feature = Feature.substr(2, Feature.size() - 4); return llvm::StringSwitch<bool>(Feature) - .Case("address_sanitizer", LangOpts.Sanitize.has(SanitizerKind::Address)) + .Case("address_sanitizer", + LangOpts.Sanitize.hasOneOf(SanitizerKind::Address | + SanitizerKind::KernelAddress)) + .Case("assume_nonnull", LangOpts.ObjC1 || LangOpts.GNUMode) .Case("attribute_analyzer_noreturn", true) .Case("attribute_availability", true) .Case("attribute_availability_with_message", true) .Case("attribute_availability_app_extension", true) .Case("attribute_cf_returns_not_retained", true) .Case("attribute_cf_returns_retained", true) + .Case("attribute_cf_returns_on_parameters", true) .Case("attribute_deprecated_with_message", true) .Case("attribute_ext_vector_type", true) .Case("attribute_ns_returns_not_retained", true) @@ -1073,6 +1077,7 @@ static bool HasFeature(const Preprocessor &PP, const IdentifierInfo *II) { .Case("cxx_exceptions", LangOpts.CXXExceptions) .Case("cxx_rtti", LangOpts.RTTI) .Case("enumerator_attributes", true) + .Case("nullability", LangOpts.ObjC1 || LangOpts.GNUMode) .Case("memory_sanitizer", LangOpts.Sanitize.has(SanitizerKind::Memory)) .Case("thread_sanitizer", LangOpts.Sanitize.has(SanitizerKind::Thread)) .Case("dataflow_sanitizer", LangOpts.Sanitize.has(SanitizerKind::DataFlow)) @@ -1190,6 +1195,7 @@ static bool HasFeature(const Preprocessor &PP, const IdentifierInfo *II) { .Case("is_trivially_copyable", LangOpts.CPlusPlus) .Case("is_union", LangOpts.CPlusPlus) .Case("modules", LangOpts.Modules) + .Case("safe_stack", LangOpts.Sanitize.has(SanitizerKind::SafeStack)) .Case("tls", PP.getTargetInfo().isTLSSupported()) .Case("underlying_type", LangOpts.CPlusPlus) .Default(false); @@ -1219,6 +1225,7 @@ static bool HasExtension(const Preprocessor &PP, const IdentifierInfo *II) { // Because we inherit the feature list from HasFeature, this string switch // must be less restrictive than HasFeature's. return llvm::StringSwitch<bool>(Extension) + .Case("nullability", true) // C11 features supported by other languages as extensions. .Case("c_alignas", true) .Case("c_alignof", true) @@ -1746,7 +1753,7 @@ void Preprocessor::ExpandBuiltinMacro(Token &Tok) { Diag(Tok.getLocation(), diag::err_pp_identifier_arg_not_identifier) << Tok.getKind(); // Don't walk past anything that's not a real token. - if (Tok.is(tok::eof) || Tok.is(tok::eod) || Tok.isAnnotation()) + if (Tok.isOneOf(tok::eof, tok::eod) || Tok.isAnnotation()) return; } diff --git a/lib/Lex/Pragma.cpp b/lib/Lex/Pragma.cpp index 26ed674f65aa..5eb665549e86 100644 --- a/lib/Lex/Pragma.cpp +++ b/lib/Lex/Pragma.cpp @@ -1342,6 +1342,60 @@ struct PragmaARCCFCodeAuditedHandler : public PragmaHandler { } }; +/// PragmaAssumeNonNullHandler - +/// \#pragma clang assume_nonnull begin/end +struct PragmaAssumeNonNullHandler : public PragmaHandler { + PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &NameTok) override { + SourceLocation Loc = NameTok.getLocation(); + bool IsBegin; + + Token Tok; + + // Lex the 'begin' or 'end'. + PP.LexUnexpandedToken(Tok); + const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo(); + if (BeginEnd && BeginEnd->isStr("begin")) { + IsBegin = true; + } else if (BeginEnd && BeginEnd->isStr("end")) { + IsBegin = false; + } else { + PP.Diag(Tok.getLocation(), diag::err_pp_assume_nonnull_syntax); + return; + } + + // Verify that this is followed by EOD. + PP.LexUnexpandedToken(Tok); + if (Tok.isNot(tok::eod)) + PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma"; + + // The start location of the active audit. + SourceLocation BeginLoc = PP.getPragmaAssumeNonNullLoc(); + + // The start location we want after processing this. + SourceLocation NewLoc; + + if (IsBegin) { + // Complain about attempts to re-enter an audit. + if (BeginLoc.isValid()) { + PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull); + PP.Diag(BeginLoc, diag::note_pragma_entered_here); + } + NewLoc = Loc; + } else { + // Complain about attempts to leave an audit that doesn't exist. + if (!BeginLoc.isValid()) { + PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull); + return; + } + NewLoc = SourceLocation(); + } + + PP.setPragmaAssumeNonNullLoc(NewLoc); + } +}; + /// \brief Handle "\#pragma region [...]" /// /// The syntax is @@ -1393,6 +1447,7 @@ void Preprocessor::RegisterBuiltinPragmas() { AddPragmaHandler("clang", new PragmaDependencyHandler()); AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang")); AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler()); + AddPragmaHandler("clang", new PragmaAssumeNonNullHandler()); AddPragmaHandler("STDC", new PragmaSTDC_FENV_ACCESSHandler()); AddPragmaHandler("STDC", new PragmaSTDC_CX_LIMITED_RANGEHandler()); diff --git a/lib/Lex/TokenConcatenation.cpp b/lib/Lex/TokenConcatenation.cpp index 08327496ab8a..27b4eab1a28d 100644 --- a/lib/Lex/TokenConcatenation.cpp +++ b/lib/Lex/TokenConcatenation.cpp @@ -178,20 +178,20 @@ bool TokenConcatenation::AvoidConcat(const Token &PrevPrevTok, if (ConcatInfo & aci_avoid_equal) { // If the next token is '=' or '==', avoid concatenation. - if (Tok.is(tok::equal) || Tok.is(tok::equalequal)) + if (Tok.isOneOf(tok::equal, tok::equalequal)) return true; ConcatInfo &= ~aci_avoid_equal; } if (Tok.isAnnotation()) { // Modules annotation can show up when generated automatically for includes. - assert((Tok.is(tok::annot_module_include) || - Tok.is(tok::annot_module_begin) || - Tok.is(tok::annot_module_end)) && + assert(Tok.isOneOf(tok::annot_module_include, tok::annot_module_begin, + tok::annot_module_end) && "unexpected annotation in AvoidConcat"); ConcatInfo = 0; } - if (ConcatInfo == 0) return false; + if (ConcatInfo == 0) + return false; // Basic algorithm: we look at the first character of the second token, and // determine whether it, if appended to the first token, would form (or @@ -238,11 +238,11 @@ bool TokenConcatenation::AvoidConcat(const Token &PrevPrevTok, if (Tok.is(tok::numeric_constant)) return GetFirstChar(PP, Tok) != '.'; - if (Tok.getIdentifierInfo() || Tok.is(tok::wide_string_literal) || - Tok.is(tok::utf8_string_literal) || Tok.is(tok::utf16_string_literal) || - Tok.is(tok::utf32_string_literal) || Tok.is(tok::wide_char_constant) || - Tok.is(tok::utf8_char_constant) || Tok.is(tok::utf16_char_constant) || - Tok.is(tok::utf32_char_constant)) + if (Tok.getIdentifierInfo() || + Tok.isOneOf(tok::wide_string_literal, tok::utf8_string_literal, + tok::utf16_string_literal, tok::utf32_string_literal, + tok::wide_char_constant, tok::utf8_char_constant, + tok::utf16_char_constant, tok::utf32_char_constant)) return true; // If this isn't identifier + string, we're done. diff --git a/lib/Lex/TokenLexer.cpp b/lib/Lex/TokenLexer.cpp index 83efbab76139..e7512fa2831a 100644 --- a/lib/Lex/TokenLexer.cpp +++ b/lib/Lex/TokenLexer.cpp @@ -185,7 +185,7 @@ void TokenLexer::ExpandFunctionArguments() { if (i != 0 && !Tokens[i-1].is(tok::hashhash) && CurTok.hasLeadingSpace()) NextTokGetsSpace = true; - if (CurTok.is(tok::hash) || CurTok.is(tok::hashat)) { + if (CurTok.isOneOf(tok::hash, tok::hashat)) { int ArgNo = Macro->getArgumentNum(Tokens[i+1].getIdentifierInfo()); assert(ArgNo != -1 && "Token following # is not an argument?"); diff --git a/lib/Parse/ParseCXXInlineMethods.cpp b/lib/Parse/ParseCXXInlineMethods.cpp index 5da70d025e56..ea67a52f1fc1 100644 --- a/lib/Parse/ParseCXXInlineMethods.cpp +++ b/lib/Parse/ParseCXXInlineMethods.cpp @@ -29,8 +29,7 @@ NamedDecl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, const VirtSpecifiers& VS, ExprResult& Init) { assert(D.isFunctionDeclarator() && "This isn't a function declarator!"); - assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try) || - Tok.is(tok::equal)) && + assert(Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try, tok::equal) && "Current token not a '{', ':', '=', or 'try'!"); MultiTemplateParamsArg TemplateParams( @@ -191,7 +190,7 @@ NamedDecl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, /// declaration. Now lex its initializer and store its tokens for parsing /// after the class is complete. void Parser::ParseCXXNonStaticMemberInitializer(Decl *VarD) { - assert((Tok.is(tok::l_brace) || Tok.is(tok::equal)) && + assert(Tok.isOneOf(tok::l_brace, tok::equal) && "Current token not a '{' or '='!"); LateParsedMemberInitializer *MI = @@ -511,7 +510,7 @@ void Parser::ParseLexedMethodDef(LexedMethod &LM) { // Consume the previously pushed token. ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); - assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) + assert(Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try) && "Inline method not starting with '{', ':' or 'try'"); // Parse the method body. Function body parsing code is similar enough @@ -826,7 +825,7 @@ bool Parser::ConsumeAndStoreFunctionPrologue(CachedTokens &Toks) { } } - if (Tok.is(tok::identifier) || Tok.is(tok::kw_template)) { + if (Tok.isOneOf(tok::identifier, tok::kw_template)) { Toks.push_back(Tok); ConsumeToken(); } else if (Tok.is(tok::code_completion)) { diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp index bd114d7e34a7..1c52552ea15d 100644 --- a/lib/Parse/ParseDecl.cpp +++ b/lib/Parse/ParseDecl.cpp @@ -285,7 +285,7 @@ unsigned Parser::ParseAttributeArgsCommon( if (AttrKind == AttributeList::UnknownAttribute || AttrKind == AttributeList::IgnoredAttribute) { const Token &Next = NextToken(); - IsIdentifierArg = Next.is(tok::r_paren) || Next.is(tok::comma); + IsIdentifierArg = Next.isOneOf(tok::r_paren, tok::comma); } if (IsIdentifierArg) @@ -687,6 +687,28 @@ void Parser::ParseOpenCLQualifiers(ParsedAttributes &Attrs) { AttributeList::AS_Keyword); } +void Parser::ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs) { + // Treat these like attributes, even though they're type specifiers. + while (true) { + switch (Tok.getKind()) { + case tok::kw___nonnull: + case tok::kw___nullable: + case tok::kw___null_unspecified: { + IdentifierInfo *AttrName = Tok.getIdentifierInfo(); + SourceLocation AttrNameLoc = ConsumeToken(); + if (!getLangOpts().ObjC1) + Diag(AttrNameLoc, diag::ext_nullability) + << AttrName; + attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0, + AttributeList::AS_Keyword); + break; + } + default: + return; + } + } +} + static bool VersionNumberSeparator(const char Separator) { return (Separator == '.' || Separator == '_'); } @@ -1599,7 +1621,7 @@ void Parser::SkipMalformedDecl() { // a malformed class or function definition or similar. ConsumeBrace(); SkipUntil(tok::r_brace); - if (Tok.is(tok::comma) || Tok.is(tok::l_brace) || Tok.is(tok::kw_try)) { + if (Tok.isOneOf(tok::comma, tok::l_brace, tok::kw_try)) { // This declaration isn't over yet. Keep skipping. continue; } @@ -1705,7 +1727,7 @@ Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS, // and we don't have any other declarators in this declaration. bool Fixit = !DS.setFunctionSpecNoreturn(Loc, PrevSpec, DiagID); MaybeParseGNUAttributes(D, &LateParsedAttrs); - Fixit &= Tok.is(tok::semi) || Tok.is(tok::l_brace) || Tok.is(tok::kw_try); + Fixit &= Tok.isOneOf(tok::semi, tok::l_brace, tok::kw_try); Diag(Loc, diag::err_c11_noreturn_misplaced) << (Fixit ? FixItHint::CreateRemoval(Loc) : FixItHint()) @@ -2176,9 +2198,9 @@ void Parser::ParseSpecifierQualifierList(DeclSpec &DS, AccessSpecifier AS, /// int (x) /// static bool isValidAfterIdentifierInDeclarator(const Token &T) { - return T.is(tok::l_square) || T.is(tok::l_paren) || T.is(tok::r_paren) || - T.is(tok::semi) || T.is(tok::comma) || T.is(tok::equal) || - T.is(tok::kw_asm) || T.is(tok::l_brace) || T.is(tok::colon); + return T.isOneOf(tok::l_square, tok::l_paren, tok::r_paren, tok::semi, + tok::comma, tok::equal, tok::kw_asm, tok::l_brace, + tok::colon); } @@ -2438,7 +2460,7 @@ ExprResult Parser::ParseAlignArgument(SourceLocation Start, /// [C++11] 'alignas' '(' assignment-expression ...[opt] ')' void Parser::ParseAlignmentSpecifier(ParsedAttributes &Attrs, SourceLocation *EndLoc) { - assert((Tok.is(tok::kw_alignas) || Tok.is(tok::kw__Alignas)) && + assert(Tok.isOneOf(tok::kw_alignas, tok::kw__Alignas) && "Not an alignment-specifier!"); IdentifierInfo *KWName = Tok.getIdentifierInfo(); @@ -2481,8 +2503,8 @@ Parser::DiagnoseMissingSemiAfterTagDefinition(DeclSpec &DS, AccessSpecifier AS, bool EnteringContext = (DSContext == DSC_class || DSContext == DSC_top_level); if (getLangOpts().CPlusPlus && - (Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || - Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id)) && + Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_decltype, + tok::annot_template_id) && TryAnnotateCXXScopeToken(EnteringContext)) { SkipMalformedDecl(); return true; @@ -2495,7 +2517,7 @@ Parser::DiagnoseMissingSemiAfterTagDefinition(DeclSpec &DS, AccessSpecifier AS, // Determine whether the following tokens could possibly be a // declarator. bool MightBeDeclarator = true; - if (Tok.is(tok::kw_typename) || Tok.is(tok::annot_typename)) { + if (Tok.isOneOf(tok::kw_typename, tok::annot_typename)) { // A declarator-id can't start with 'typename'. MightBeDeclarator = false; } else if (AfterScope.is(tok::annot_template_id)) { @@ -2510,9 +2532,8 @@ Parser::DiagnoseMissingSemiAfterTagDefinition(DeclSpec &DS, AccessSpecifier AS, // These tokens cannot come after the declarator-id in a // simple-declaration, and are likely to come after a type-specifier. - if (Next.is(tok::star) || Next.is(tok::amp) || Next.is(tok::ampamp) || - Next.is(tok::identifier) || Next.is(tok::annot_cxxscope) || - Next.is(tok::coloncolon)) { + if (Next.isOneOf(tok::star, tok::amp, tok::ampamp, tok::identifier, + tok::annot_cxxscope, tok::coloncolon)) { // Missing a semicolon. MightBeDeclarator = false; } else if (HasScope) { @@ -2920,6 +2941,19 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS, if (DS.isTypeAltiVecVector()) goto DoneWithDeclSpec; + if (DSContext == DSC_objc_method_result && isObjCInstancetype()) { + ParsedType TypeRep = Actions.ActOnObjCInstanceType(Loc); + assert(TypeRep); + isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, + DiagID, TypeRep, Policy); + if (isInvalid) + break; + + DS.SetRangeEnd(Loc); + ConsumeToken(); + continue; + } + ParsedType TypeRep = Actions.getTypeName(*Tok.getIdentifierInfo(), Tok.getLocation(), getCurScope()); @@ -3041,6 +3075,13 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS, ParseOpenCLAttributes(DS.getAttributes()); continue; + // Nullability type specifiers. + case tok::kw___nonnull: + case tok::kw___nullable: + case tok::kw___null_unspecified: + ParseNullabilityTypeSpecifiers(DS.getAttributes()); + continue; + // storage-class-specifier case tok::kw_typedef: isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_typedef, Loc, @@ -3654,7 +3695,7 @@ void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS, bool IsScopedUsingClassTag = false; // In C++11, recognize 'enum class' and 'enum struct'. - if (Tok.is(tok::kw_class) || Tok.is(tok::kw_struct)) { + if (Tok.isOneOf(tok::kw_class, tok::kw_struct)) { Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_scoped_enum : diag::ext_scoped_enum); IsScopedUsingClassTag = Tok.is(tok::kw_class); @@ -4285,6 +4326,10 @@ bool Parser::isTypeSpecifierQualifier() { case tok::kw___pascal: case tok::kw___unaligned: + case tok::kw___nonnull: + case tok::kw___nullable: + case tok::kw___null_unspecified: + case tok::kw___private: case tok::kw___local: case tok::kw___global: @@ -4458,6 +4503,10 @@ bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) { case tok::kw___pascal: case tok::kw___unaligned: + case tok::kw___nonnull: + case tok::kw___nullable: + case tok::kw___null_unspecified: + case tok::kw___private: case tok::kw___local: case tok::kw___global: @@ -4483,7 +4532,7 @@ bool Parser::isConstructorDeclarator(bool IsUnqualified) { } // Parse the constructor name. - if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id)) { + if (Tok.isOneOf(tok::identifier, tok::annot_template_id)) { // We already know that we have a constructor name; just consume // the token. ConsumeToken(); @@ -4687,6 +4736,14 @@ void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, unsigned AttrReqs, continue; } goto DoneWithTypeQuals; + + // Nullability type specifiers. + case tok::kw___nonnull: + case tok::kw___nullable: + case tok::kw___null_unspecified: + ParseNullabilityTypeSpecifiers(DS.getAttributes()); + continue; + case tok::kw___attribute: if (AttrReqs & AR_GNUAttributesParsedAndRejected) // When GNU attributes are expressly forbidden, diagnose their usage. @@ -5041,8 +5098,8 @@ void Parser::ParseDirectDeclarator(Declarator &D) { // the l_paren token. } - if (Tok.is(tok::identifier) || Tok.is(tok::kw_operator) || - Tok.is(tok::annot_template_id) || Tok.is(tok::tilde)) { + if (Tok.isOneOf(tok::identifier, tok::kw_operator, tok::annot_template_id, + tok::tilde)) { // We found something that indicates the start of an unqualified-id. // Parse that unqualified-id. bool AllowConstructorName; @@ -5145,7 +5202,7 @@ void Parser::ParseDirectDeclarator(Declarator &D) { << (D.getDeclSpec().isEmpty() ? SourceRange() : D.getDeclSpec().getSourceRange()); } else if (getLangOpts().CPlusPlus) { - if (Tok.is(tok::period) || Tok.is(tok::arrow)) + if (Tok.isOneOf(tok::period, tok::arrow)) Diag(Tok, diag::err_invalid_operator_on_type) << Tok.is(tok::arrow); else { SourceLocation Loc = D.getCXXScopeSpec().getEndLoc(); @@ -5521,7 +5578,7 @@ void Parser::ParseFunctionDeclarator(Declarator &D, /// true if a ref-qualifier is found. bool Parser::ParseRefQualifier(bool &RefQualifierIsLValueRef, SourceLocation &RefQualifierLoc) { - if (Tok.is(tok::amp) || Tok.is(tok::ampamp)) { + if (Tok.isOneOf(tok::amp, tok::ampamp)) { Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_ref_qualifier : diag::ext_ref_qualifier); diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp index 53e4a419682e..47778b856dda 100644 --- a/lib/Parse/ParseDeclCXX.cpp +++ b/lib/Parse/ParseDeclCXX.cpp @@ -685,7 +685,7 @@ Decl *Parser::ParseUsingDeclaration(unsigned Context, /// _Static_assert ( constant-expression , string-literal ) ; /// Decl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd){ - assert((Tok.is(tok::kw_static_assert) || Tok.is(tok::kw__Static_assert)) && + assert(Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert) && "Not a static_assert declaration"); if (Tok.is(tok::kw__Static_assert) && !getLangOpts().C11) @@ -753,7 +753,7 @@ Decl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd){ /// 'decltype' ( 'auto' ) [C++1y] /// SourceLocation Parser::ParseDecltypeSpecifier(DeclSpec &DS) { - assert((Tok.is(tok::kw_decltype) || Tok.is(tok::annot_decltype)) + assert(Tok.isOneOf(tok::kw_decltype, tok::annot_decltype) && "Not a decltype specifier"); ExprResult Result; @@ -943,7 +943,7 @@ TypeResult Parser::ParseBaseTypeSpecifier(SourceLocation &BaseLoc, // Parse decltype-specifier // tok == kw_decltype is just error recovery, it can only happen when SS // isn't empty - if (Tok.is(tok::kw_decltype) || Tok.is(tok::annot_decltype)) { + if (Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)) { if (SS.isNotEmpty()) Diag(SS.getBeginLoc(), diag::err_unexpected_scope_on_base_decltype) << FixItHint::CreateRemoval(SS.getRange()); @@ -1058,9 +1058,9 @@ TypeResult Parser::ParseBaseTypeSpecifier(SourceLocation &BaseLoc, } void Parser::ParseMicrosoftInheritanceClassAttributes(ParsedAttributes &attrs) { - while (Tok.is(tok::kw___single_inheritance) || - Tok.is(tok::kw___multiple_inheritance) || - Tok.is(tok::kw___virtual_inheritance)) { + while (Tok.isOneOf(tok::kw___single_inheritance, + tok::kw___multiple_inheritance, + tok::kw___virtual_inheritance)) { IdentifierInfo *AttrName = Tok.getIdentifierInfo(); SourceLocation AttrNameLoc = ConsumeToken(); attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0, @@ -1232,9 +1232,9 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind, MaybeParseMicrosoftDeclSpecs(attrs); // Parse inheritance specifiers. - if (Tok.is(tok::kw___single_inheritance) || - Tok.is(tok::kw___multiple_inheritance) || - Tok.is(tok::kw___virtual_inheritance)) + if (Tok.isOneOf(tok::kw___single_inheritance, + tok::kw___multiple_inheritance, + tok::kw___virtual_inheritance)) ParseMicrosoftInheritanceClassAttributes(attrs); // If C++0x attributes exist here, parse them. @@ -1250,55 +1250,55 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind, Tok.isNot(tok::identifier) && !Tok.isAnnotation() && Tok.getIdentifierInfo() && - (Tok.is(tok::kw___is_abstract) || - Tok.is(tok::kw___is_arithmetic) || - Tok.is(tok::kw___is_array) || - Tok.is(tok::kw___is_base_of) || - Tok.is(tok::kw___is_class) || - Tok.is(tok::kw___is_complete_type) || - Tok.is(tok::kw___is_compound) || - Tok.is(tok::kw___is_const) || - Tok.is(tok::kw___is_constructible) || - Tok.is(tok::kw___is_convertible) || - Tok.is(tok::kw___is_convertible_to) || - Tok.is(tok::kw___is_destructible) || - Tok.is(tok::kw___is_empty) || - Tok.is(tok::kw___is_enum) || - Tok.is(tok::kw___is_floating_point) || - Tok.is(tok::kw___is_final) || - Tok.is(tok::kw___is_function) || - Tok.is(tok::kw___is_fundamental) || - Tok.is(tok::kw___is_integral) || - Tok.is(tok::kw___is_interface_class) || - Tok.is(tok::kw___is_literal) || - Tok.is(tok::kw___is_lvalue_expr) || - Tok.is(tok::kw___is_lvalue_reference) || - Tok.is(tok::kw___is_member_function_pointer) || - Tok.is(tok::kw___is_member_object_pointer) || - Tok.is(tok::kw___is_member_pointer) || - Tok.is(tok::kw___is_nothrow_assignable) || - Tok.is(tok::kw___is_nothrow_constructible) || - Tok.is(tok::kw___is_nothrow_destructible) || - Tok.is(tok::kw___is_object) || - Tok.is(tok::kw___is_pod) || - Tok.is(tok::kw___is_pointer) || - Tok.is(tok::kw___is_polymorphic) || - Tok.is(tok::kw___is_reference) || - Tok.is(tok::kw___is_rvalue_expr) || - Tok.is(tok::kw___is_rvalue_reference) || - Tok.is(tok::kw___is_same) || - Tok.is(tok::kw___is_scalar) || - Tok.is(tok::kw___is_sealed) || - Tok.is(tok::kw___is_signed) || - Tok.is(tok::kw___is_standard_layout) || - Tok.is(tok::kw___is_trivial) || - Tok.is(tok::kw___is_trivially_assignable) || - Tok.is(tok::kw___is_trivially_constructible) || - Tok.is(tok::kw___is_trivially_copyable) || - Tok.is(tok::kw___is_union) || - Tok.is(tok::kw___is_unsigned) || - Tok.is(tok::kw___is_void) || - Tok.is(tok::kw___is_volatile))) + Tok.isOneOf(tok::kw___is_abstract, + tok::kw___is_arithmetic, + tok::kw___is_array, + tok::kw___is_base_of, + tok::kw___is_class, + tok::kw___is_complete_type, + tok::kw___is_compound, + tok::kw___is_const, + tok::kw___is_constructible, + tok::kw___is_convertible, + tok::kw___is_convertible_to, + tok::kw___is_destructible, + tok::kw___is_empty, + tok::kw___is_enum, + tok::kw___is_floating_point, + tok::kw___is_final, + tok::kw___is_function, + tok::kw___is_fundamental, + tok::kw___is_integral, + tok::kw___is_interface_class, + tok::kw___is_literal, + tok::kw___is_lvalue_expr, + tok::kw___is_lvalue_reference, + tok::kw___is_member_function_pointer, + tok::kw___is_member_object_pointer, + tok::kw___is_member_pointer, + tok::kw___is_nothrow_assignable, + tok::kw___is_nothrow_constructible, + tok::kw___is_nothrow_destructible, + tok::kw___is_object, + tok::kw___is_pod, + tok::kw___is_pointer, + tok::kw___is_polymorphic, + tok::kw___is_reference, + tok::kw___is_rvalue_expr, + tok::kw___is_rvalue_reference, + tok::kw___is_same, + tok::kw___is_scalar, + tok::kw___is_sealed, + tok::kw___is_signed, + tok::kw___is_standard_layout, + tok::kw___is_trivial, + tok::kw___is_trivially_assignable, + tok::kw___is_trivially_constructible, + tok::kw___is_trivially_copyable, + tok::kw___is_union, + tok::kw___is_unsigned, + tok::kw___is_void, + tok::kw___is_volatile)) // GNU libstdc++ 4.2 and libc++ use certain intrinsic names as the // name of struct templates, but some are keywords in GCC >= 4.3 // and Clang. Therefore, when we see the token sequence "struct @@ -1476,7 +1476,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind, } } - if (Tok.is(tok::l_brace) || Tok.is(tok::colon)) + if (Tok.isOneOf(tok::l_brace, tok::colon)) TUK = Sema::TUK_Definition; else TUK = Sema::TUK_Reference; @@ -2220,8 +2220,7 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, // Access declarations. bool MalformedTypeSpec = false; if (!TemplateInfo.Kind && - (Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || - Tok.is(tok::kw___super))) { + Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw___super)) { if (TryAnnotateCXXScopeToken()) MalformedTypeSpec = true; @@ -2274,7 +2273,7 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, // static_assert-declaration. A templated static_assert declaration is // diagnosed in Parser::ParseSingleDeclarationAfterTemplate. if (!TemplateInfo.Kind && - (Tok.is(tok::kw_static_assert) || Tok.is(tok::kw__Static_assert))) { + Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert)) { SourceLocation DeclEnd; ParseStaticAssertDeclaration(DeclEnd); return; @@ -2411,7 +2410,7 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, if (Tok.is(tok::l_brace) && !getLangOpts().CPlusPlus11) { DefinitionKind = FDK_Definition; } else if (DeclaratorInfo.isFunctionDeclarator()) { - if (Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) { + if (Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try)) { DefinitionKind = FDK_Definition; } else if (Tok.is(tok::equal)) { const Token &KW = NextToken(); @@ -2480,7 +2479,7 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, while (1) { InClassInitStyle HasInClassInit = ICIS_NoInit; - if ((Tok.is(tok::equal) || Tok.is(tok::l_brace)) && !HasInitializer) { + if (Tok.isOneOf(tok::equal, tok::l_brace) && !HasInitializer) { if (BitfieldSize.get()) { Diag(Tok, diag::err_bitfield_member_init); SkipUntil(tok::comma, StopAtSemi | StopBeforeMatch); @@ -2657,7 +2656,7 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, /// be a constant-expression. ExprResult Parser::ParseCXXMemberInitializer(Decl *D, bool IsFunction, SourceLocation &EqualLoc) { - assert((Tok.is(tok::equal) || Tok.is(tok::l_brace)) + assert(Tok.isOneOf(tok::equal, tok::l_brace) && "Data member initializer not starting with '=' or '{'"); EnterExpressionEvaluationContext Context(Actions, @@ -2671,8 +2670,7 @@ ExprResult Parser::ParseCXXMemberInitializer(Decl *D, bool IsFunction, // An initializer of '= delete p, foo' will never be parsed, because // a top-level comma always ends the initializer expression. const Token &Next = NextToken(); - if (IsFunction || Next.is(tok::semi) || Next.is(tok::comma) || - Next.is(tok::eof)) { + if (IsFunction || Next.isOneOf(tok::semi, tok::comma, tok::eof)) { if (IsFunction) Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration) << 1 /* delete */; @@ -2724,12 +2722,13 @@ void Parser::SkipCXXMemberSpecification(SourceLocation RecordLoc, ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope); ParsingClassDefinition ParsingDef(*this, TagDecl, /*NonNestedClass*/ true, TagType == DeclSpec::TST_interface); - Actions.ActOnTagStartSkippedDefinition(getCurScope(), TagDecl); + auto OldContext = + Actions.ActOnTagStartSkippedDefinition(getCurScope(), TagDecl); // Parse the bases but don't attach them to the class. ParseBaseClause(nullptr); - Actions.ActOnTagFinishSkippedDefinition(); + Actions.ActOnTagFinishSkippedDefinition(OldContext); if (!Tok.is(tok::l_brace)) { Diag(PP.getLocForEndOfToken(PrevTokLocation), @@ -2915,8 +2914,8 @@ void Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc, while (Tok.isNot(tok::r_brace) && !isEofOrEom()) { // Each iteration of this loop reads one member-declaration. - if (getLangOpts().MicrosoftExt && (Tok.is(tok::kw___if_exists) || - Tok.is(tok::kw___if_not_exists))) { + if (getLangOpts().MicrosoftExt && Tok.isOneOf(tok::kw___if_exists, + tok::kw___if_not_exists)) { ParseMicrosoftIfExistsClassDeclaration((DeclSpec::TST)TagType, CurAS); continue; } @@ -3127,7 +3126,7 @@ void Parser::ParseConstructorInitializer(Decl *ConstructorDecl) { break; // If the next token looks like a base or member initializer, assume that // we're just missing a comma. - else if (Tok.is(tok::identifier) || Tok.is(tok::coloncolon)) { + else if (Tok.isOneOf(tok::identifier, tok::coloncolon)) { SourceLocation Loc = PP.getLocForEndOfToken(PrevTokLocation); Diag(Loc, diag::err_ctor_init_missing_comma) << FixItHint::CreateInsertion(Loc, ", "); @@ -3779,7 +3778,7 @@ SourceLocation Parser::SkipCXX11Attributes() { return EndLoc; } -/// ParseMicrosoftAttributes - Parse a Microsoft attribute [Attr] +/// Parse one or more Microsoft-style attributes [Attr] /// /// [MS] ms-attribute: /// '[' token-seq ']' @@ -3791,13 +3790,17 @@ void Parser::ParseMicrosoftAttributes(ParsedAttributes &attrs, SourceLocation *endLoc) { assert(Tok.is(tok::l_square) && "Not a Microsoft attribute list"); - while (Tok.is(tok::l_square)) { + do { // FIXME: If this is actually a C++11 attribute, parse it as one. - ConsumeBracket(); + BalancedDelimiterTracker T(*this, tok::l_square); + T.consumeOpen(); + if (Tok.is(tok::r_square)) + Diag(T.getOpenLocation(), diag::err_empty_attribute_block); SkipUntil(tok::r_square, StopAtSemi | StopBeforeMatch); - if (endLoc) *endLoc = Tok.getLocation(); - ExpectAndConsume(tok::r_square); - } + T.consumeClose(); + if (endLoc) + *endLoc = T.getCloseLocation(); + } while (Tok.is(tok::l_square)); } void Parser::ParseMicrosoftIfExistsClassDeclaration(DeclSpec::TST TagType, @@ -3829,7 +3832,7 @@ void Parser::ParseMicrosoftIfExistsClassDeclaration(DeclSpec::TST TagType, while (Tok.isNot(tok::r_brace) && !isEofOrEom()) { // __if_exists, __if_not_exists can nest. - if ((Tok.is(tok::kw___if_exists) || Tok.is(tok::kw___if_not_exists))) { + if (Tok.isOneOf(tok::kw___if_exists, tok::kw___if_not_exists)) { ParseMicrosoftIfExistsClassDeclaration((DeclSpec::TST)TagType, CurAS); continue; } diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp index 95a28a8d5a14..da759c76522c 100644 --- a/lib/Parse/ParseExpr.cpp +++ b/lib/Parse/ParseExpr.cpp @@ -470,8 +470,7 @@ class CastExpressionIdValidator : public CorrectionCandidateCallback { if (!AllowNonTypes || !CorrectionCandidateCallback::ValidateCandidate(candidate)) return false; - if (!(NextToken.is(tok::equal) || NextToken.is(tok::arrow) || - NextToken.is(tok::period))) + if (!NextToken.isOneOf(tok::equal, tok::arrow, tok::period)) return true; for (auto *C : candidate) { @@ -829,11 +828,9 @@ ExprResult Parser::ParseCastExpression(bool isUnaryExpression, } } - if (Next.is(tok::coloncolon) || - (!ColonIsSacred && Next.is(tok::colon)) || - Next.is(tok::less) || - Next.is(tok::l_paren) || - Next.is(tok::l_brace)) { + if ((!ColonIsSacred && Next.is(tok::colon)) || + Next.isOneOf(tok::coloncolon, tok::less, tok::l_paren, + tok::l_brace)) { // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse. if (TryAnnotateTypeOrScopeToken()) return ExprError(); @@ -931,7 +928,7 @@ ExprResult Parser::ParseCastExpression(bool isUnaryExpression, auto Validator = llvm::make_unique<CastExpressionIdValidator>( Tok, isTypeCast != NotTypeCast, isTypeCast != IsTypeCast); Validator->IsAddressOfOperand = isAddressOfOperand; - if (Tok.is(tok::periodstar) || Tok.is(tok::arrowstar)) { + if (Tok.isOneOf(tok::periodstar, tok::arrowstar)) { Validator->WantExpressionKeywords = false; Validator->WantRemainingKeywords = false; } else { @@ -1639,10 +1636,9 @@ Parser::ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok, ParsedType &CastTy, SourceRange &CastRange) { - assert((OpTok.is(tok::kw_typeof) || OpTok.is(tok::kw_sizeof) || - OpTok.is(tok::kw___alignof) || OpTok.is(tok::kw_alignof) || - OpTok.is(tok::kw__Alignof) || OpTok.is(tok::kw_vec_step)) && - "Not a typeof/sizeof/alignof/vec_step expression!"); + assert(OpTok.isOneOf(tok::kw_typeof, tok::kw_sizeof, tok::kw___alignof, + tok::kw_alignof, tok::kw__Alignof, tok::kw_vec_step) && + "Not a typeof/sizeof/alignof/vec_step expression!"); ExprResult Operand; @@ -1650,8 +1646,8 @@ Parser::ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok, if (Tok.isNot(tok::l_paren)) { // If construct allows a form without parenthesis, user may forget to put // pathenthesis around type name. - if (OpTok.is(tok::kw_sizeof) || OpTok.is(tok::kw___alignof) || - OpTok.is(tok::kw_alignof) || OpTok.is(tok::kw__Alignof)) { + if (OpTok.isOneOf(tok::kw_sizeof, tok::kw___alignof, tok::kw_alignof, + tok::kw__Alignof)) { if (isTypeIdUnambiguously()) { DeclSpec DS(AttrFactory); ParseSpecifierQualifierList(DS); @@ -1725,9 +1721,8 @@ Parser::ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok, /// [C++11] 'alignof' '(' type-id ')' /// \endverbatim ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() { - assert((Tok.is(tok::kw_sizeof) || Tok.is(tok::kw___alignof) || - Tok.is(tok::kw_alignof) || Tok.is(tok::kw__Alignof) || - Tok.is(tok::kw_vec_step)) && + assert(Tok.isOneOf(tok::kw_sizeof, tok::kw___alignof, tok::kw_alignof, + tok::kw__Alignof, tok::kw_vec_step) && "Not a sizeof/alignof/vec_step expression!"); Token OpTok = Tok; ConsumeToken(); @@ -1778,7 +1773,7 @@ ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() { RParenLoc); } - if (OpTok.is(tok::kw_alignof) || OpTok.is(tok::kw__Alignof)) + if (OpTok.isOneOf(tok::kw_alignof, tok::kw__Alignof)) Diag(OpTok, diag::warn_cxx98_compat_alignof); EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated, @@ -1793,8 +1788,7 @@ ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() { CastRange); UnaryExprOrTypeTrait ExprKind = UETT_SizeOf; - if (OpTok.is(tok::kw_alignof) || OpTok.is(tok::kw___alignof) || - OpTok.is(tok::kw__Alignof)) + if (OpTok.isOneOf(tok::kw_alignof, tok::kw___alignof, tok::kw__Alignof)) ExprKind = UETT_AlignOf; else if (OpTok.is(tok::kw_vec_step)) ExprKind = UETT_VecStep; @@ -1806,7 +1800,7 @@ ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() { CastTy.getAsOpaquePtr(), CastRange); - if (OpTok.is(tok::kw_alignof) || OpTok.is(tok::kw__Alignof)) + if (OpTok.isOneOf(tok::kw_alignof, tok::kw__Alignof)) Diag(OpTok, diag::ext_alignof_expr) << OpTok.getIdentifierInfo(); // If we get here, the operand to the sizeof/alignof was an expresion. @@ -2107,10 +2101,10 @@ Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr, // Diagnose use of bridge casts in non-arc mode. bool BridgeCast = (getLangOpts().ObjC2 && - (Tok.is(tok::kw___bridge) || - Tok.is(tok::kw___bridge_transfer) || - Tok.is(tok::kw___bridge_retained) || - Tok.is(tok::kw___bridge_retain))); + Tok.isOneOf(tok::kw___bridge, + tok::kw___bridge_transfer, + tok::kw___bridge_retained, + tok::kw___bridge_retain)); if (BridgeCast && !getLangOpts().ObjCAutoRefCount) { if (!TryConsumeToken(tok::kw___bridge)) { StringRef BridgeCastName = Tok.getName(); @@ -2646,9 +2640,6 @@ void Parser::ParseBlockId(SourceLocation CaretLoc) { Declarator DeclaratorInfo(DS, Declarator::BlockLiteralContext); ParseDeclarator(DeclaratorInfo); - // We do this for: ^ __attribute__((noreturn)) {, as DS has the attributes. - DeclaratorInfo.takeAttributes(DS.getAttributes(), SourceLocation()); - MaybeParseGNUAttributes(DeclaratorInfo); // Inform sema that we are starting a block. diff --git a/lib/Parse/ParseExprCXX.cpp b/lib/Parse/ParseExprCXX.cpp index ed9f75d7b4de..7fb4b5e5a07f 100644 --- a/lib/Parse/ParseExprCXX.cpp +++ b/lib/Parse/ParseExprCXX.cpp @@ -254,7 +254,7 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS, } if (!HasScopeSpecifier && - (Tok.is(tok::kw_decltype) || Tok.is(tok::annot_decltype))) { + Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)) { DeclSpec DS(AttrFactory); SourceLocation DeclLoc = Tok.getLocation(); SourceLocation EndLoc = ParseDecltypeSpecifier(DS); @@ -487,7 +487,7 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS, // as the name in a nested-name-specifier. Token Identifier = Tok; SourceLocation IdLoc = ConsumeToken(); - assert((Tok.is(tok::coloncolon) || Tok.is(tok::colon)) && + assert(Tok.isOneOf(tok::coloncolon, tok::colon) && "NextToken() not working properly!"); Token ColonColon = Tok; SourceLocation CCLoc = ConsumeToken(); @@ -892,7 +892,7 @@ Optional<unsigned> Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro, Parens.getCloseLocation(), Exprs); } - } else if (Tok.is(tok::l_brace) || Tok.is(tok::equal)) { + } else if (Tok.isOneOf(tok::l_brace, tok::equal)) { // Each lambda init-capture forms its own full expression, which clears // Actions.MaybeODRUseExprs. So create an expression evaluation context // to save the necessary state, and restore it later. @@ -1159,8 +1159,7 @@ ExprResult Parser::ParseLambdaExpressionAfterIntroducer( LParenLoc, FunLocalRangeEnd, D, TrailingReturnType), Attr, DeclEndLoc); - } else if (Tok.is(tok::kw_mutable) || Tok.is(tok::arrow) || - Tok.is(tok::kw___attribute) || + } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute) || (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) { // It's common to forget that one needs '()' before 'mutable', an attribute // specifier, or the result type. Deal with this. diff --git a/lib/Parse/ParseObjc.cpp b/lib/Parse/ParseObjc.cpp index 691f53f05a8f..e4f7911138de 100644 --- a/lib/Parse/ParseObjc.cpp +++ b/lib/Parse/ParseObjc.cpp @@ -13,6 +13,7 @@ #include "clang/Parse/Parser.h" #include "RAIIObjectsForParser.h" +#include "clang/AST/ASTContext.h" #include "clang/Basic/CharInfo.h" #include "clang/Parse/ParseDiagnostic.h" #include "clang/Sema/DeclSpec.h" @@ -307,6 +308,37 @@ Decl *Parser::ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc, return ClsType; } +/// Add an attribute for a context-sensitive type nullability to the given +/// declarator. +static void addContextSensitiveTypeNullability(Parser &P, + Declarator &D, + NullabilityKind nullability, + SourceLocation nullabilityLoc, + bool &addedToDeclSpec) { + // Create the attribute. + auto getNullabilityAttr = [&]() -> AttributeList * { + return D.getAttributePool().create( + P.getNullabilityKeyword(nullability), + SourceRange(nullabilityLoc), + nullptr, SourceLocation(), + nullptr, 0, + AttributeList::AS_ContextSensitiveKeyword); + }; + + if (D.getNumTypeObjects() > 0) { + // Add the attribute to the declarator chunk nearest the declarator. + auto nullabilityAttr = getNullabilityAttr(); + DeclaratorChunk &chunk = D.getTypeObject(0); + nullabilityAttr->setNext(chunk.getAttrListRef()); + chunk.getAttrListRef() = nullabilityAttr; + } else if (!addedToDeclSpec) { + // Otherwise, just put it on the declaration specifiers (if one + // isn't there already). + D.getMutableDeclSpec().addAttributes(getNullabilityAttr()); + addedToDeclSpec = true; + } +} + /// objc-interface-decl-list: /// empty /// objc-interface-decl-list objc-property-decl [OBJC2] @@ -330,7 +362,7 @@ void Parser::ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey, while (1) { // If this is a method prototype, parse it. - if (Tok.is(tok::minus) || Tok.is(tok::plus)) { + if (Tok.isOneOf(tok::minus, tok::plus)) { if (Decl *methodPrototype = ParseObjCMethodPrototype(MethodImplKind, false)) allMethods.push_back(methodPrototype); @@ -445,6 +477,7 @@ void Parser::ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey, ParseObjCPropertyAttribute(OCDS); } + bool addedToDeclSpec = false; auto ObjCPropertyCallback = [&](ParsingFieldDeclarator &FD) { if (FD.D.getIdentifier() == nullptr) { Diag(AtLoc, diag::err_objc_property_requires_field_name) @@ -457,6 +490,13 @@ void Parser::ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey, return; } + // Map a nullability property attribute to a context-sensitive keyword + // attribute. + if (OCDS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nullability) + addContextSensitiveTypeNullability(*this, FD.D, OCDS.getNullability(), + OCDS.getNullabilityLoc(), + addedToDeclSpec); + // Install the property declarator into interfaceDecl. IdentifierInfo *SelName = OCDS.getGetterName() ? OCDS.getGetterName() : FD.D.getIdentifier(); @@ -510,6 +550,24 @@ void Parser::ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey, Actions.ActOnAtEnd(getCurScope(), AtEnd, allMethods, allTUVariables); } +/// Diagnose redundant or conflicting nullability information. +static void diagnoseRedundantPropertyNullability(Parser &P, + ObjCDeclSpec &DS, + NullabilityKind nullability, + SourceLocation nullabilityLoc){ + if (DS.getNullability() == nullability) { + P.Diag(nullabilityLoc, diag::warn_nullability_duplicate) + << static_cast<unsigned>(nullability) << true + << SourceRange(DS.getNullabilityLoc()); + return; + } + + P.Diag(nullabilityLoc, diag::err_nullability_conflicting) + << static_cast<unsigned>(nullability) << true + << static_cast<unsigned>(DS.getNullability()) << true + << SourceRange(DS.getNullabilityLoc()); +} + /// Parse property attribute declarations. /// /// property-attr-decl: '(' property-attrlist ')' @@ -529,6 +587,10 @@ void Parser::ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey, /// strong /// weak /// unsafe_unretained +/// nonnull +/// nullable +/// null_unspecified +/// null_resettable /// void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec &DS) { assert(Tok.getKind() == tok::l_paren); @@ -614,6 +676,37 @@ void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec &DS) { DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_getter); DS.setGetterName(SelIdent); } + } else if (II->isStr("nonnull")) { + if (DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nullability) + diagnoseRedundantPropertyNullability(*this, DS, + NullabilityKind::NonNull, + Tok.getLocation()); + DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nullability); + DS.setNullability(Tok.getLocation(), NullabilityKind::NonNull); + } else if (II->isStr("nullable")) { + if (DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nullability) + diagnoseRedundantPropertyNullability(*this, DS, + NullabilityKind::Nullable, + Tok.getLocation()); + DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nullability); + DS.setNullability(Tok.getLocation(), NullabilityKind::Nullable); + } else if (II->isStr("null_unspecified")) { + if (DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nullability) + diagnoseRedundantPropertyNullability(*this, DS, + NullabilityKind::Unspecified, + Tok.getLocation()); + DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nullability); + DS.setNullability(Tok.getLocation(), NullabilityKind::Unspecified); + } else if (II->isStr("null_resettable")) { + if (DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nullability) + diagnoseRedundantPropertyNullability(*this, DS, + NullabilityKind::Unspecified, + Tok.getLocation()); + DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nullability); + DS.setNullability(Tok.getLocation(), NullabilityKind::Unspecified); + + // Also set the null_resettable bit. + DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_null_resettable); } else { Diag(AttrName, diag::err_objc_expected_property_attr) << II; SkipUntil(tok::r_paren, StopAtSemi); @@ -641,7 +734,7 @@ void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec &DS) { /// Decl *Parser::ParseObjCMethodPrototype(tok::ObjCKeywordKind MethodImplKind, bool MethodDefinition) { - assert((Tok.is(tok::minus) || Tok.is(tok::plus)) && "expected +/-"); + assert(Tok.isOneOf(tok::minus, tok::plus) && "expected +/-"); tok::TokenKind methodType = Tok.getKind(); SourceLocation mLoc = ConsumeToken(); @@ -779,6 +872,17 @@ bool Parser::isTokIdentifier_in() const { /// objc-type-qualifier /// objc-type-qualifiers objc-type-qualifier /// +/// objc-type-qualifier: +/// 'in' +/// 'out' +/// 'inout' +/// 'oneway' +/// 'bycopy' +/// 'byref' +/// 'nonnull' +/// 'nullable' +/// 'null_unspecified' +/// void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS, Declarator::TheContext Context) { assert(Context == Declarator::ObjCParameterContext || @@ -796,10 +900,13 @@ void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS, const IdentifierInfo *II = Tok.getIdentifierInfo(); for (unsigned i = 0; i != objc_NumQuals; ++i) { - if (II != ObjCTypeQuals[i]) + if (II != ObjCTypeQuals[i] || + NextToken().is(tok::less) || + NextToken().is(tok::coloncolon)) continue; ObjCDeclSpec::ObjCDeclQualifier Qual; + NullabilityKind Nullability; switch (i) { default: llvm_unreachable("Unknown decl qualifier"); case objc_in: Qual = ObjCDeclSpec::DQ_In; break; @@ -808,8 +915,28 @@ void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS, case objc_oneway: Qual = ObjCDeclSpec::DQ_Oneway; break; case objc_bycopy: Qual = ObjCDeclSpec::DQ_Bycopy; break; case objc_byref: Qual = ObjCDeclSpec::DQ_Byref; break; + + case objc_nonnull: + Qual = ObjCDeclSpec::DQ_CSNullability; + Nullability = NullabilityKind::NonNull; + break; + + case objc_nullable: + Qual = ObjCDeclSpec::DQ_CSNullability; + Nullability = NullabilityKind::Nullable; + break; + + case objc_null_unspecified: + Qual = ObjCDeclSpec::DQ_CSNullability; + Nullability = NullabilityKind::Unspecified; + break; } + + // FIXME: Diagnose redundant specifiers. DS.setObjCDeclQualifier(Qual); + if (Qual == ObjCDeclSpec::DQ_CSNullability) + DS.setNullability(Tok.getLocation(), Nullability); + ConsumeToken(); II = nullptr; break; @@ -878,17 +1005,28 @@ ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS, ParseObjCTypeQualifierList(DS, context); ParsedType Ty; - if (isTypeSpecifierQualifier()) { + if (isTypeSpecifierQualifier() || isObjCInstancetype()) { // Parse an abstract declarator. DeclSpec declSpec(AttrFactory); declSpec.setObjCQualifiers(&DS); - ParseSpecifierQualifierList(declSpec); + DeclSpecContext dsContext = DSC_normal; + if (context == Declarator::ObjCResultContext) + dsContext = DSC_objc_method_result; + ParseSpecifierQualifierList(declSpec, AS_none, dsContext); declSpec.SetRangeEnd(Tok.getLocation()); Declarator declarator(declSpec, context); ParseDeclarator(declarator); // If that's not invalid, extract a type. if (!declarator.isInvalidType()) { + // Map a nullability specifier to a context-sensitive keyword attribute. + bool addedToDeclSpec = false; + if (DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) + addContextSensitiveTypeNullability(*this, declarator, + DS.getNullability(), + DS.getNullabilityLoc(), + addedToDeclSpec); + TypeResult type = Actions.ActOnTypeName(getCurScope(), declarator); if (!type.isInvalid()) Ty = type.get(); @@ -898,15 +1036,6 @@ ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS, if (context == Declarator::ObjCParameterContext) takeDeclAttributes(*paramAttrs, declarator); } - } else if (context == Declarator::ObjCResultContext && - Tok.is(tok::identifier)) { - if (!Ident_instancetype) - Ident_instancetype = PP.getIdentifierInfo("instancetype"); - - if (Tok.getIdentifierInfo() == Ident_instancetype) { - Ty = Actions.ActOnObjCInstanceType(Tok.getLocation()); - ConsumeToken(); - } } if (Tok.is(tok::r_paren)) @@ -1309,6 +1438,7 @@ void Parser::ParseObjCClassInstanceVariables(Decl *interfaceDecl, auto ObjCIvarCallback = [&](ParsingFieldDeclarator &FD) { Actions.ActOnObjCContainerStartDefinition(interfaceDecl); // Install the declarator into the interface decl. + FD.D.setObjCIvar(true); Decl *Field = Actions.ActOnIvar( getCurScope(), FD.D.getDeclSpec().getSourceRange().getBegin(), FD.D, FD.BitfieldSize, visibility); @@ -2170,8 +2300,8 @@ ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) { bool Parser::ParseObjCXXMessageReceiver(bool &IsExpr, void *&TypeOrExpr) { InMessageExpressionRAIIObject InMessage(*this, true); - if (Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || - Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope)) + if (Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_typename, + tok::annot_cxxscope)) TryAnnotateTypeOrScopeToken(); if (!Actions.isSimpleTypeSpecifier(Tok.getKind())) { @@ -2265,7 +2395,7 @@ bool Parser::isStartOfObjCClassMessageMissingOpenBracket() { if (!Type.get().isNull() && Type.get()->isObjCObjectOrInterfaceType()) { const Token &AfterNext = GetLookAheadToken(2); - if (AfterNext.is(tok::colon) || AfterNext.is(tok::r_square)) { + if (AfterNext.isOneOf(tok::colon, tok::r_square)) { if (Tok.is(tok::identifier)) TryAnnotateTypeOrScopeToken(); @@ -2891,9 +3021,8 @@ void Parser::ParseLexedObjCMethodDefs(LexedMethod &LM, bool parseMethod) { // Consume the previously pushed token. ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); - assert((Tok.is(tok::l_brace) || Tok.is(tok::kw_try) || - Tok.is(tok::colon)) && - "Inline objective-c method not starting with '{' or 'try' or ':'"); + assert(Tok.isOneOf(tok::l_brace, tok::kw_try, tok::colon) && + "Inline objective-c method not starting with '{' or 'try' or ':'"); // Enter a scope for the method or c-function body. ParseScope BodyScope(this, parseMethod diff --git a/lib/Parse/ParseOpenMP.cpp b/lib/Parse/ParseOpenMP.cpp index 187289ee637d..a3c3c5dc7d49 100644 --- a/lib/Parse/ParseOpenMP.cpp +++ b/lib/Parse/ParseOpenMP.cpp @@ -94,6 +94,7 @@ Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() { case OMPD_taskyield: case OMPD_barrier: case OMPD_taskwait: + case OMPD_taskgroup: case OMPD_flush: case OMPD_for: case OMPD_for_simd: @@ -128,7 +129,8 @@ Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() { /// 'section' | 'single' | 'master' | 'critical' [ '(' <name> ')' ] | /// 'parallel for' | 'parallel sections' | 'task' | 'taskyield' | /// 'barrier' | 'taskwait' | 'flush' | 'ordered' | 'atomic' | -/// 'for simd' | 'parallel for simd' | 'target' | 'teams' {clause} +/// 'for simd' | 'parallel for simd' | 'target' | 'teams' | 'taskgroup' +/// {clause} /// annot_pragma_openmp_end /// StmtResult @@ -198,7 +200,8 @@ Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) { case OMPD_ordered: case OMPD_atomic: case OMPD_target: - case OMPD_teams: { + case OMPD_teams: + case OMPD_taskgroup: { ConsumeToken(); // Parse directive name of the 'critical' directive if any. if (DKind == OMPD_critical) { diff --git a/lib/Parse/ParsePragma.cpp b/lib/Parse/ParsePragma.cpp index 84256dfd8e31..892d3c6a52ce 100644 --- a/lib/Parse/ParsePragma.cpp +++ b/lib/Parse/ParsePragma.cpp @@ -823,9 +823,11 @@ bool Parser::HandlePragmaLoopHint(LoopHint &Hint) { ConsumeToken(); // The annotation token. SourceLocation StateLoc = Toks[0].getLocation(); IdentifierInfo *StateInfo = Toks[0].getIdentifierInfo(); - if (!StateInfo || ((OptionUnroll ? !StateInfo->isStr("full") - : !StateInfo->isStr("enable")) && - !StateInfo->isStr("disable"))) { + if (!StateInfo || + ((OptionUnroll ? !StateInfo->isStr("full") + : !StateInfo->isStr("enable") && + !StateInfo->isStr("assume_safety")) && + !StateInfo->isStr("disable"))) { Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword) << /*FullKeyword=*/OptionUnroll; return false; @@ -1954,6 +1956,7 @@ static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName, /// loop-hint-keyword: /// 'enable' /// 'disable' +/// 'assume_safety' /// /// unroll-hint-keyword: /// 'full' diff --git a/lib/Parse/ParseStmt.cpp b/lib/Parse/ParseStmt.cpp index 055bdeabf623..b658cef234ec 100644 --- a/lib/Parse/ParseStmt.cpp +++ b/lib/Parse/ParseStmt.cpp @@ -119,15 +119,12 @@ namespace { class StatementFilterCCC : public CorrectionCandidateCallback { public: StatementFilterCCC(Token nextTok) : NextToken(nextTok) { - WantTypeSpecifiers = nextTok.is(tok::l_paren) || nextTok.is(tok::less) || - nextTok.is(tok::identifier) || nextTok.is(tok::star) || - nextTok.is(tok::amp) || nextTok.is(tok::l_square); - WantExpressionKeywords = nextTok.is(tok::l_paren) || - nextTok.is(tok::identifier) || - nextTok.is(tok::arrow) || nextTok.is(tok::period); - WantRemainingKeywords = nextTok.is(tok::l_paren) || nextTok.is(tok::semi) || - nextTok.is(tok::identifier) || - nextTok.is(tok::l_brace); + WantTypeSpecifiers = nextTok.isOneOf(tok::l_paren, tok::less, tok::l_square, + tok::identifier, tok::star, tok::amp); + WantExpressionKeywords = + nextTok.isOneOf(tok::l_paren, tok::identifier, tok::arrow, tok::period); + WantRemainingKeywords = + nextTok.isOneOf(tok::l_paren, tok::semi, tok::identifier, tok::l_brace); WantCXXNamedCasts = false; } @@ -1427,7 +1424,7 @@ bool Parser::isForRangeIdentifier() { if (Next.is(tok::colon)) return true; - if (Next.is(tok::l_square) || Next.is(tok::kw_alignas)) { + if (Next.isOneOf(tok::l_square, tok::kw_alignas)) { TentativeParsingAction PA(*this); ConsumeToken(); SkipCXX11Attributes(); diff --git a/lib/Parse/ParseStmtAsm.cpp b/lib/Parse/ParseStmtAsm.cpp index 8ba9f15f0a40..8cdae6a74b20 100644 --- a/lib/Parse/ParseStmtAsm.cpp +++ b/lib/Parse/ParseStmtAsm.cpp @@ -512,8 +512,8 @@ StmtResult Parser::ParseMicrosoftAsmStatement(SourceLocation AsmLoc) { llvm::SourceMgr TempSrcMgr; llvm::MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &TempSrcMgr); - MOFI->InitMCObjectFileInfo(TT, llvm::Reloc::Default, llvm::CodeModel::Default, - Ctx); + MOFI->InitMCObjectFileInfo(TheTriple, llvm::Reloc::Default, + llvm::CodeModel::Default, Ctx); std::unique_ptr<llvm::MemoryBuffer> Buffer = llvm::MemoryBuffer::getMemBuffer(AsmString, "<MS inline asm>"); diff --git a/lib/Parse/ParseTemplate.cpp b/lib/Parse/ParseTemplate.cpp index f1467fe553a0..a8116785fdfd 100644 --- a/lib/Parse/ParseTemplate.cpp +++ b/lib/Parse/ParseTemplate.cpp @@ -62,7 +62,7 @@ Parser::ParseTemplateDeclarationOrSpecialization(unsigned Context, SourceLocation &DeclEnd, AccessSpecifier AS, AttributeList *AccessAttrs) { - assert((Tok.is(tok::kw_export) || Tok.is(tok::kw_template)) && + assert(Tok.isOneOf(tok::kw_export, tok::kw_template) && "Token does not start a template declaration."); // Enter template-parameter scope. @@ -135,7 +135,7 @@ Parser::ParseTemplateDeclarationOrSpecialization(unsigned Context, } else { LastParamListWasEmpty = true; } - } while (Tok.is(tok::kw_export) || Tok.is(tok::kw_template)); + } while (Tok.isOneOf(tok::kw_export, tok::kw_template)); // Parse the actual template declaration. return ParseSingleDeclarationAfterTemplate(Context, @@ -367,7 +367,7 @@ Parser::ParseTemplateParameterList(unsigned Depth, // Did we find a comma or the end of the template parameter list? if (Tok.is(tok::comma)) { ConsumeToken(); - } else if (Tok.is(tok::greater) || Tok.is(tok::greatergreater)) { + } else if (Tok.isOneOf(tok::greater, tok::greatergreater)) { // Don't consume this... that's done by template parser. break; } else { @@ -484,7 +484,7 @@ Decl *Parser::ParseTemplateParameter(unsigned Depth, unsigned Position) { /// 'typename' ...[opt][C++0x] identifier[opt] /// 'typename' identifier[opt] '=' type-id Decl *Parser::ParseTypeParameter(unsigned Depth, unsigned Position) { - assert((Tok.is(tok::kw_class) || Tok.is(tok::kw_typename)) && + assert(Tok.isOneOf(tok::kw_class, tok::kw_typename) && "A type-parameter starts with 'class' or 'typename'"); // Consume the 'class' or 'typename' keyword. @@ -506,8 +506,8 @@ Decl *Parser::ParseTypeParameter(unsigned Depth, unsigned Position) { if (Tok.is(tok::identifier)) { ParamName = Tok.getIdentifierInfo(); NameLoc = ConsumeToken(); - } else if (Tok.is(tok::equal) || Tok.is(tok::comma) || - Tok.is(tok::greater) || Tok.is(tok::greatergreater)) { + } else if (Tok.isOneOf(tok::equal, tok::comma, tok::greater, + tok::greatergreater)) { // Unnamed template parameter. Don't have to do anything here, just // don't consume this token. } else { @@ -567,7 +567,7 @@ Parser::ParseTemplateTemplateParameter(unsigned Depth, unsigned Position) { // or greater appear immediately or after 'struct'. In the latter case, // replace the keyword with 'class'. if (!TryConsumeToken(tok::kw_class)) { - bool Replace = Tok.is(tok::kw_typename) || Tok.is(tok::kw_struct); + bool Replace = Tok.isOneOf(tok::kw_typename, tok::kw_struct); const Token &Next = Tok.is(tok::kw_struct) ? NextToken() : Tok; if (Tok.is(tok::kw_typename)) { Diag(Tok.getLocation(), @@ -577,9 +577,8 @@ Parser::ParseTemplateTemplateParameter(unsigned Depth, unsigned Position) { << (!getLangOpts().CPlusPlus1z ? FixItHint::CreateReplacement(Tok.getLocation(), "class") : FixItHint()); - } else if (Next.is(tok::identifier) || Next.is(tok::comma) || - Next.is(tok::greater) || Next.is(tok::greatergreater) || - Next.is(tok::ellipsis)) { + } else if (Next.isOneOf(tok::identifier, tok::comma, tok::greater, + tok::greatergreater, tok::ellipsis)) { Diag(Tok.getLocation(), diag::err_class_on_template_template_param) << (Replace ? FixItHint::CreateReplacement(Tok.getLocation(), "class") : FixItHint::CreateInsertion(Tok.getLocation(), "class ")); @@ -604,8 +603,8 @@ Parser::ParseTemplateTemplateParameter(unsigned Depth, unsigned Position) { if (Tok.is(tok::identifier)) { ParamName = Tok.getIdentifierInfo(); NameLoc = ConsumeToken(); - } else if (Tok.is(tok::equal) || Tok.is(tok::comma) || - Tok.is(tok::greater) || Tok.is(tok::greatergreater)) { + } else if (Tok.isOneOf(tok::equal, tok::comma, tok::greater, + tok::greatergreater)) { // Unnamed template parameter. Don't have to do anything here, just // don't consume this token. } else { @@ -794,16 +793,15 @@ bool Parser::ParseGreaterThanInTemplateList(SourceLocation &RAngleLoc, Token Next = NextToken(); if ((RemainingToken == tok::greater || RemainingToken == tok::greatergreater) && - (Next.is(tok::greater) || Next.is(tok::greatergreater) || - Next.is(tok::greatergreatergreater) || Next.is(tok::equal) || - Next.is(tok::greaterequal) || Next.is(tok::greatergreaterequal) || - Next.is(tok::equalequal)) && + Next.isOneOf(tok::greater, tok::greatergreater, + tok::greatergreatergreater, tok::equal, tok::greaterequal, + tok::greatergreaterequal, tok::equalequal) && areTokensAdjacent(Tok, Next)) Hint2 = FixItHint::CreateInsertion(Next.getLocation(), " "); unsigned DiagId = diag::err_two_right_angle_brackets_need_space; if (getLangOpts().CPlusPlus11 && - (Tok.is(tok::greatergreater) || Tok.is(tok::greatergreatergreater))) + Tok.isOneOf(tok::greatergreater, tok::greatergreatergreater)) DiagId = diag::warn_cxx98_compat_two_right_angle_brackets; else if (Tok.is(tok::greaterequal)) DiagId = diag::err_right_angle_bracket_equal_needs_space; @@ -1055,8 +1053,7 @@ void Parser::AnnotateTemplateIdTokenAsType() { /// \brief Determine whether the given token can end a template argument. static bool isEndOfTemplateArgument(Token Tok) { - return Tok.is(tok::comma) || Tok.is(tok::greater) || - Tok.is(tok::greatergreater); + return Tok.isOneOf(tok::comma, tok::greater, tok::greatergreater); } /// \brief Parse a C++ template template argument. @@ -1217,7 +1214,7 @@ bool Parser::IsTemplateArgumentList(unsigned Skip) { ConsumeToken(); // If we have a '>' or a ',' then this is a template argument list. - return Tok.is(tok::greater) || Tok.is(tok::comma); + return Tok.isOneOf(tok::greater, tok::comma); } /// ParseTemplateArgumentList - Parse a C++ template-argument-list @@ -1339,8 +1336,8 @@ void Parser::ParseLateTemplatedFuncDef(LateParsedTemplate &LPT) { // Consume the previously pushed token. ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); - assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) - && "Inline method not starting with '{', ':' or 'try'"); + assert(Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try) && + "Inline method not starting with '{', ':' or 'try'"); // Parse the method body. Function body parsing code is similar enough // to be re-used for method bodies as well. diff --git a/lib/Parse/ParseTentative.cpp b/lib/Parse/ParseTentative.cpp index abf16fa6222b..d63cf24bcdb9 100644 --- a/lib/Parse/ParseTentative.cpp +++ b/lib/Parse/ParseTentative.cpp @@ -179,8 +179,8 @@ Parser::TPResult Parser::TryConsumeDeclarationSpecifier() { ConsumeToken(); // Skip attributes. - while (Tok.is(tok::l_square) || Tok.is(tok::kw___attribute) || - Tok.is(tok::kw___declspec) || Tok.is(tok::kw_alignas)) { + while (Tok.isOneOf(tok::l_square, tok::kw___attribute, tok::kw___declspec, + tok::kw_alignas)) { if (Tok.is(tok::l_square)) { ConsumeBracket(); if (!SkipUntil(tok::r_square)) @@ -195,8 +195,8 @@ Parser::TPResult Parser::TryConsumeDeclarationSpecifier() { } } - if ((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || - Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id)) && + if (Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_decltype, + tok::annot_template_id) && TryAnnotateCXXScopeToken()) return TPResult::Error; if (Tok.is(tok::annot_cxxscope)) @@ -289,7 +289,7 @@ Parser::TPResult Parser::TryParseInitDeclaratorList() { return TPR; // [GNU] simple-asm-expr[opt] attributes[opt] - if (Tok.is(tok::kw_asm) || Tok.is(tok::kw___attribute)) + if (Tok.isOneOf(tok::kw_asm, tok::kw___attribute)) return TPResult::True; // initializer[opt] @@ -370,8 +370,7 @@ bool Parser::isCXXConditionDeclaration() { if (TPR == TPResult::Ambiguous) { // '=' // [GNU] simple-asm-expr[opt] attributes[opt] - if (Tok.is(tok::equal) || - Tok.is(tok::kw_asm) || Tok.is(tok::kw___attribute)) + if (Tok.isOneOf(tok::equal, tok::kw_asm, tok::kw___attribute)) TPR = TPResult::True; else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) TPR = TPResult::True; @@ -448,7 +447,7 @@ bool Parser::isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous) { // the abstract declarator we encounter a '>', '>>' (in C++0x), or // ',', this is a type-id. Otherwise, it's an expression. } else if (Context == TypeIdAsTemplateArgument && - (Tok.is(tok::greater) || Tok.is(tok::comma) || + (Tok.isOneOf(tok::greater, tok::comma) || (getLangOpts().CPlusPlus11 && Tok.is(tok::greatergreater)))) { TPR = TPResult::True; isAmbiguous = true; @@ -624,18 +623,17 @@ Parser::isCXX11AttributeSpecifier(bool Disambiguate, Parser::TPResult Parser::TryParsePtrOperatorSeq() { while (true) { - if (Tok.is(tok::coloncolon) || Tok.is(tok::identifier)) + if (Tok.isOneOf(tok::coloncolon, tok::identifier)) if (TryAnnotateCXXScopeToken(true)) return TPResult::Error; - if (Tok.is(tok::star) || Tok.is(tok::amp) || Tok.is(tok::caret) || - Tok.is(tok::ampamp) || + if (Tok.isOneOf(tok::star, tok::amp, tok::caret, tok::ampamp) || (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::star))) { // ptr-operator ConsumeToken(); - while (Tok.is(tok::kw_const) || - Tok.is(tok::kw_volatile) || - Tok.is(tok::kw_restrict)) + while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict, + tok::kw___nonnull, tok::kw___nullable, + tok::kw___null_unspecified)) ConsumeToken(); } else { return TPResult::True; @@ -803,7 +801,7 @@ Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract, if (Tok.is(tok::ellipsis)) ConsumeToken(); - if ((Tok.is(tok::identifier) || Tok.is(tok::kw_operator) || + if ((Tok.isOneOf(tok::identifier, tok::kw_operator) || (Tok.is(tok::annot_cxxscope) && (NextToken().is(tok::identifier) || NextToken().is(tok::kw_operator)))) && mayHaveIdentifier) { @@ -833,14 +831,9 @@ Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract, // '(' declarator ')' // '(' attributes declarator ')' // '(' abstract-declarator ')' - if (Tok.is(tok::kw___attribute) || - Tok.is(tok::kw___declspec) || - Tok.is(tok::kw___cdecl) || - Tok.is(tok::kw___stdcall) || - Tok.is(tok::kw___fastcall) || - Tok.is(tok::kw___thiscall) || - Tok.is(tok::kw___vectorcall) || - Tok.is(tok::kw___unaligned)) + if (Tok.isOneOf(tok::kw___attribute, tok::kw___declspec, tok::kw___cdecl, + tok::kw___stdcall, tok::kw___fastcall, tok::kw___thiscall, + tok::kw___vectorcall, tok::kw___unaligned)) return TPResult::True; // attributes indicate declaration TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier); if (TPR != TPResult::Ambiguous) @@ -1015,9 +1008,8 @@ class TentativeParseCCC : public CorrectionCandidateCallback { public: TentativeParseCCC(const Token &Next) { WantRemainingKeywords = false; - WantTypeSpecifiers = Next.is(tok::l_paren) || Next.is(tok::r_paren) || - Next.is(tok::greater) || Next.is(tok::l_brace) || - Next.is(tok::identifier); + WantTypeSpecifiers = Next.isOneOf(tok::l_paren, tok::r_paren, tok::greater, + tok::l_brace, tok::identifier); } bool ValidateCandidate(const TypoCorrection &Candidate) override { @@ -1201,8 +1193,8 @@ Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult, case tok::coloncolon: { // ::foo::bar const Token &Next = NextToken(); - if (Next.is(tok::kw_new) || // ::new - Next.is(tok::kw_delete)) // ::delete + if (Next.isOneOf(tok::kw_new, // ::new + tok::kw_delete)) // ::delete return TPResult::False; } // Fall through. @@ -1284,6 +1276,9 @@ Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult, case tok::kw___ptr32: case tok::kw___forceinline: case tok::kw___unaligned: + case tok::kw___nonnull: + case tok::kw___nullable: + case tok::kw___null_unspecified: return TPResult::True; // Borland @@ -1603,12 +1598,10 @@ bool Parser::isCXXFunctionDeclarator(bool *IsAmbiguous) { TPR = TPResult::False; else { const Token &Next = NextToken(); - if (Next.is(tok::amp) || Next.is(tok::ampamp) || - Next.is(tok::kw_const) || Next.is(tok::kw_volatile) || - Next.is(tok::kw_throw) || Next.is(tok::kw_noexcept) || - Next.is(tok::l_square) || isCXX11VirtSpecifier(Next) || - Next.is(tok::l_brace) || Next.is(tok::kw_try) || - Next.is(tok::equal) || Next.is(tok::arrow)) + if (Next.isOneOf(tok::amp, tok::ampamp, tok::kw_const, tok::kw_volatile, + tok::kw_throw, tok::kw_noexcept, tok::l_square, + tok::l_brace, tok::kw_try, tok::equal, tok::arrow) || + isCXX11VirtSpecifier(Next)) // The next token cannot appear after a constructor-style initializer, // and can appear next in a function definition. This must be a function // declarator. @@ -1729,8 +1722,8 @@ Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration, // parameter-declaration-clause, and the last param is missing its default // argument. if (VersusTemplateArgument) - return (Tok.is(tok::equal) || Tok.is(tok::r_paren)) ? TPResult::True - : TPResult::False; + return Tok.isOneOf(tok::equal, tok::r_paren) ? TPResult::True + : TPResult::False; if (Tok.is(tok::equal)) { // '=' assignment-expression @@ -1783,13 +1776,11 @@ Parser::TPResult Parser::TryParseFunctionDeclarator() { return TPResult::Error; // cv-qualifier-seq - while (Tok.is(tok::kw_const) || - Tok.is(tok::kw_volatile) || - Tok.is(tok::kw_restrict) ) + while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict)) ConsumeToken(); // ref-qualifier[opt] - if (Tok.is(tok::amp) || Tok.is(tok::ampamp)) + if (Tok.isOneOf(tok::amp, tok::ampamp)) ConsumeToken(); // exception-specification diff --git a/lib/Parse/Parser.cpp b/lib/Parse/Parser.cpp index dea7a6998a2d..e32df95548d9 100644 --- a/lib/Parse/Parser.cpp +++ b/lib/Parse/Parser.cpp @@ -463,6 +463,10 @@ void Parser::Initialize() { ObjCTypeQuals[objc_oneway] = &PP.getIdentifierTable().get("oneway"); ObjCTypeQuals[objc_bycopy] = &PP.getIdentifierTable().get("bycopy"); ObjCTypeQuals[objc_byref] = &PP.getIdentifierTable().get("byref"); + ObjCTypeQuals[objc_nonnull] = &PP.getIdentifierTable().get("nonnull"); + ObjCTypeQuals[objc_nullable] = &PP.getIdentifierTable().get("nullable"); + ObjCTypeQuals[objc_null_unspecified] + = &PP.getIdentifierTable().get("null_unspecified"); } Ident_instancetype = nullptr; diff --git a/lib/Sema/AnalysisBasedWarnings.cpp b/lib/Sema/AnalysisBasedWarnings.cpp index 97f4a8def8c1..36030b99a30b 100644 --- a/lib/Sema/AnalysisBasedWarnings.cpp +++ b/lib/Sema/AnalysisBasedWarnings.cpp @@ -574,28 +574,29 @@ namespace { /// ContainsReference - A visitor class to search for references to /// a particular declaration (the needle) within any evaluated component of an /// expression (recursively). -class ContainsReference : public EvaluatedExprVisitor<ContainsReference> { +class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> { bool FoundReference; const DeclRefExpr *Needle; public: + typedef ConstEvaluatedExprVisitor<ContainsReference> Inherited; + ContainsReference(ASTContext &Context, const DeclRefExpr *Needle) - : EvaluatedExprVisitor<ContainsReference>(Context), - FoundReference(false), Needle(Needle) {} + : Inherited(Context), FoundReference(false), Needle(Needle) {} - void VisitExpr(Expr *E) { + void VisitExpr(const Expr *E) { // Stop evaluating if we already have a reference. if (FoundReference) return; - EvaluatedExprVisitor<ContainsReference>::VisitExpr(E); + Inherited::VisitExpr(E); } - void VisitDeclRefExpr(DeclRefExpr *E) { + void VisitDeclRefExpr(const DeclRefExpr *E) { if (E == Needle) FoundReference = true; else - EvaluatedExprVisitor<ContainsReference>::VisitDeclRefExpr(E); + Inherited::VisitDeclRefExpr(E); } bool doesContainReference() const { return FoundReference; } @@ -854,7 +855,7 @@ static bool DiagnoseUninitializedUse(Sema &S, const VarDecl *VD, return false; ContainsReference CR(S.Context, DRE); - CR.Visit(const_cast<Expr*>(Initializer)); + CR.Visit(Initializer); if (CR.doesContainReference()) { S.Diag(DRE->getLocStart(), diag::warn_uninit_self_reference_in_init) diff --git a/lib/Sema/Sema.cpp b/lib/Sema/Sema.cpp index 50edc4261353..db1251f097f5 100644 --- a/lib/Sema/Sema.cpp +++ b/lib/Sema/Sema.cpp @@ -356,6 +356,19 @@ ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty, assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue"); #endif + // Check whether we're implicitly casting from a nullable type to a nonnull + // type. + if (auto exprNullability = E->getType()->getNullability(Context)) { + if (*exprNullability == NullabilityKind::Nullable) { + if (auto typeNullability = Ty->getNullability(Context)) { + if (*typeNullability == NullabilityKind::NonNull) { + Diag(E->getLocStart(), diag::warn_nullability_lost) + << E->getType() << Ty; + } + } + } + } + QualType ExprTy = Context.getCanonicalType(E->getType()); QualType TypeTy = Context.getCanonicalType(Ty); @@ -551,10 +564,10 @@ static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD, if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I)) Complete = M->isDefined() || (M->isPure() && !isa<CXXDestructorDecl>(M)); else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I)) - // If the template function is marked as late template parsed at this point, - // it has not been instantiated and therefore we have not performed semantic - // analysis on it yet, so we cannot know if the type can be considered - // complete. + // If the template function is marked as late template parsed at this + // point, it has not been instantiated and therefore we have not + // performed semantic analysis on it yet, so we cannot know if the type + // can be considered complete. Complete = !F->getTemplatedDecl()->isLateTemplateParsed() && F->getTemplatedDecl()->isDefined(); else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) { @@ -722,11 +735,7 @@ void Sema::ActOnEndOfTranslationUnit() { ModMap.resolveConflicts(Mod, /*Complain=*/false); // Queue the submodules, so their exports will also be resolved. - for (Module::submodule_iterator Sub = Mod->submodule_begin(), - SubEnd = Mod->submodule_end(); - Sub != SubEnd; ++Sub) { - Stack.push_back(*Sub); - } + Stack.append(Mod->submodule_begin(), Mod->submodule_end()); } } diff --git a/lib/Sema/SemaChecking.cpp b/lib/Sema/SemaChecking.cpp index c3b81b6683d2..f76727cad881 100644 --- a/lib/Sema/SemaChecking.cpp +++ b/lib/Sema/SemaChecking.cpp @@ -836,6 +836,16 @@ bool Sema::CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { SemaBuiltinConstantArgRange(TheCall, 2, 0, 1); } + if (BuiltinID == ARM::BI__builtin_arm_rsr64 || + BuiltinID == ARM::BI__builtin_arm_wsr64) + return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 3, false); + + if (BuiltinID == ARM::BI__builtin_arm_rsr || + BuiltinID == ARM::BI__builtin_arm_rsrp || + BuiltinID == ARM::BI__builtin_arm_wsr || + BuiltinID == ARM::BI__builtin_arm_wsrp) + return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true); + if (CheckNeonBuiltinFunctionCall(BuiltinID, TheCall)) return true; @@ -876,6 +886,16 @@ bool Sema::CheckAArch64BuiltinFunctionCall(unsigned BuiltinID, SemaBuiltinConstantArgRange(TheCall, 4, 0, 1); } + if (BuiltinID == AArch64::BI__builtin_arm_rsr64 || + BuiltinID == AArch64::BI__builtin_arm_wsr64) + return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, false); + + if (BuiltinID == AArch64::BI__builtin_arm_rsr || + BuiltinID == AArch64::BI__builtin_arm_rsrp || + BuiltinID == AArch64::BI__builtin_arm_wsr || + BuiltinID == AArch64::BI__builtin_arm_wsrp) + return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true); + if (CheckNeonBuiltinFunctionCall(BuiltinID, TheCall)) return true; @@ -1095,6 +1115,13 @@ bool Sema::getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember, /// \brief Returns true if the value evaluates to null. static bool CheckNonNullExpr(Sema &S, const Expr *Expr) { + // If the expression has non-null type, it doesn't evaluate to null. + if (auto nullability + = Expr->IgnoreImplicit()->getType()->getNullability(S.Context)) { + if (*nullability == NullabilityKind::NonNull) + return false; + } + // As a special case, transparent unions initialized with zero are // considered null for the purposes of the nonnull attribute. if (const RecordType *UT = Expr->getType()->getAsUnionType()) { @@ -1170,56 +1197,111 @@ DiagnoseCStringFormatDirectiveInCFAPI(Sema &S, } } +/// Determine whether the given type has a non-null nullability annotation. +static bool isNonNullType(ASTContext &ctx, QualType type) { + if (auto nullability = type->getNullability(ctx)) + return *nullability == NullabilityKind::NonNull; + + return false; +} + static void CheckNonNullArguments(Sema &S, const NamedDecl *FDecl, + const FunctionProtoType *Proto, ArrayRef<const Expr *> Args, SourceLocation CallSiteLoc) { + assert((FDecl || Proto) && "Need a function declaration or prototype"); + // Check the attributes attached to the method/function itself. llvm::SmallBitVector NonNullArgs; - for (const auto *NonNull : FDecl->specific_attrs<NonNullAttr>()) { - if (!NonNull->args_size()) { - // Easy case: all pointer arguments are nonnull. - for (const auto *Arg : Args) - if (S.isValidPointerAttrType(Arg->getType())) - CheckNonNullArgument(S, Arg, CallSiteLoc); - return; - } + if (FDecl) { + // Handle the nonnull attribute on the function/method declaration itself. + for (const auto *NonNull : FDecl->specific_attrs<NonNullAttr>()) { + if (!NonNull->args_size()) { + // Easy case: all pointer arguments are nonnull. + for (const auto *Arg : Args) + if (S.isValidPointerAttrType(Arg->getType())) + CheckNonNullArgument(S, Arg, CallSiteLoc); + return; + } - for (unsigned Val : NonNull->args()) { - if (Val >= Args.size()) - continue; - if (NonNullArgs.empty()) - NonNullArgs.resize(Args.size()); - NonNullArgs.set(Val); + for (unsigned Val : NonNull->args()) { + if (Val >= Args.size()) + continue; + if (NonNullArgs.empty()) + NonNullArgs.resize(Args.size()); + NonNullArgs.set(Val); + } } } - // Check the attributes on the parameters. - ArrayRef<ParmVarDecl*> parms; - if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(FDecl)) - parms = FD->parameters(); - else if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(FDecl)) - parms = MD->parameters(); - - unsigned ArgIndex = 0; - for (ArrayRef<ParmVarDecl*>::iterator I = parms.begin(), E = parms.end(); - I != E; ++I, ++ArgIndex) { - const ParmVarDecl *PVD = *I; - if (PVD->hasAttr<NonNullAttr>() || - (ArgIndex < NonNullArgs.size() && NonNullArgs[ArgIndex])) - CheckNonNullArgument(S, Args[ArgIndex], CallSiteLoc); + if (FDecl && (isa<FunctionDecl>(FDecl) || isa<ObjCMethodDecl>(FDecl))) { + // Handle the nonnull attribute on the parameters of the + // function/method. + ArrayRef<ParmVarDecl*> parms; + if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(FDecl)) + parms = FD->parameters(); + else + parms = cast<ObjCMethodDecl>(FDecl)->parameters(); + + unsigned ParamIndex = 0; + for (ArrayRef<ParmVarDecl*>::iterator I = parms.begin(), E = parms.end(); + I != E; ++I, ++ParamIndex) { + const ParmVarDecl *PVD = *I; + if (PVD->hasAttr<NonNullAttr>() || + isNonNullType(S.Context, PVD->getType())) { + if (NonNullArgs.empty()) + NonNullArgs.resize(Args.size()); + + NonNullArgs.set(ParamIndex); + } + } + } else { + // If we have a non-function, non-method declaration but no + // function prototype, try to dig out the function prototype. + if (!Proto) { + if (const ValueDecl *VD = dyn_cast<ValueDecl>(FDecl)) { + QualType type = VD->getType().getNonReferenceType(); + if (auto pointerType = type->getAs<PointerType>()) + type = pointerType->getPointeeType(); + else if (auto blockType = type->getAs<BlockPointerType>()) + type = blockType->getPointeeType(); + // FIXME: data member pointers? + + // Dig out the function prototype, if there is one. + Proto = type->getAs<FunctionProtoType>(); + } + } + + // Fill in non-null argument information from the nullability + // information on the parameter types (if we have them). + if (Proto) { + unsigned Index = 0; + for (auto paramType : Proto->getParamTypes()) { + if (isNonNullType(S.Context, paramType)) { + if (NonNullArgs.empty()) + NonNullArgs.resize(Args.size()); + + NonNullArgs.set(Index); + } + + ++Index; + } + } } - // In case this is a variadic call, check any remaining arguments. - for (/**/; ArgIndex < NonNullArgs.size(); ++ArgIndex) + // Check for non-null arguments. + for (unsigned ArgIndex = 0, ArgIndexEnd = NonNullArgs.size(); + ArgIndex != ArgIndexEnd; ++ArgIndex) { if (NonNullArgs[ArgIndex]) CheckNonNullArgument(S, Args[ArgIndex], CallSiteLoc); + } } /// Handles the checks for format strings, non-POD arguments to vararg /// functions, and NULL arguments passed to non-NULL parameters. -void Sema::checkCall(NamedDecl *FDecl, ArrayRef<const Expr *> Args, - unsigned NumParams, bool IsMemberFunction, +void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, + ArrayRef<const Expr *> Args, bool IsMemberFunction, SourceLocation Loc, SourceRange Range, VariadicCallType CallType) { // FIXME: We should check as much as we can in the template definition. @@ -1241,6 +1323,13 @@ void Sema::checkCall(NamedDecl *FDecl, ArrayRef<const Expr *> Args, // Refuse POD arguments that weren't caught by the format string // checks above. if (CallType != VariadicDoesNotApply) { + unsigned NumParams = Proto ? Proto->getNumParams() + : FDecl && isa<FunctionDecl>(FDecl) + ? cast<FunctionDecl>(FDecl)->getNumParams() + : FDecl && isa<ObjCMethodDecl>(FDecl) + ? cast<ObjCMethodDecl>(FDecl)->param_size() + : 0; + for (unsigned ArgIdx = NumParams; ArgIdx < Args.size(); ++ArgIdx) { // Args[ArgIdx] can be null in malformed code. if (const Expr *Arg = Args[ArgIdx]) { @@ -1250,12 +1339,14 @@ void Sema::checkCall(NamedDecl *FDecl, ArrayRef<const Expr *> Args, } } - if (FDecl) { - CheckNonNullArguments(*this, FDecl, Args, Loc); + if (FDecl || Proto) { + CheckNonNullArguments(*this, FDecl, Proto, Args, Loc); // Type safety checking. - for (const auto *I : FDecl->specific_attrs<ArgumentWithTypeTagAttr>()) - CheckArgumentWithTypeTag(I, Args.data()); + if (FDecl) { + for (const auto *I : FDecl->specific_attrs<ArgumentWithTypeTagAttr>()) + CheckArgumentWithTypeTag(I, Args.data()); + } } } @@ -1267,8 +1358,8 @@ void Sema::CheckConstructorCall(FunctionDecl *FDecl, SourceLocation Loc) { VariadicCallType CallType = Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply; - checkCall(FDecl, Args, Proto->getNumParams(), - /*IsMemberFunction=*/true, Loc, SourceRange(), CallType); + checkCall(FDecl, Proto, Args, /*IsMemberFunction=*/true, Loc, SourceRange(), + CallType); } /// CheckFunctionCall - Check a direct function call for various correctness @@ -1281,7 +1372,6 @@ bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall, IsMemberOperatorCall; VariadicCallType CallType = getVariadicCallType(FDecl, Proto, TheCall->getCallee()); - unsigned NumParams = Proto ? Proto->getNumParams() : 0; Expr** Args = TheCall->getArgs(); unsigned NumArgs = TheCall->getNumArgs(); if (IsMemberOperatorCall) { @@ -1291,7 +1381,7 @@ bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall, ++Args; --NumArgs; } - checkCall(FDecl, llvm::makeArrayRef(Args, NumArgs), NumParams, + checkCall(FDecl, Proto, llvm::makeArrayRef(Args, NumArgs), IsMemberFunction, TheCall->getRParenLoc(), TheCall->getCallee()->getSourceRange(), CallType); @@ -1325,9 +1415,9 @@ bool Sema::CheckObjCMethodCall(ObjCMethodDecl *Method, SourceLocation lbrac, VariadicCallType CallType = Method->isVariadic() ? VariadicMethod : VariadicDoesNotApply; - checkCall(Method, Args, Method->param_size(), - /*IsMemberFunction=*/false, - lbrac, Method->getSourceRange(), CallType); + checkCall(Method, nullptr, Args, + /*IsMemberFunction=*/false, lbrac, Method->getSourceRange(), + CallType); return false; } @@ -1336,13 +1426,14 @@ bool Sema::CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall, const FunctionProtoType *Proto) { QualType Ty; if (const auto *V = dyn_cast<VarDecl>(NDecl)) - Ty = V->getType(); + Ty = V->getType().getNonReferenceType(); else if (const auto *F = dyn_cast<FieldDecl>(NDecl)) - Ty = F->getType(); + Ty = F->getType().getNonReferenceType(); else return false; - if (!Ty->isBlockPointerType() && !Ty->isFunctionPointerType()) + if (!Ty->isBlockPointerType() && !Ty->isFunctionPointerType() && + !Ty->isFunctionProtoType()) return false; VariadicCallType CallType; @@ -1353,11 +1444,10 @@ bool Sema::CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall, } else { // Ty->isFunctionPointerType() CallType = VariadicFunction; } - unsigned NumParams = Proto ? Proto->getNumParams() : 0; - checkCall(NDecl, llvm::makeArrayRef(TheCall->getArgs(), - TheCall->getNumArgs()), - NumParams, /*IsMemberFunction=*/false, TheCall->getRParenLoc(), + checkCall(NDecl, Proto, + llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs()), + /*IsMemberFunction=*/false, TheCall->getRParenLoc(), TheCall->getCallee()->getSourceRange(), CallType); return false; @@ -1368,11 +1458,9 @@ bool Sema::CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall, bool Sema::CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto) { VariadicCallType CallType = getVariadicCallType(/*FDecl=*/nullptr, Proto, TheCall->getCallee()); - unsigned NumParams = Proto ? Proto->getNumParams() : 0; - - checkCall(/*FDecl=*/nullptr, + checkCall(/*FDecl=*/nullptr, Proto, llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs()), - NumParams, /*IsMemberFunction=*/false, TheCall->getRParenLoc(), + /*IsMemberFunction=*/false, TheCall->getRParenLoc(), TheCall->getCallee()->getSourceRange(), CallType); return false; @@ -2593,6 +2681,107 @@ bool Sema::SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, return false; } +/// SemaBuiltinARMSpecialReg - Handle a check if argument ArgNum of CallExpr +/// TheCall is an ARM/AArch64 special register string literal. +bool Sema::SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall, + int ArgNum, unsigned ExpectedFieldNum, + bool AllowName) { + bool IsARMBuiltin = BuiltinID == ARM::BI__builtin_arm_rsr64 || + BuiltinID == ARM::BI__builtin_arm_wsr64 || + BuiltinID == ARM::BI__builtin_arm_rsr || + BuiltinID == ARM::BI__builtin_arm_rsrp || + BuiltinID == ARM::BI__builtin_arm_wsr || + BuiltinID == ARM::BI__builtin_arm_wsrp; + bool IsAArch64Builtin = BuiltinID == AArch64::BI__builtin_arm_rsr64 || + BuiltinID == AArch64::BI__builtin_arm_wsr64 || + BuiltinID == AArch64::BI__builtin_arm_rsr || + BuiltinID == AArch64::BI__builtin_arm_rsrp || + BuiltinID == AArch64::BI__builtin_arm_wsr || + BuiltinID == AArch64::BI__builtin_arm_wsrp; + assert((IsARMBuiltin || IsAArch64Builtin) && "Unexpected ARM builtin."); + + // We can't check the value of a dependent argument. + Expr *Arg = TheCall->getArg(ArgNum); + if (Arg->isTypeDependent() || Arg->isValueDependent()) + return false; + + // Check if the argument is a string literal. + if (!isa<StringLiteral>(Arg->IgnoreParenImpCasts())) + return Diag(TheCall->getLocStart(), diag::err_expr_not_string_literal) + << Arg->getSourceRange(); + + // Check the type of special register given. + StringRef Reg = cast<StringLiteral>(Arg->IgnoreParenImpCasts())->getString(); + SmallVector<StringRef, 6> Fields; + Reg.split(Fields, ":"); + + if (Fields.size() != ExpectedFieldNum && !(AllowName && Fields.size() == 1)) + return Diag(TheCall->getLocStart(), diag::err_arm_invalid_specialreg) + << Arg->getSourceRange(); + + // If the string is the name of a register then we cannot check that it is + // valid here but if the string is of one the forms described in ACLE then we + // can check that the supplied fields are integers and within the valid + // ranges. + if (Fields.size() > 1) { + bool FiveFields = Fields.size() == 5; + + bool ValidString = true; + if (IsARMBuiltin) { + ValidString &= Fields[0].startswith_lower("cp") || + Fields[0].startswith_lower("p"); + if (ValidString) + Fields[0] = + Fields[0].drop_front(Fields[0].startswith_lower("cp") ? 2 : 1); + + ValidString &= Fields[2].startswith_lower("c"); + if (ValidString) + Fields[2] = Fields[2].drop_front(1); + + if (FiveFields) { + ValidString &= Fields[3].startswith_lower("c"); + if (ValidString) + Fields[3] = Fields[3].drop_front(1); + } + } + + SmallVector<int, 5> Ranges; + if (FiveFields) + Ranges.append({IsAArch64Builtin ? 1 : 15, 7, 7, 15, 15}); + else + Ranges.append({15, 7, 15}); + + for (unsigned i=0; i<Fields.size(); ++i) { + int IntField; + ValidString &= !Fields[i].getAsInteger(10, IntField); + ValidString &= (IntField >= 0 && IntField <= Ranges[i]); + } + + if (!ValidString) + return Diag(TheCall->getLocStart(), diag::err_arm_invalid_specialreg) + << Arg->getSourceRange(); + + } else if (IsAArch64Builtin && Fields.size() == 1) { + // If the register name is one of those that appear in the condition below + // and the special register builtin being used is one of the write builtins, + // then we require that the argument provided for writing to the register + // is an integer constant expression. This is because it will be lowered to + // an MSR (immediate) instruction, so we need to know the immediate at + // compile time. + if (TheCall->getNumArgs() != 2) + return false; + + std::string RegLower = Reg.lower(); + if (RegLower != "spsel" && RegLower != "daifset" && RegLower != "daifclr" && + RegLower != "pan" && RegLower != "uao") + return false; + + return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15); + } + + return false; +} + /// SemaBuiltinLongjmp - Handle __builtin_longjmp(void *env[5], int val). /// This checks that the target supports __builtin_longjmp and /// that val is a constant 1. @@ -5559,7 +5748,8 @@ Sema::CheckReturnValExpr(Expr *RetValExp, QualType lhsType, CheckReturnStackAddr(*this, RetValExp, lhsType, ReturnLoc); // Check if the return value is null but should not be. - if (Attrs && hasSpecificAttr<ReturnsNonNullAttr>(*Attrs) && + if (((Attrs && hasSpecificAttr<ReturnsNonNullAttr>(*Attrs)) || + (!isObjCMethod && isNonNullType(Context, lhsType))) && CheckNonNullExpr(*this, RetValExp)) Diag(ReturnLoc, diag::warn_null_ret) << (isObjCMethod ? 1 : 0) << RetValExp->getSourceRange(); diff --git a/lib/Sema/SemaCodeComplete.cpp b/lib/Sema/SemaCodeComplete.cpp index fd97809295a5..ebb6bbcd3454 100644 --- a/lib/Sema/SemaCodeComplete.cpp +++ b/lib/Sema/SemaCodeComplete.cpp @@ -1341,6 +1341,11 @@ static void AddTypeSpecifierResults(const LangOptions &LangOpts, Builder.AddChunk(CodeCompletionString::CK_RightParen); Results.AddResult(Result(Builder.TakeString())); } + + // Nullability + Results.AddResult(Result("__nonnull", CCP_Type)); + Results.AddResult(Result("__null_unspecified", CCP_Type)); + Results.AddResult(Result("__nullable", CCP_Type)); } static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC, @@ -2097,7 +2102,8 @@ static void MaybeAddSentinel(Preprocessor &PP, } } -static std::string formatObjCParamQualifiers(unsigned ObjCQuals) { +static std::string formatObjCParamQualifiers(unsigned ObjCQuals, + QualType &Type) { std::string Result; if (ObjCQuals & Decl::OBJC_TQ_In) Result += "in "; @@ -2111,6 +2117,23 @@ static std::string formatObjCParamQualifiers(unsigned ObjCQuals) { Result += "byref "; if (ObjCQuals & Decl::OBJC_TQ_Oneway) Result += "oneway "; + if (ObjCQuals & Decl::OBJC_TQ_CSNullability) { + if (auto nullability = AttributedType::stripOuterNullability(Type)) { + switch (*nullability) { + case NullabilityKind::NonNull: + Result += "nonnull "; + break; + + case NullabilityKind::Nullable: + Result += "nullable "; + break; + + case NullabilityKind::Unspecified: + Result += "null_unspecified "; + break; + } + } + } return Result; } @@ -2128,13 +2151,15 @@ static std::string FormatFunctionParameter(const PrintingPolicy &Policy, if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName) Result = Param->getIdentifier()->getName(); - Param->getType().getAsStringInternal(Result, Policy); - + QualType Type = Param->getType(); if (ObjCMethodParam) { - Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier()) - + Result + ")"; + Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(), + Type); + Result += Type.getAsString(Policy) + ")"; if (Param->getIdentifier() && !SuppressName) Result += Param->getIdentifier()->getName(); + } else { + Type.getAsStringInternal(Result, Policy); } return Result; } @@ -2182,13 +2207,16 @@ static std::string FormatFunctionParameter(const PrintingPolicy &Policy, if (!ObjCMethodParam && Param->getIdentifier()) Result = Param->getIdentifier()->getName(); - Param->getType().getUnqualifiedType().getAsStringInternal(Result, Policy); + QualType Type = Param->getType().getUnqualifiedType(); if (ObjCMethodParam) { - Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier()) - + Result + ")"; + Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(), + Type); + Result += Type.getAsString(Policy) + Result + ")"; if (Param->getIdentifier()) Result += Param->getIdentifier()->getName(); + } else { + Type.getAsStringInternal(Result, Policy); } return Result; @@ -2762,9 +2790,10 @@ CodeCompletionResult::CreateCodeCompletionString(ASTContext &Ctx, if ((*P)->getType()->isBlockPointerType() && !DeclaringEntity) Arg = FormatFunctionParameter(Policy, *P, true); else { - (*P)->getType().getAsStringInternal(Arg, Policy); - Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier()) - + Arg + ")"; + QualType Type = (*P)->getType(); + Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(), + Type); + Arg += Type.getAsString(Policy) + ")"; if (IdentifierInfo *II = (*P)->getIdentifier()) if (DeclaringEntity || AllParametersAreInformative) Arg += II->getName(); @@ -4858,6 +4887,12 @@ void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) { Getter.AddPlaceholderChunk("method"); Results.AddResult(CodeCompletionResult(Getter.TakeString())); } + if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nullability)) { + Results.AddResult(CodeCompletionResult("nonnull")); + Results.AddResult(CodeCompletionResult("nullable")); + Results.AddResult(CodeCompletionResult("null_unspecified")); + Results.AddResult(CodeCompletionResult("null_resettable")); + } Results.ExitScope(); HandleCodeCompleteResults(this, CodeCompleter, CodeCompletionContext::CCC_Other, @@ -5107,6 +5142,11 @@ void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS, Results.AddResult("byref"); Results.AddResult("oneway"); } + if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) { + Results.AddResult("nonnull"); + Results.AddResult("nullable"); + Results.AddResult("null_unspecified"); + } // If we're completing the return type of an Objective-C method and the // identifier IBAction refers to a macro, provide a completion item for @@ -6279,7 +6319,7 @@ static void AddObjCPassingTypeChunk(QualType Type, const PrintingPolicy &Policy, CodeCompletionBuilder &Builder) { Builder.AddChunk(CodeCompletionString::CK_LeftParen); - std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals); + std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type); if (!Quals.empty()) Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals)); Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy, @@ -7018,7 +7058,12 @@ void Sema::CodeCompleteObjCMethodDecl(Scope *S, break; // Add the parameter type. - AddObjCPassingTypeChunk((*P)->getOriginalType(), + QualType ParamType; + if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) + ParamType = (*P)->getType(); + else + ParamType = (*P)->getOriginalType(); + AddObjCPassingTypeChunk(ParamType, (*P)->getObjCDeclQualifier(), Context, Policy, Builder); diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp index 89f4b3a0c1fb..aa006b31fc89 100644 --- a/lib/Sema/SemaDecl.cpp +++ b/lib/Sema/SemaDecl.cpp @@ -1007,7 +1007,7 @@ Corrected: // Check for a tag type hidden by a non-type decl in a few cases where it // seems likely a type is wanted instead of the non-type that was found. - bool NextIsOp = NextToken.is(tok::amp) || NextToken.is(tok::star); + bool NextIsOp = NextToken.isOneOf(tok::amp, tok::star); if ((NextToken.is(tok::identifier) || (NextIsOp && FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) && @@ -1081,6 +1081,22 @@ void Sema::PopDeclContext() { assert(CurContext && "Popped translation unit!"); } +Sema::SkippedDefinitionContext Sema::ActOnTagStartSkippedDefinition(Scope *S, + Decl *D) { + // Unlike PushDeclContext, the context to which we return is not necessarily + // the containing DC of TD, because the new context will be some pre-existing + // TagDecl definition instead of a fresh one. + auto Result = static_cast<SkippedDefinitionContext>(CurContext); + CurContext = cast<TagDecl>(D)->getDefinition(); + assert(CurContext && "skipping definition of undefined tag"); + S->setEntity(CurContext); + return Result; +} + +void Sema::ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context) { + CurContext = static_cast<decltype(CurContext)>(Context); +} + /// EnterDeclaratorContext - Used when we must lookup names in the context /// of a declarator's nested name specifier. /// @@ -1788,7 +1804,7 @@ static void filterNonConflictingPreviousDecls(Sema &S, NamedDecl *decl, LookupResult &previous){ // This is only interesting when modules are enabled. - if (!S.getLangOpts().Modules) + if (!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility) return; // Empty sets are uninteresting. @@ -1818,7 +1834,7 @@ static void filterNonConflictingPreviousTypedefDecls(Sema &S, TypedefNameDecl *Decl, LookupResult &Previous) { // This is only interesting when modules are enabled. - if (!S.getLangOpts().Modules) + if (!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility) return; // Empty sets are uninteresting. @@ -2449,6 +2465,32 @@ static void mergeParamDeclAttributes(ParmVarDecl *newDecl, if (!foundAny) newDecl->dropAttrs(); } +static void mergeParamDeclTypes(ParmVarDecl *NewParam, + const ParmVarDecl *OldParam, + Sema &S) { + if (auto Oldnullability = OldParam->getType()->getNullability(S.Context)) { + if (auto Newnullability = NewParam->getType()->getNullability(S.Context)) { + if (*Oldnullability != *Newnullability) { + unsigned unsNewnullability = static_cast<unsigned>(*Newnullability); + unsigned unsOldnullability = static_cast<unsigned>(*Oldnullability); + S.Diag(NewParam->getLocation(), diag::warn_mismatched_nullability_attr) + << unsNewnullability + << ((NewParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) != 0) + << unsOldnullability + << ((OldParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) != 0); + S.Diag(OldParam->getLocation(), diag::note_previous_declaration); + } + } + else { + QualType NewT = NewParam->getType(); + NewT = S.Context.getAttributedType( + AttributedType::getNullabilityAttrKind(*Oldnullability), + NewT, NewT); + NewParam->setType(NewT); + } + } +} + namespace { /// Used in MergeFunctionDecl to keep track of function parameters in @@ -3085,9 +3127,12 @@ bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, // Merge attributes from the parameters. These can mismatch with K&R // declarations. if (New->getNumParams() == Old->getNumParams()) - for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) - mergeParamDeclAttributes(New->getParamDecl(i), Old->getParamDecl(i), - *this); + for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) { + ParmVarDecl *NewParam = New->getParamDecl(i); + ParmVarDecl *OldParam = Old->getParamDecl(i); + mergeParamDeclAttributes(NewParam, OldParam, *this); + mergeParamDeclTypes(NewParam, OldParam, *this); + } if (getLangOpts().CPlusPlus) return MergeCXXFunctionDecl(New, Old, S); @@ -4663,12 +4708,14 @@ NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D, RequireCompleteDeclContext(D.getCXXScopeSpec(), DC)) return nullptr; + // If a class is incomplete, do not parse entities inside it. if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) { Diag(D.getIdentifierLoc(), diag::err_member_def_undefined_record) << Name << DC << D.getCXXScopeSpec().getRange(); - D.setInvalidType(); - } else if (!D.getDeclSpec().isFriendSpecified()) { + return nullptr; + } + if (!D.getDeclSpec().isFriendSpecified()) { if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC, Name, D.getIdentifierLoc())) { if (DC->isRecord()) @@ -13486,7 +13533,8 @@ EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum, Sema::SkipBodyInfo Sema::shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, SourceLocation IILoc) { - if (!getLangOpts().Modules || !getLangOpts().CPlusPlus) + if (!(getLangOpts().Modules || getLangOpts().ModulesLocalVisibility) || + !getLangOpts().CPlusPlus) return SkipBodyInfo(); // We have an anonymous enum definition. Look up the first enumerator to @@ -13500,7 +13548,6 @@ Sema::SkipBodyInfo Sema::shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, !hasVisibleDefinition(cast<NamedDecl>(PrevECD->getDeclContext()), &Hidden)) { SkipBodyInfo Skip; - Skip.ShouldSkip = true; Skip.Previous = Hidden; return Skip; } @@ -14197,16 +14244,22 @@ void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name, SourceLocation PragmaLoc, SourceLocation NameLoc, SourceLocation AliasNameLoc) { - Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, - LookupOrdinaryName); - AsmLabelAttr *Attr = ::new (Context) AsmLabelAttr(AliasNameLoc, Context, - AliasName->getName(), 0); - - if (PrevDecl) + NamedDecl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, + LookupOrdinaryName); + AsmLabelAttr *Attr = + AsmLabelAttr::CreateImplicit(Context, AliasName->getName(), AliasNameLoc); + + // If a declaration that: + // 1) declares a function or a variable + // 2) has external linkage + // already exists, add a label attribute to it. + if (PrevDecl && + (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)) && + PrevDecl->hasExternalFormalLinkage()) PrevDecl->addAttr(Attr); - else - (void)ExtnameUndeclaredIdentifiers.insert( - std::pair<IdentifierInfo*,AsmLabelAttr*>(Name, Attr)); + // Otherwise, add a label atttibute to ExtnameUndeclaredIdentifiers. + else + (void)ExtnameUndeclaredIdentifiers.insert(std::make_pair(Name, Attr)); } void Sema::ActOnPragmaWeakID(IdentifierInfo* Name, diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp index 1d0415990e1b..43790c2f37e0 100644 --- a/lib/Sema/SemaDeclAttr.cpp +++ b/lib/Sema/SemaDeclAttr.cpp @@ -2397,6 +2397,28 @@ static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &Attr) { D->addAttr(NewAttr); } +// Check for things we'd like to warn about, no errors or validation for now. +// TODO: Validation should use a backend target library that specifies +// the allowable subtarget features and cpus. We could use something like a +// TargetCodeGenInfo hook here to do validation. +void Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) { + for (auto Str : {"tune=", "fpmath="}) + if (AttrStr.find(Str) != StringRef::npos) + Diag(LiteralLoc, diag::warn_unsupported_target_attribute) << Str; +} + +static void handleTargetAttr(Sema &S, Decl *D, const AttributeList &Attr) { + StringRef Str; + SourceLocation LiteralLoc; + if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &LiteralLoc)) + return; + S.checkTargetAttr(LiteralLoc, Str); + unsigned Index = Attr.getAttributeSpellingListIndex(); + TargetAttr *NewAttr = + ::new (S.Context) TargetAttr(Attr.getRange(), S.Context, Str, Index); + D->addAttr(NewAttr); +} + static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr) { VarDecl *VD = cast<VarDecl>(D); @@ -3132,16 +3154,22 @@ static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) { return; } - if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType()) + // Base type can also be a vector type (see PR17453). + // Distinguish between base type and base element type. + QualType OldElemTy = OldTy; + if (const VectorType *VT = OldTy->getAs<VectorType>()) + OldElemTy = VT->getElementType(); + + if (!OldElemTy->getAs<BuiltinType>() && !OldElemTy->isComplexType()) S.Diag(Attr.getLoc(), diag::err_mode_not_primitive); else if (IntegerMode) { - if (!OldTy->isIntegralOrEnumerationType()) + if (!OldElemTy->isIntegralOrEnumerationType()) S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); } else if (ComplexMode) { - if (!OldTy->isComplexType()) + if (!OldElemTy->isComplexType()) S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); } else { - if (!OldTy->isFloatingType()) + if (!OldElemTy->isFloatingType()) S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); } @@ -3154,21 +3182,40 @@ static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) { return; } - QualType NewTy; + QualType NewElemTy; if (IntegerMode) - NewTy = S.Context.getIntTypeForBitwidth(DestWidth, - OldTy->isSignedIntegerType()); + NewElemTy = S.Context.getIntTypeForBitwidth( + DestWidth, OldElemTy->isSignedIntegerType()); else - NewTy = S.Context.getRealTypeForBitwidth(DestWidth); + NewElemTy = S.Context.getRealTypeForBitwidth(DestWidth); - if (NewTy.isNull()) { + if (NewElemTy.isNull()) { S.Diag(Attr.getLoc(), diag::err_machine_mode) << 1 /*Unsupported*/ << Name; return; } if (ComplexMode) { - NewTy = S.Context.getComplexType(NewTy); + NewElemTy = S.Context.getComplexType(NewElemTy); + } + + QualType NewTy = NewElemTy; + if (const VectorType *OldVT = OldTy->getAs<VectorType>()) { + // Complex machine mode does not support base vector types. + if (ComplexMode) { + S.Diag(Attr.getLoc(), diag::err_complex_mode_vector_type); + return; + } + unsigned NumElements = S.Context.getTypeSize(OldElemTy) * + OldVT->getNumElements() / + S.Context.getTypeSize(NewElemTy); + NewTy = + S.Context.getVectorType(NewElemTy, NumElements, OldVT->getVectorKind()); + } + + if (NewTy.isNull()) { + S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); + return; } // Install the new type. @@ -3683,10 +3730,31 @@ static void handleNSReturnsRetainedAttr(Sema &S, Decl *D, returnType = PD->getType(); else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) returnType = FD->getReturnType(); - else { + else if (auto *Param = dyn_cast<ParmVarDecl>(D)) { + returnType = Param->getType()->getPointeeType(); + if (returnType.isNull()) { + S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type) + << Attr.getName() << /*pointer-to-CF*/2 + << Attr.getRange(); + return; + } + } else { + AttributeDeclKind ExpectedDeclKind; + switch (Attr.getKind()) { + default: llvm_unreachable("invalid ownership attribute"); + case AttributeList::AT_NSReturnsRetained: + case AttributeList::AT_NSReturnsAutoreleased: + case AttributeList::AT_NSReturnsNotRetained: + ExpectedDeclKind = ExpectedFunctionOrMethod; + break; + + case AttributeList::AT_CFReturnsRetained: + case AttributeList::AT_CFReturnsNotRetained: + ExpectedDeclKind = ExpectedFunctionMethodOrParameter; + break; + } S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type) - << Attr.getRange() << Attr.getName() - << ExpectedFunctionOrMethod; + << Attr.getRange() << Attr.getName() << ExpectedDeclKind; return; } @@ -3713,8 +3781,25 @@ static void handleNSReturnsRetainedAttr(Sema &S, Decl *D, } if (!typeOK) { - S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type) - << Attr.getRange() << Attr.getName() << isa<ObjCMethodDecl>(D) << cf; + if (isa<ParmVarDecl>(D)) { + S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type) + << Attr.getName() << /*pointer-to-CF*/2 + << Attr.getRange(); + } else { + // Needs to be kept in sync with warn_ns_attribute_wrong_return_type. + enum : unsigned { + Function, + Method, + Property + } SubjectKind = Function; + if (isa<ObjCMethodDecl>(D)) + SubjectKind = Method; + else if (isa<ObjCPropertyDecl>(D)) + SubjectKind = Property; + S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type) + << Attr.getName() << SubjectKind << cf + << Attr.getRange(); + } return; } @@ -4716,6 +4801,9 @@ static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, case AttributeList::AT_Section: handleSectionAttr(S, D, Attr); break; + case AttributeList::AT_Target: + handleTargetAttr(S, D, Attr); + break; case AttributeList::AT_Unavailable: handleAttrWithMessage<UnavailableAttr>(S, D, Attr); break; diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp index c80ef2d2bdc1..7ed9bfcb9796 100644 --- a/lib/Sema/SemaDeclCXX.cpp +++ b/lib/Sema/SemaDeclCXX.cpp @@ -9494,6 +9494,7 @@ static void getDefaultArgExprsForConstructors(Sema &S, CXXRecordDecl *Class) { Expr *DefaultArg = S.BuildCXXDefaultArgExpr(Class->getLocation(), CD, CD->getParamDecl(I)).get(); + S.DiscardCleanupsInEvaluationContext(); S.Context.addDefaultArgExprForConstructor(CD, I, DefaultArg); } } diff --git a/lib/Sema/SemaDeclObjC.cpp b/lib/Sema/SemaDeclObjC.cpp index 38318791fd77..543566fdb7cc 100644 --- a/lib/Sema/SemaDeclObjC.cpp +++ b/lib/Sema/SemaDeclObjC.cpp @@ -1366,6 +1366,13 @@ static SourceRange getTypeRange(TypeSourceInfo *TSI) { return (TSI ? TSI->getTypeLoc().getSourceRange() : SourceRange()); } +/// Determine whether two set of Objective-C declaration qualifiers conflict. +static bool objcModifiersConflict(Decl::ObjCDeclQualifier x, + Decl::ObjCDeclQualifier y) { + return (x & ~Decl::OBJC_TQ_CSNullability) != + (y & ~Decl::OBJC_TQ_CSNullability); +} + static bool CheckMethodOverrideReturn(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, @@ -1373,8 +1380,8 @@ static bool CheckMethodOverrideReturn(Sema &S, bool IsOverridingMode, bool Warn) { if (IsProtocolMethodDecl && - (MethodDecl->getObjCDeclQualifier() != - MethodImpl->getObjCDeclQualifier())) { + objcModifiersConflict(MethodDecl->getObjCDeclQualifier(), + MethodImpl->getObjCDeclQualifier())) { if (Warn) { S.Diag(MethodImpl->getLocation(), (IsOverridingMode @@ -1388,7 +1395,24 @@ static bool CheckMethodOverrideReturn(Sema &S, else return false; } - + if (Warn && IsOverridingMode && + !isa<ObjCImplementationDecl>(MethodImpl->getDeclContext()) && + !S.Context.hasSameNullabilityTypeQualifier(MethodImpl->getReturnType(), + MethodDecl->getReturnType(), + false)) { + unsigned unsNullabilityMethodImpl = + static_cast<unsigned>(*MethodImpl->getReturnType()->getNullability(S.Context)); + unsigned unsNullabilityMethodDecl = + static_cast<unsigned>(*MethodDecl->getReturnType()->getNullability(S.Context)); + S.Diag(MethodImpl->getLocation(), + diag::warn_conflicting_nullability_attr_overriding_ret_types) + << unsNullabilityMethodImpl + << ((MethodImpl->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) != 0) + << unsNullabilityMethodDecl + << ((MethodDecl->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) != 0); + S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration); + } + if (S.Context.hasSameUnqualifiedType(MethodImpl->getReturnType(), MethodDecl->getReturnType())) return true; @@ -1438,8 +1462,8 @@ static bool CheckMethodOverrideParam(Sema &S, bool IsOverridingMode, bool Warn) { if (IsProtocolMethodDecl && - (ImplVar->getObjCDeclQualifier() != - IfaceVar->getObjCDeclQualifier())) { + objcModifiersConflict(ImplVar->getObjCDeclQualifier(), + IfaceVar->getObjCDeclQualifier())) { if (Warn) { if (IsOverridingMode) S.Diag(ImplVar->getLocation(), @@ -1459,7 +1483,19 @@ static bool CheckMethodOverrideParam(Sema &S, QualType ImplTy = ImplVar->getType(); QualType IfaceTy = IfaceVar->getType(); - + if (Warn && IsOverridingMode && + !isa<ObjCImplementationDecl>(MethodImpl->getDeclContext()) && + !S.Context.hasSameNullabilityTypeQualifier(ImplTy, IfaceTy, true)) { + unsigned unsImplTy = static_cast<unsigned>(*ImplTy->getNullability(S.Context)); + unsigned unsIfaceTy = static_cast<unsigned>(*IfaceTy->getNullability(S.Context)); + S.Diag(ImplVar->getLocation(), + diag::warn_conflicting_nullability_attr_overriding_param_types) + << unsImplTy + << ((ImplVar->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) != 0) + << unsIfaceTy + << ((IfaceVar->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) != 0); + S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration); + } if (S.Context.hasSameUnqualifiedType(ImplTy, IfaceTy)) return true; @@ -1988,6 +2024,9 @@ void Sema::ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl, DiagnoseUnimplementedProperties(S, IMPDecl, CDecl, SynthesizeProperties); } + // Diagnose null-resettable synthesized setters. + diagnoseNullResettableSynthesizedSetters(IMPDecl); + SelectorSet ClsMap; for (const auto *I : IMPDecl->class_methods()) ClsMap.insert(I->getSelector()); @@ -3121,6 +3160,89 @@ void Sema::CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod, ObjCMethod->setOverriding(hasOverriddenMethodsInBaseOrProtocol); } +/// Merge type nullability from for a redeclaration of the same entity, +/// producing the updated type of the redeclared entity. +static QualType mergeTypeNullabilityForRedecl(Sema &S, SourceLocation loc, + QualType type, + bool usesCSKeyword, + SourceLocation prevLoc, + QualType prevType, + bool prevUsesCSKeyword) { + // Determine the nullability of both types. + auto nullability = type->getNullability(S.Context); + auto prevNullability = prevType->getNullability(S.Context); + + // Easy case: both have nullability. + if (nullability.hasValue() == prevNullability.hasValue()) { + // Neither has nullability; continue. + if (!nullability) + return type; + + // The nullabilities are equivalent; do nothing. + if (*nullability == *prevNullability) + return type; + + // Complain about mismatched nullability. + S.Diag(loc, diag::err_nullability_conflicting) + << static_cast<unsigned>(*nullability) << usesCSKeyword + << static_cast<unsigned>(*prevNullability) << prevUsesCSKeyword; + return type; + } + + // If it's the redeclaration that has nullability, don't change anything. + if (nullability) + return type; + + // Otherwise, provide the result with the same nullability. + return S.Context.getAttributedType( + AttributedType::getNullabilityAttrKind(*prevNullability), + type, type); +} + +/// Merge information from the declaration of a method in the \@interface +/// (or a category/extension) into the corresponding method in the +/// @implementation (for a class or category). +static void mergeInterfaceMethodToImpl(Sema &S, + ObjCMethodDecl *method, + ObjCMethodDecl *prevMethod) { + // Merge the objc_requires_super attribute. + if (prevMethod->hasAttr<ObjCRequiresSuperAttr>() && + !method->hasAttr<ObjCRequiresSuperAttr>()) { + // merge the attribute into implementation. + method->addAttr( + ObjCRequiresSuperAttr::CreateImplicit(S.Context, + method->getLocation())); + } + + // Merge nullability of the result type. + QualType newReturnType + = mergeTypeNullabilityForRedecl( + S, method->getReturnTypeSourceRange().getBegin(), + method->getReturnType(), + method->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability, + prevMethod->getReturnTypeSourceRange().getBegin(), + prevMethod->getReturnType(), + prevMethod->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability); + method->setReturnType(newReturnType); + + // Handle each of the parameters. + unsigned numParams = method->param_size(); + unsigned numPrevParams = prevMethod->param_size(); + for (unsigned i = 0, n = std::min(numParams, numPrevParams); i != n; ++i) { + ParmVarDecl *param = method->param_begin()[i]; + ParmVarDecl *prevParam = prevMethod->param_begin()[i]; + + // Merge nullability. + QualType newParamType + = mergeTypeNullabilityForRedecl( + S, param->getLocation(), param->getType(), + param->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability, + prevParam->getLocation(), prevParam->getType(), + prevParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability); + param->setType(newParamType); + } +} + Decl *Sema::ActOnMethodDeclaration( Scope *S, SourceLocation MethodLoc, SourceLocation EndLoc, @@ -3151,7 +3273,9 @@ Decl *Sema::ActOnMethodDeclaration( if (CheckFunctionReturnType(resultDeclType, MethodLoc)) return nullptr; - HasRelatedResultType = (resultDeclType == Context.getObjCInstanceType()); + QualType bareResultType = resultDeclType; + (void)AttributedType::stripOuterNullability(bareResultType); + HasRelatedResultType = (bareResultType == Context.getObjCInstanceType()); } else { // get the type for "id". resultDeclType = Context.getObjCIdType(); Diag(MethodLoc, diag::warn_missing_method_return_type) @@ -3252,22 +3376,20 @@ Decl *Sema::ActOnMethodDeclaration( ImpDecl->addClassMethod(ObjCMethod); } - ObjCMethodDecl *IMD = nullptr; - if (ObjCInterfaceDecl *IDecl = ImpDecl->getClassInterface()) - IMD = IDecl->lookupMethod(ObjCMethod->getSelector(), - ObjCMethod->isInstanceMethod()); - if (IMD && IMD->hasAttr<ObjCRequiresSuperAttr>() && - !ObjCMethod->hasAttr<ObjCRequiresSuperAttr>()) { - // merge the attribute into implementation. - ObjCMethod->addAttr(ObjCRequiresSuperAttr::CreateImplicit(Context, - ObjCMethod->getLocation())); - } - if (isa<ObjCCategoryImplDecl>(ImpDecl)) { - ObjCMethodFamily family = - ObjCMethod->getSelector().getMethodFamily(); - if (family == OMF_dealloc && IMD && IMD->isOverriding()) - Diag(ObjCMethod->getLocation(), diag::warn_dealloc_in_category) - << ObjCMethod->getDeclName(); + // Merge information from the @interface declaration into the + // @implementation. + if (ObjCInterfaceDecl *IDecl = ImpDecl->getClassInterface()) { + if (auto *IMD = IDecl->lookupMethod(ObjCMethod->getSelector(), + ObjCMethod->isInstanceMethod())) { + mergeInterfaceMethodToImpl(*this, ObjCMethod, IMD); + + // Warn about defining -dealloc in a category. + if (isa<ObjCCategoryImplDecl>(ImpDecl) && IMD->isOverriding() && + ObjCMethod->getSelector().getMethodFamily() == OMF_dealloc) { + Diag(ObjCMethod->getLocation(), diag::warn_dealloc_in_category) + << ObjCMethod->getDeclName(); + } + } } } else { cast<DeclContext>(ClassDecl)->addDecl(ObjCMethod); diff --git a/lib/Sema/SemaExceptionSpec.cpp b/lib/Sema/SemaExceptionSpec.cpp index 51d6acebada1..f3bcf76a21ba 100644 --- a/lib/Sema/SemaExceptionSpec.cpp +++ b/lib/Sema/SemaExceptionSpec.cpp @@ -1041,6 +1041,7 @@ CanThrowResult Sema::canThrow(const Expr *E) { case Expr::CXXReinterpretCastExprClass: case Expr::CXXStdInitializerListExprClass: case Expr::DesignatedInitExprClass: + case Expr::DesignatedInitUpdateExprClass: case Expr::ExprWithCleanupsClass: case Expr::ExtVectorElementExprClass: case Expr::InitListExprClass: @@ -1135,6 +1136,7 @@ CanThrowResult Sema::canThrow(const Expr *E) { case Expr::ImaginaryLiteralClass: case Expr::ImplicitValueInitExprClass: case Expr::IntegerLiteralClass: + case Expr::NoInitExprClass: case Expr::ObjCEncodeExprClass: case Expr::ObjCStringLiteralClass: case Expr::ObjCBoolLiteralExprClass: diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp index 7e305ffa8edc..6c839f356fdc 100644 --- a/lib/Sema/SemaExprCXX.cpp +++ b/lib/Sema/SemaExprCXX.cpp @@ -20,7 +20,6 @@ #include "clang/AST/CXXInheritance.h" #include "clang/AST/CharUnits.h" #include "clang/AST/DeclObjC.h" -#include "clang/AST/EvaluatedExprVisitor.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/ExprObjC.h" #include "clang/AST/RecursiveASTVisitor.h" @@ -3291,10 +3290,10 @@ Sema::PerformImplicitConversion(Expr *From, QualType ToType, // We may not have been able to figure out what this member pointer resolved // to up until this exact point. Attempt to lock-in it's inheritance model. - QualType FromType = From->getType(); - if (FromType->isMemberPointerType()) - if (Context.getTargetInfo().getCXXABI().isMicrosoft()) - RequireCompleteType(From->getExprLoc(), FromType, 0); + if (Context.getTargetInfo().getCXXABI().isMicrosoft()) { + RequireCompleteType(From->getExprLoc(), From->getType(), 0); + RequireCompleteType(From->getExprLoc(), ToType, 0); + } From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK) .get(); diff --git a/lib/Sema/SemaExprObjC.cpp b/lib/Sema/SemaExprObjC.cpp index 63b7485c8764..9947fad70dd3 100644 --- a/lib/Sema/SemaExprObjC.cpp +++ b/lib/Sema/SemaExprObjC.cpp @@ -1135,49 +1135,154 @@ ObjCMethodDecl *Sema::tryCaptureObjCSelf(SourceLocation Loc) { } static QualType stripObjCInstanceType(ASTContext &Context, QualType T) { + QualType origType = T; + if (auto nullability = AttributedType::stripOuterNullability(T)) { + if (T == Context.getObjCInstanceType()) { + return Context.getAttributedType( + AttributedType::getNullabilityAttrKind(*nullability), + Context.getObjCIdType(), + Context.getObjCIdType()); + } + + return origType; + } + if (T == Context.getObjCInstanceType()) return Context.getObjCIdType(); - return T; + return origType; } -QualType Sema::getMessageSendResultType(QualType ReceiverType, - ObjCMethodDecl *Method, - bool isClassMessage, bool isSuperMessage) { +/// Determine the result type of a message send based on the receiver type, +/// method, and the kind of message send. +/// +/// This is the "base" result type, which will still need to be adjusted +/// to account for nullability. +static QualType getBaseMessageSendResultType(Sema &S, + QualType ReceiverType, + ObjCMethodDecl *Method, + bool isClassMessage, + bool isSuperMessage) { assert(Method && "Must have a method"); if (!Method->hasRelatedResultType()) return Method->getSendResultType(); - + + ASTContext &Context = S.Context; + + // Local function that transfers the nullability of the method's + // result type to the returned result. + auto transferNullability = [&](QualType type) -> QualType { + // If the method's result type has nullability, extract it. + if (auto nullability = Method->getSendResultType()->getNullability(Context)){ + // Strip off any outer nullability sugar from the provided type. + (void)AttributedType::stripOuterNullability(type); + + // Form a new attributed type using the method result type's nullability. + return Context.getAttributedType( + AttributedType::getNullabilityAttrKind(*nullability), + type, + type); + } + + return type; + }; + // If a method has a related return type: // - if the method found is an instance method, but the message send // was a class message send, T is the declared return type of the method // found if (Method->isInstanceMethod() && isClassMessage) return stripObjCInstanceType(Context, Method->getSendResultType()); - - // - if the receiver is super, T is a pointer to the class of the + + // - if the receiver is super, T is a pointer to the class of the // enclosing method definition if (isSuperMessage) { - if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) - if (ObjCInterfaceDecl *Class = CurMethod->getClassInterface()) - return Context.getObjCObjectPointerType( - Context.getObjCInterfaceType(Class)); + if (ObjCMethodDecl *CurMethod = S.getCurMethodDecl()) + if (ObjCInterfaceDecl *Class = CurMethod->getClassInterface()) { + return transferNullability( + Context.getObjCObjectPointerType( + Context.getObjCInterfaceType(Class))); + } } - + // - if the receiver is the name of a class U, T is a pointer to U if (ReceiverType->getAs<ObjCInterfaceType>() || ReceiverType->isObjCQualifiedInterfaceType()) - return Context.getObjCObjectPointerType(ReceiverType); - // - if the receiver is of type Class or qualified Class type, + return transferNullability(Context.getObjCObjectPointerType(ReceiverType)); + // - if the receiver is of type Class or qualified Class type, // T is the declared return type of the method. if (ReceiverType->isObjCClassType() || ReceiverType->isObjCQualifiedClassType()) return stripObjCInstanceType(Context, Method->getSendResultType()); - + // - if the receiver is id, qualified id, Class, or qualified Class, T // is the receiver type, otherwise // - T is the type of the receiver expression. - return ReceiverType; + return transferNullability(ReceiverType); +} + +QualType Sema::getMessageSendResultType(QualType ReceiverType, + ObjCMethodDecl *Method, + bool isClassMessage, + bool isSuperMessage) { + // Produce the result type. + QualType resultType = getBaseMessageSendResultType(*this, ReceiverType, + Method, + isClassMessage, + isSuperMessage); + + // If this is a class message, ignore the nullability of the receiver. + if (isClassMessage) + return resultType; + + // Map the nullability of the result into a table index. + unsigned receiverNullabilityIdx = 0; + if (auto nullability = ReceiverType->getNullability(Context)) + receiverNullabilityIdx = 1 + static_cast<unsigned>(*nullability); + + unsigned resultNullabilityIdx = 0; + if (auto nullability = resultType->getNullability(Context)) + resultNullabilityIdx = 1 + static_cast<unsigned>(*nullability); + + // The table of nullability mappings, indexed by the receiver's nullability + // and then the result type's nullability. + static const uint8_t None = 0; + static const uint8_t NonNull = 1; + static const uint8_t Nullable = 2; + static const uint8_t Unspecified = 3; + static const uint8_t nullabilityMap[4][4] = { + // None NonNull Nullable Unspecified + /* None */ { None, None, Nullable, None }, + /* NonNull */ { None, NonNull, Nullable, Unspecified }, + /* Nullable */ { Nullable, Nullable, Nullable, Nullable }, + /* Unspecified */ { None, Unspecified, Nullable, Unspecified } + }; + + unsigned newResultNullabilityIdx + = nullabilityMap[receiverNullabilityIdx][resultNullabilityIdx]; + if (newResultNullabilityIdx == resultNullabilityIdx) + return resultType; + + // Strip off the existing nullability. This removes as little type sugar as + // possible. + do { + if (auto attributed = dyn_cast<AttributedType>(resultType.getTypePtr())) { + resultType = attributed->getModifiedType(); + } else { + resultType = resultType.getDesugaredType(Context); + } + } while (resultType->getNullability(Context)); + + // Add nullability back if needed. + if (newResultNullabilityIdx > 0) { + auto newNullability + = static_cast<NullabilityKind>(newResultNullabilityIdx-1); + return Context.getAttributedType( + AttributedType::getNullabilityAttrKind(newNullability), + resultType, resultType); + } + + return resultType; } /// Look for an ObjC method whose result type exactly matches the given type. diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp index 610e0a9a0389..821d7f64b253 100644 --- a/lib/Sema/SemaInit.cpp +++ b/lib/Sema/SemaInit.cpp @@ -306,7 +306,8 @@ class InitListChecker { QualType CurrentObjectType, InitListExpr *StructuredList, unsigned StructuredIndex, - SourceRange InitRange); + SourceRange InitRange, + bool IsFullyOverwritten = false); void UpdateStructuredListElement(InitListExpr *StructuredList, unsigned &StructuredIndex, Expr *expr); @@ -317,11 +318,33 @@ class InitListChecker { SourceLocation Loc, const InitializedEntity &Entity, bool VerifyOnly); + + // Explanation on the "FillWithNoInit" mode: + // + // Assume we have the following definitions (Case#1): + // struct P { char x[6][6]; } xp = { .x[1] = "bar" }; + // struct PP { struct P lp; } l = { .lp = xp, .lp.x[1][2] = 'f' }; + // + // l.lp.x[1][0..1] should not be filled with implicit initializers because the + // "base" initializer "xp" will provide values for them; l.lp.x[1] will be "baf". + // + // But if we have (Case#2): + // struct PP l = { .lp = xp, .lp.x[1] = { [2] = 'f' } }; + // + // l.lp.x[1][0..1] are implicitly initialized and do not use values from the + // "base" initializer; l.lp.x[1] will be "\0\0f\0\0\0". + // + // To distinguish Case#1 from Case#2, and also to avoid leaving many "holes" + // in the InitListExpr, the "holes" in Case#1 are filled not with empty + // initializers but with special "NoInitExpr" place holders, which tells the + // CodeGen not to generate any initializers for these parts. void FillInEmptyInitForField(unsigned Init, FieldDecl *Field, const InitializedEntity &ParentEntity, - InitListExpr *ILE, bool &RequiresSecondPass); + InitListExpr *ILE, bool &RequiresSecondPass, + bool FillWithNoInit = false); void FillInEmptyInitializations(const InitializedEntity &Entity, - InitListExpr *ILE, bool &RequiresSecondPass); + InitListExpr *ILE, bool &RequiresSecondPass, + bool FillWithNoInit = false); bool CheckFlexibleArrayInit(const InitializedEntity &Entity, Expr *InitExpr, FieldDecl *Field, bool TopLevelObject); @@ -455,12 +478,26 @@ void InitListChecker::CheckEmptyInitializable(const InitializedEntity &Entity, void InitListChecker::FillInEmptyInitForField(unsigned Init, FieldDecl *Field, const InitializedEntity &ParentEntity, InitListExpr *ILE, - bool &RequiresSecondPass) { + bool &RequiresSecondPass, + bool FillWithNoInit) { SourceLocation Loc = ILE->getLocEnd(); unsigned NumInits = ILE->getNumInits(); InitializedEntity MemberEntity = InitializedEntity::InitializeMember(Field, &ParentEntity); + + if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) + if (!RType->getDecl()->isUnion()) + assert(Init < NumInits && "This ILE should have been expanded"); + if (Init >= NumInits || !ILE->getInit(Init)) { + if (FillWithNoInit) { + Expr *Filler = new (SemaRef.Context) NoInitExpr(Field->getType()); + if (Init < NumInits) + ILE->setInit(Init, Filler); + else + ILE->updateInit(SemaRef.Context, Init, Filler); + return; + } // C++1y [dcl.init.aggr]p7: // If there are fewer initializer-clauses in the list than there are // members in the aggregate, then each member not explicitly initialized @@ -516,7 +553,11 @@ void InitListChecker::FillInEmptyInitForField(unsigned Init, FieldDecl *Field, } else if (InitListExpr *InnerILE = dyn_cast<InitListExpr>(ILE->getInit(Init))) FillInEmptyInitializations(MemberEntity, InnerILE, - RequiresSecondPass); + RequiresSecondPass, FillWithNoInit); + else if (DesignatedInitUpdateExpr *InnerDIUE + = dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init))) + FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(), + RequiresSecondPass, /*FillWithNoInit =*/ true); } /// Recursively replaces NULL values within the given initializer list @@ -525,7 +566,8 @@ void InitListChecker::FillInEmptyInitForField(unsigned Init, FieldDecl *Field, void InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity, InitListExpr *ILE, - bool &RequiresSecondPass) { + bool &RequiresSecondPass, + bool FillWithNoInit) { assert((ILE->getType() != SemaRef.Context.VoidTy) && "Should not have void type"); @@ -533,16 +575,27 @@ InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity, const RecordDecl *RDecl = RType->getDecl(); if (RDecl->isUnion() && ILE->getInitializedFieldInUnion()) FillInEmptyInitForField(0, ILE->getInitializedFieldInUnion(), - Entity, ILE, RequiresSecondPass); + Entity, ILE, RequiresSecondPass, FillWithNoInit); else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) && cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) { for (auto *Field : RDecl->fields()) { if (Field->hasInClassInitializer()) { - FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass); + FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass, + FillWithNoInit); break; } } } else { + // The fields beyond ILE->getNumInits() are default initialized, so in + // order to leave them uninitialized, the ILE is expanded and the extra + // fields are then filled with NoInitExpr. + unsigned NumFields = 0; + for (auto *Field : RDecl->fields()) + if (!Field->isUnnamedBitfield()) + ++NumFields; + if (ILE->getNumInits() < NumFields) + ILE->resizeInits(SemaRef.Context, NumFields); + unsigned Init = 0; for (auto *Field : RDecl->fields()) { if (Field->isUnnamedBitfield()) @@ -551,7 +604,8 @@ InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity, if (hadError) return; - FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass); + FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass, + FillWithNoInit); if (hadError) return; @@ -594,13 +648,23 @@ InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity, ElementEntity.setElementIndex(Init); Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr); - if (!InitExpr && !ILE->hasArrayFiller()) { - ExprResult ElementInit = PerformEmptyInit(SemaRef, ILE->getLocEnd(), - ElementEntity, - /*VerifyOnly*/false); - if (ElementInit.isInvalid()) { - hadError = true; - return; + if (!InitExpr && Init < NumInits && ILE->hasArrayFiller()) + ILE->setInit(Init, ILE->getArrayFiller()); + else if (!InitExpr && !ILE->hasArrayFiller()) { + Expr *Filler = nullptr; + + if (FillWithNoInit) + Filler = new (SemaRef.Context) NoInitExpr(ElementType); + else { + ExprResult ElementInit = PerformEmptyInit(SemaRef, ILE->getLocEnd(), + ElementEntity, + /*VerifyOnly*/false); + if (ElementInit.isInvalid()) { + hadError = true; + return; + } + + Filler = ElementInit.getAs<Expr>(); } if (hadError) { @@ -609,29 +673,34 @@ InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity, // For arrays, just set the expression used for value-initialization // of the "holes" in the array. if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) - ILE->setArrayFiller(ElementInit.getAs<Expr>()); + ILE->setArrayFiller(Filler); else - ILE->setInit(Init, ElementInit.getAs<Expr>()); + ILE->setInit(Init, Filler); } else { // For arrays, just set the expression used for value-initialization // of the rest of elements and exit. if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) { - ILE->setArrayFiller(ElementInit.getAs<Expr>()); + ILE->setArrayFiller(Filler); return; } - if (!isa<ImplicitValueInitExpr>(ElementInit.get())) { + if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) { // Empty initialization requires a constructor call, so // extend the initializer list to include the constructor // call and make a note that we'll need to take another pass // through the initializer list. - ILE->updateInit(SemaRef.Context, Init, ElementInit.getAs<Expr>()); + ILE->updateInit(SemaRef.Context, Init, Filler); RequiresSecondPass = true; } } } else if (InitListExpr *InnerILE = dyn_cast_or_null<InitListExpr>(InitExpr)) - FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass); + FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass, + FillWithNoInit); + else if (DesignatedInitUpdateExpr *InnerDIUE + = dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr)) + FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(), + RequiresSecondPass, /*FillWithNoInit =*/ true); } } @@ -966,13 +1035,26 @@ void InitListChecker::CheckSubElementType(const InitializedEntity &Entity, StructuredList, StructuredIndex); if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) { - if (!SemaRef.getLangOpts().CPlusPlus) { + if (SubInitList->getNumInits() == 1 && + IsStringInit(SubInitList->getInit(0), ElemType, SemaRef.Context) == + SIF_None) { + expr = SubInitList->getInit(0); + } else if (!SemaRef.getLangOpts().CPlusPlus) { InitListExpr *InnerStructuredList = getStructuredSubobjectInit(IList, Index, ElemType, StructuredList, StructuredIndex, - SubInitList->getSourceRange()); + SubInitList->getSourceRange(), true); CheckExplicitInitList(Entity, SubInitList, ElemType, InnerStructuredList); + + if (!hadError && !VerifyOnly) { + bool RequiresSecondPass = false; + FillInEmptyInitializations(Entity, InnerStructuredList, + RequiresSecondPass); + if (RequiresSecondPass && !hadError) + FillInEmptyInitializations(Entity, InnerStructuredList, + RequiresSecondPass); + } ++StructuredIndex; ++Index; return; @@ -1913,11 +1995,66 @@ InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity, // Determine the structural initializer list that corresponds to the // current subobject. - StructuredList = IsFirstDesignator? SyntacticToSemantic.lookup(IList) - : getStructuredSubobjectInit(IList, Index, CurrentObjectType, - StructuredList, StructuredIndex, - SourceRange(D->getLocStart(), - DIE->getLocEnd())); + if (IsFirstDesignator) + StructuredList = SyntacticToSemantic.lookup(IList); + else { + Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ? + StructuredList->getInit(StructuredIndex) : nullptr; + if (!ExistingInit && StructuredList->hasArrayFiller()) + ExistingInit = StructuredList->getArrayFiller(); + + if (!ExistingInit) + StructuredList = + getStructuredSubobjectInit(IList, Index, CurrentObjectType, + StructuredList, StructuredIndex, + SourceRange(D->getLocStart(), + DIE->getLocEnd())); + else if (InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit)) + StructuredList = Result; + else { + if (DesignatedInitUpdateExpr *E = + dyn_cast<DesignatedInitUpdateExpr>(ExistingInit)) + StructuredList = E->getUpdater(); + else { + DesignatedInitUpdateExpr *DIUE = + new (SemaRef.Context) DesignatedInitUpdateExpr(SemaRef.Context, + D->getLocStart(), ExistingInit, + DIE->getLocEnd()); + StructuredList->updateInit(SemaRef.Context, StructuredIndex, DIUE); + StructuredList = DIUE->getUpdater(); + } + + // We need to check on source range validity because the previous + // initializer does not have to be an explicit initializer. e.g., + // + // struct P { int a, b; }; + // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 }; + // + // There is an overwrite taking place because the first braced initializer + // list "{ .a = 2 }" already provides value for .p.b (which is zero). + if (ExistingInit->getSourceRange().isValid()) { + // We are creating an initializer list that initializes the + // subobjects of the current object, but there was already an + // initialization that completely initialized the current + // subobject, e.g., by a compound literal: + // + // struct X { int a, b; }; + // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 }; + // + // Here, xs[0].a == 0 and xs[0].b == 3, since the second, + // designated initializer re-initializes the whole + // subobject [0], overwriting previous initializers. + SemaRef.Diag(D->getLocStart(), + diag::warn_subobject_initializer_overrides) + << SourceRange(D->getLocStart(), DIE->getLocEnd()); + + SemaRef.Diag(ExistingInit->getLocStart(), + diag::note_previous_initializer) + << /*FIXME:has side effects=*/0 + << ExistingInit->getSourceRange(); + } + } + } assert(StructuredList && "Expected a structured initializer list"); } @@ -2367,7 +2504,8 @@ InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index, QualType CurrentObjectType, InitListExpr *StructuredList, unsigned StructuredIndex, - SourceRange InitRange) { + SourceRange InitRange, + bool IsFullyOverwritten) { if (VerifyOnly) return nullptr; // No structured list in verification-only mode. Expr *ExistingInit = nullptr; @@ -2377,7 +2515,16 @@ InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index, ExistingInit = StructuredList->getInit(StructuredIndex); if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit)) - return Result; + // There might have already been initializers for subobjects of the current + // object, but a subsequent initializer list will overwrite the entirety + // of the current object. (See DR 253 and C99 6.7.8p21). e.g., + // + // struct P { char x[6]; }; + // struct P l = { .x[2] = 'x', .x = { [0] = 'f' } }; + // + // The first designated initializer is ignored, and l.x is just "f". + if (!IsFullyOverwritten) + return Result; if (ExistingInit) { // We are creating an initializer list that initializes the @@ -2469,13 +2616,22 @@ void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList, if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context, StructuredIndex, expr)) { // This initializer overwrites a previous initializer. Warn. - SemaRef.Diag(expr->getLocStart(), - diag::warn_initializer_overrides) - << expr->getSourceRange(); - SemaRef.Diag(PrevInit->getLocStart(), - diag::note_previous_initializer) - << /*FIXME:has side effects=*/0 - << PrevInit->getSourceRange(); + // We need to check on source range validity because the previous + // initializer does not have to be an explicit initializer. + // struct P { int a, b; }; + // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 }; + // There is an overwrite taking place because the first braced initializer + // list "{ .a = 2 }' already provides value for .p.b (which is zero). + if (PrevInit->getSourceRange().isValid()) { + SemaRef.Diag(expr->getLocStart(), + diag::warn_initializer_overrides) + << expr->getSourceRange(); + + SemaRef.Diag(PrevInit->getLocStart(), + diag::note_previous_initializer) + << /*FIXME:has side effects=*/0 + << PrevInit->getSourceRange(); + } } ++StructuredIndex; diff --git a/lib/Sema/SemaLookup.cpp b/lib/Sema/SemaLookup.cpp index d0a55b57c61f..3fd1f21ba3fd 100644 --- a/lib/Sema/SemaLookup.cpp +++ b/lib/Sema/SemaLookup.cpp @@ -1233,6 +1233,12 @@ void Sema::makeMergedDefinitionVisible(NamedDecl *ND, SourceLocation Loc) { else // We're not building a module; just make the definition visible. ND->setHidden(false); + + // If ND is a template declaration, make the template parameters + // visible too. They're not (necessarily) within a mergeable DeclContext. + if (auto *TD = dyn_cast<TemplateDecl>(ND)) + for (auto *Param : *TD->getTemplateParameters()) + makeMergedDefinitionVisible(Param, Loc); } /// \brief Find the module in which the given declaration was defined. @@ -1282,6 +1288,41 @@ bool Sema::hasVisibleMergedDefinition(NamedDecl *Def) { return false; } +template<typename ParmDecl> +static bool +hasVisibleDefaultArgument(Sema &S, const ParmDecl *D, + llvm::SmallVectorImpl<Module *> *Modules) { + if (!D->hasDefaultArgument()) + return false; + + while (D) { + auto &DefaultArg = D->getDefaultArgStorage(); + if (!DefaultArg.isInherited() && S.isVisible(D)) + return true; + + if (!DefaultArg.isInherited() && Modules) { + auto *NonConstD = const_cast<ParmDecl*>(D); + Modules->push_back(S.getOwningModule(NonConstD)); + const auto &Merged = S.Context.getModulesWithMergedDefinition(NonConstD); + Modules->insert(Modules->end(), Merged.begin(), Merged.end()); + } + + // If there was a previous default argument, maybe its parameter is visible. + D = DefaultArg.getInheritedFrom(); + } + return false; +} + +bool Sema::hasVisibleDefaultArgument(const NamedDecl *D, + llvm::SmallVectorImpl<Module *> *Modules) { + if (auto *P = dyn_cast<TemplateTypeParmDecl>(D)) + return ::hasVisibleDefaultArgument(*this, P, Modules); + if (auto *P = dyn_cast<NonTypeTemplateParmDecl>(D)) + return ::hasVisibleDefaultArgument(*this, P, Modules); + return ::hasVisibleDefaultArgument(*this, cast<TemplateTemplateParmDecl>(D), + Modules); +} + /// \brief Determine whether a declaration is visible to name lookup. /// /// This routine determines whether the declaration D is visible in the current @@ -3006,6 +3047,9 @@ void Sema::ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc, if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) continue; + if (!isVisible(D) && !(D = findAcceptableDecl(*this, D))) + continue; + Result.insert(D); } } @@ -4632,6 +4676,76 @@ static NamedDecl *getDefinitionToImport(NamedDecl *D) { return nullptr; } +void Sema::diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl, + bool NeedDefinition, bool Recover) { + assert(!isVisible(Decl) && "missing import for non-hidden decl?"); + + // Suggest importing a module providing the definition of this entity, if + // possible. + NamedDecl *Def = getDefinitionToImport(Decl); + if (!Def) + Def = Decl; + + // FIXME: Add a Fix-It that imports the corresponding module or includes + // the header. + Module *Owner = getOwningModule(Decl); + assert(Owner && "definition of hidden declaration is not in a module"); + + llvm::SmallVector<Module*, 8> OwningModules; + OwningModules.push_back(Owner); + auto Merged = Context.getModulesWithMergedDefinition(Decl); + OwningModules.insert(OwningModules.end(), Merged.begin(), Merged.end()); + + diagnoseMissingImport(Loc, Decl, Decl->getLocation(), OwningModules, + NeedDefinition ? MissingImportKind::Definition + : MissingImportKind::Declaration, + Recover); +} + +void Sema::diagnoseMissingImport(SourceLocation UseLoc, NamedDecl *Decl, + SourceLocation DeclLoc, + ArrayRef<Module *> Modules, + MissingImportKind MIK, bool Recover) { + assert(!Modules.empty()); + + if (Modules.size() > 1) { + std::string ModuleList; + unsigned N = 0; + for (Module *M : Modules) { + ModuleList += "\n "; + if (++N == 5 && N != Modules.size()) { + ModuleList += "[...]"; + break; + } + ModuleList += M->getFullModuleName(); + } + + Diag(UseLoc, diag::err_module_unimported_use_multiple) + << (int)MIK << Decl << ModuleList; + } else { + Diag(UseLoc, diag::err_module_unimported_use) + << (int)MIK << Decl << Modules[0]->getFullModuleName(); + } + + unsigned DiagID; + switch (MIK) { + case MissingImportKind::Declaration: + DiagID = diag::note_previous_declaration; + break; + case MissingImportKind::Definition: + DiagID = diag::note_previous_definition; + break; + case MissingImportKind::DefaultArgument: + DiagID = diag::note_default_argument_declared_here; + break; + } + Diag(DeclLoc, DiagID); + + // Try to recover by implicitly importing this module. + if (Recover) + createImplicitModuleImportForErrorRecovery(UseLoc, Modules[0]); +} + /// \brief Diagnose a successfully-corrected typo. Separated from the correction /// itself to allow external validation of the result, etc. /// @@ -4658,23 +4772,8 @@ void Sema::diagnoseTypo(const TypoCorrection &Correction, NamedDecl *Decl = Correction.getCorrectionDecl(); assert(Decl && "import required but no declaration to import"); - // Suggest importing a module providing the definition of this entity, if - // possible. - NamedDecl *Def = getDefinitionToImport(Decl); - if (!Def) - Def = Decl; - Module *Owner = getOwningModule(Def); - assert(Owner && "definition of hidden declaration is not in a module"); - - Diag(Correction.getCorrectionRange().getBegin(), - diag::err_module_private_declaration) - << Def << Owner->getFullModuleName(); - Diag(Def->getLocation(), diag::note_previous_declaration); - - // Recover by implicitly importing this module. - if (ErrorRecovery) - createImplicitModuleImportForErrorRecovery( - Correction.getCorrectionRange().getBegin(), Owner); + diagnoseMissingImport(Correction.getCorrectionRange().getBegin(), Decl, + /*NeedDefinition*/ false, ErrorRecovery); return; } diff --git a/lib/Sema/SemaObjCProperty.cpp b/lib/Sema/SemaObjCProperty.cpp index 5e7b4b8b859d..87fb5b6913a3 100644 --- a/lib/Sema/SemaObjCProperty.cpp +++ b/lib/Sema/SemaObjCProperty.cpp @@ -103,15 +103,6 @@ static void checkARCPropertyDecl(Sema &S, ObjCPropertyDecl *property) { << propertyLifetime; } -static unsigned deduceWeakPropertyFromType(Sema &S, QualType T) { - if ((S.getLangOpts().getGC() != LangOptions::NonGC && - T.isObjCGCWeak()) || - (S.getLangOpts().ObjCAutoRefCount && - T.getObjCLifetime() == Qualifiers::OCL_Weak)) - return ObjCDeclSpec::DQ_PR_weak; - return 0; -} - /// \brief Check this Objective-C property against a property declared in the /// given protocol. static void @@ -146,10 +137,10 @@ Decl *Sema::ActOnProperty(Scope *S, SourceLocation AtLoc, tok::ObjCKeywordKind MethodImplKind, DeclContext *lexicalDC) { unsigned Attributes = ODS.getPropertyAttributes(); + FD.D.setObjCWeakProperty((Attributes & ObjCDeclSpec::DQ_PR_weak) != 0); TypeSourceInfo *TSI = GetTypeForDeclarator(FD.D, S); QualType T = TSI->getType(); - Attributes |= deduceWeakPropertyFromType(*this, T); - + Attributes |= deduceWeakPropertyFromType(T); bool isReadWrite = ((Attributes & ObjCDeclSpec::DQ_PR_readwrite) || // default is readwrite! !(Attributes & ObjCDeclSpec::DQ_PR_readonly)); @@ -173,7 +164,7 @@ Decl *Sema::ActOnProperty(Scope *S, SourceLocation AtLoc, isAssign, isReadWrite, Attributes, ODS.getPropertyAttributes(), - isOverridingProperty, TSI, + isOverridingProperty, T, TSI, MethodImplKind); if (!Res) return nullptr; @@ -184,7 +175,7 @@ Decl *Sema::ActOnProperty(Scope *S, SourceLocation AtLoc, Res = CreatePropertyDecl(S, ClassDecl, AtLoc, LParenLoc, FD, GetterSel, SetterSel, isAssign, isReadWrite, Attributes, ODS.getPropertyAttributes(), - TSI, MethodImplKind); + T, TSI, MethodImplKind); if (lexicalDC) Res->setLexicalDeclContext(lexicalDC); } @@ -322,7 +313,8 @@ Sema::HandlePropertyInClassExtension(Scope *S, const unsigned Attributes, const unsigned AttributesAsWritten, bool *isOverridingProperty, - TypeSourceInfo *T, + QualType T, + TypeSourceInfo *TSI, tok::ObjCKeywordKind MethodImplKind) { ObjCCategoryDecl *CDecl = cast<ObjCCategoryDecl>(CurContext); // Diagnose if this property is already in continuation class. @@ -348,7 +340,7 @@ Sema::HandlePropertyInClassExtension(Scope *S, // FIXME. We should really be using CreatePropertyDecl for this. ObjCPropertyDecl *PDecl = ObjCPropertyDecl::Create(Context, DC, FD.D.getIdentifierLoc(), - PropertyId, AtLoc, LParenLoc, T); + PropertyId, AtLoc, LParenLoc, T, TSI); PDecl->setPropertyAttributesAsWritten( makePropertyAttributesAsWritten(AttributesAsWritten)); if (Attributes & ObjCDeclSpec::DQ_PR_readonly) @@ -359,6 +351,11 @@ Sema::HandlePropertyInClassExtension(Scope *S, PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic); if (Attributes & ObjCDeclSpec::DQ_PR_atomic) PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_atomic); + if (Attributes & ObjCDeclSpec::DQ_PR_nullability) + PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nullability); + if (Attributes & ObjCDeclSpec::DQ_PR_null_resettable) + PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_null_resettable); + // Set setter/getter selector name. Needed later. PDecl->setGetterName(GetterSel); PDecl->setSetterName(SetterSel); @@ -383,7 +380,8 @@ Sema::HandlePropertyInClassExtension(Scope *S, ObjCPropertyDecl *PrimaryPDecl = CreatePropertyDecl(S, CCPrimary, AtLoc, LParenLoc, FD, GetterSel, SetterSel, isAssign, isReadWrite, - Attributes,AttributesAsWritten, T, MethodImplKind, DC); + Attributes,AttributesAsWritten, T, TSI, MethodImplKind, + DC); // A case of continuation class adding a new property in the class. This // is not what it was meant for. However, gcc supports it and so should we. @@ -427,7 +425,7 @@ Sema::HandlePropertyInClassExtension(Scope *S, if (isReadWrite && (PIkind & ObjCPropertyDecl::OBJC_PR_readonly)) { PIkind &= ~ObjCPropertyDecl::OBJC_PR_readonly; PIkind |= ObjCPropertyDecl::OBJC_PR_readwrite; - PIkind |= deduceWeakPropertyFromType(*this, PIDecl->getType()); + PIkind |= deduceWeakPropertyFromType(PIDecl->getType()); unsigned ClassExtensionMemoryModel = getOwnershipRule(Attributes); unsigned PrimaryClassMemoryModel = getOwnershipRule(PIkind); if (PrimaryClassMemoryModel && ClassExtensionMemoryModel && @@ -531,11 +529,11 @@ ObjCPropertyDecl *Sema::CreatePropertyDecl(Scope *S, const bool isReadWrite, const unsigned Attributes, const unsigned AttributesAsWritten, + QualType T, TypeSourceInfo *TInfo, tok::ObjCKeywordKind MethodImplKind, DeclContext *lexicalDC){ IdentifierInfo *PropertyId = FD.D.getIdentifier(); - QualType T = TInfo->getType(); // Issue a warning if property is 'assign' as default and its object, which is // gc'able conforms to NSCopying protocol @@ -564,7 +562,8 @@ ObjCPropertyDecl *Sema::CreatePropertyDecl(Scope *S, DeclContext *DC = cast<DeclContext>(CDecl); ObjCPropertyDecl *PDecl = ObjCPropertyDecl::Create(Context, DC, FD.D.getIdentifierLoc(), - PropertyId, AtLoc, LParenLoc, TInfo); + PropertyId, AtLoc, + LParenLoc, T, TInfo); if (ObjCPropertyDecl *prevDecl = ObjCPropertyDecl::findPropertyDecl(DC, PropertyId)) { @@ -639,6 +638,12 @@ ObjCPropertyDecl *Sema::CreatePropertyDecl(Scope *S, else if (MethodImplKind == tok::objc_optional) PDecl->setPropertyImplementation(ObjCPropertyDecl::Optional); + if (Attributes & ObjCDeclSpec::DQ_PR_nullability) + PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nullability); + + if (Attributes & ObjCDeclSpec::DQ_PR_null_resettable) + PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_null_resettable); + return PDecl; } @@ -1753,6 +1758,33 @@ void Sema::DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl, } } +void Sema::diagnoseNullResettableSynthesizedSetters(ObjCImplDecl *impDecl) { + for (const auto *propertyImpl : impDecl->property_impls()) { + const auto *property = propertyImpl->getPropertyDecl(); + + // Warn about null_resettable properties with synthesized setters, + // because the setter won't properly handle nil. + if (propertyImpl->getPropertyImplementation() + == ObjCPropertyImplDecl::Synthesize && + (property->getPropertyAttributes() & + ObjCPropertyDecl::OBJC_PR_null_resettable) && + property->getGetterMethodDecl() && + property->getSetterMethodDecl()) { + auto *getterMethod = property->getGetterMethodDecl(); + auto *setterMethod = property->getSetterMethodDecl(); + if (!impDecl->getInstanceMethod(setterMethod->getSelector()) && + !impDecl->getInstanceMethod(getterMethod->getSelector())) { + SourceLocation loc = propertyImpl->getLocation(); + if (loc.isInvalid()) + loc = impDecl->getLocStart(); + + Diag(loc, diag::warn_null_resettable_setter) + << setterMethod->getSelector() << property->getDeclName(); + } + } + } +} + void Sema::AtomicPropertySetterGetterRules (ObjCImplDecl* IMPDecl, ObjCContainerDecl* IDecl) { @@ -1988,9 +2020,21 @@ void Sema::ProcessPropertyDecl(ObjCPropertyDecl *property, redeclaredProperty->getLocation() : property->getLocation(); + // If the property is null_resettable, the getter returns nonnull. + QualType resultTy = property->getType(); + if (property->getPropertyAttributes() & + ObjCPropertyDecl::OBJC_PR_null_resettable) { + QualType modifiedTy = resultTy; + if (auto nullability = AttributedType::stripOuterNullability(modifiedTy)){ + if (*nullability == NullabilityKind::Unspecified) + resultTy = Context.getAttributedType(AttributedType::attr_nonnull, + modifiedTy, modifiedTy); + } + } + GetterMethod = ObjCMethodDecl::Create(Context, Loc, Loc, property->getGetterName(), - property->getType(), nullptr, CD, + resultTy, nullptr, CD, /*isInstance=*/true, /*isVariadic=*/false, /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true, /*isDefined=*/false, @@ -2051,12 +2095,25 @@ void Sema::ProcessPropertyDecl(ObjCPropertyDecl *property, ObjCMethodDecl::Optional : ObjCMethodDecl::Required); + // If the property is null_resettable, the setter accepts a + // nullable value. + QualType paramTy = property->getType().getUnqualifiedType(); + if (property->getPropertyAttributes() & + ObjCPropertyDecl::OBJC_PR_null_resettable) { + QualType modifiedTy = paramTy; + if (auto nullability = AttributedType::stripOuterNullability(modifiedTy)){ + if (*nullability == NullabilityKind::Unspecified) + paramTy = Context.getAttributedType(AttributedType::attr_nullable, + modifiedTy, modifiedTy); + } + } + // Invent the arguments for the setter. We don't bother making a // nice name for the argument. ParmVarDecl *Argument = ParmVarDecl::Create(Context, SetterMethod, Loc, Loc, property->getIdentifier(), - property->getType().getUnqualifiedType(), + paramTy, /*TInfo=*/nullptr, SC_None, nullptr); @@ -2228,6 +2285,22 @@ void Sema::CheckObjCPropertyAttributes(Decl *PDecl, Attributes &= ~ObjCDeclSpec::DQ_PR_weak; } + if (Attributes & ObjCDeclSpec::DQ_PR_weak) { + // 'weak' and 'nonnull' are mutually exclusive. + if (auto nullability = PropertyTy->getNullability(Context)) { + if (*nullability == NullabilityKind::NonNull) + Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) + << "nonnull" << "weak"; + } else { + PropertyTy = + Context.getAttributedType( + AttributedType::getNullabilityAttrKind(NullabilityKind::Nullable), + PropertyTy, PropertyTy); + TypeSourceInfo *TSInfo = PropertyDecl->getTypeSourceInfo(); + PropertyDecl->setType(PropertyTy, TSInfo); + } + } + if ((Attributes & ObjCDeclSpec::DQ_PR_atomic) && (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)) { Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) diff --git a/lib/Sema/SemaOpenMP.cpp b/lib/Sema/SemaOpenMP.cpp index cfe8db3d658c..e609fcf1d9be 100644 --- a/lib/Sema/SemaOpenMP.cpp +++ b/lib/Sema/SemaOpenMP.cpp @@ -1270,6 +1270,14 @@ void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) { Params); break; } + case OMPD_taskgroup: { + Sema::CapturedParamNameType Params[] = { + std::make_pair(StringRef(), QualType()) // __context with shared vars + }; + ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP, + Params); + break; + } case OMPD_threadprivate: case OMPD_taskyield: case OMPD_barrier: @@ -1335,6 +1343,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | parallel | taskyield | * | // | parallel | barrier | * | // | parallel | taskwait | * | + // | parallel | taskgroup | * | // | parallel | flush | * | // | parallel | ordered | + | // | parallel | atomic | * | @@ -1357,6 +1366,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | for | taskyield | * | // | for | barrier | + | // | for | taskwait | * | + // | for | taskgroup | * | // | for | flush | * | // | for | ordered | * (if construct is ordered) | // | for | atomic | * | @@ -1379,6 +1389,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | master | taskyield | * | // | master | barrier | + | // | master | taskwait | * | + // | master | taskgroup | * | // | master | flush | * | // | master | ordered | + | // | master | atomic | * | @@ -1401,6 +1412,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | critical | taskyield | * | // | critical | barrier | + | // | critical | taskwait | * | + // | critical | taskgroup | * | // | critical | ordered | + | // | critical | atomic | * | // | critical | target | * | @@ -1422,6 +1434,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | simd | taskyield | | // | simd | barrier | | // | simd | taskwait | | + // | simd | taskgroup | | // | simd | flush | | // | simd | ordered | | // | simd | atomic | | @@ -1444,6 +1457,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | for simd | taskyield | | // | for simd | barrier | | // | for simd | taskwait | | + // | for simd | taskgroup | | // | for simd | flush | | // | for simd | ordered | | // | for simd | atomic | | @@ -1466,6 +1480,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | parallel for simd| taskyield | | // | parallel for simd| barrier | | // | parallel for simd| taskwait | | + // | parallel for simd| taskgroup | | // | parallel for simd| flush | | // | parallel for simd| ordered | | // | parallel for simd| atomic | | @@ -1488,6 +1503,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | sections | taskyield | * | // | sections | barrier | + | // | sections | taskwait | * | + // | sections | taskgroup | * | // | sections | flush | * | // | sections | ordered | + | // | sections | atomic | * | @@ -1510,6 +1526,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | section | taskyield | * | // | section | barrier | + | // | section | taskwait | * | + // | section | taskgroup | * | // | section | flush | * | // | section | ordered | + | // | section | atomic | * | @@ -1532,6 +1549,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | single | taskyield | * | // | single | barrier | + | // | single | taskwait | * | + // | single | taskgroup | * | // | single | flush | * | // | single | ordered | + | // | single | atomic | * | @@ -1554,6 +1572,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | parallel for | taskyield | * | // | parallel for | barrier | + | // | parallel for | taskwait | * | + // | parallel for | taskgroup | * | // | parallel for | flush | * | // | parallel for | ordered | * (if construct is ordered) | // | parallel for | atomic | * | @@ -1576,6 +1595,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | parallel sections| taskyield | * | // | parallel sections| barrier | + | // | parallel sections| taskwait | * | + // | parallel sections| taskgroup | * | // | parallel sections| flush | * | // | parallel sections| ordered | + | // | parallel sections| atomic | * | @@ -1598,6 +1618,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | task | taskyield | * | // | task | barrier | + | // | task | taskwait | * | + // | task | taskgroup | * | // | task | flush | * | // | task | ordered | + | // | task | atomic | * | @@ -1620,6 +1641,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | ordered | taskyield | * | // | ordered | barrier | + | // | ordered | taskwait | * | + // | ordered | taskgroup | * | // | ordered | flush | * | // | ordered | ordered | + | // | ordered | atomic | * | @@ -1642,6 +1664,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | atomic | taskyield | | // | atomic | barrier | | // | atomic | taskwait | | + // | atomic | taskgroup | | // | atomic | flush | | // | atomic | ordered | | // | atomic | atomic | | @@ -1664,6 +1687,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | target | taskyield | * | // | target | barrier | * | // | target | taskwait | * | + // | target | taskgroup | * | // | target | flush | * | // | target | ordered | * | // | target | atomic | * | @@ -1686,6 +1710,7 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | teams | taskyield | + | // | teams | barrier | + | // | teams | taskwait | + | + // | teams | taskgroup | + | // | teams | flush | + | // | teams | ordered | + | // | teams | atomic | + | @@ -1936,6 +1961,11 @@ StmtResult Sema::ActOnOpenMPExecutableDirective(OpenMPDirectiveKind Kind, "No associated statement allowed for 'omp taskwait' directive"); Res = ActOnOpenMPTaskwaitDirective(StartLoc, EndLoc); break; + case OMPD_taskgroup: + assert(ClausesWithImplicit.empty() && + "No clauses are allowed for 'omp taskgroup' directive"); + Res = ActOnOpenMPTaskgroupDirective(AStmt, StartLoc, EndLoc); + break; case OMPD_flush: assert(AStmt == nullptr && "No associated statement allowed for 'omp flush' directive"); @@ -2939,9 +2969,6 @@ CheckOpenMPLoop(OpenMPDirectiveKind DKind, Expr *NestedLoopCountExpr, ? SemaRef.BuildBinOp(CurScope, CondLoc, BO_LE, IV.get(), UB.get()) : SemaRef.BuildBinOp(CurScope, CondLoc, BO_LT, IV.get(), NumIterations.get()); - // Loop condition with 1 iteration separated (IV < LastIteration) - ExprResult SeparatedCond = SemaRef.BuildBinOp(CurScope, CondLoc, BO_LT, - IV.get(), LastIteration.get()); // Loop increment (IV = IV + 1) SourceLocation IncLoc; @@ -3071,7 +3098,6 @@ CheckOpenMPLoop(OpenMPDirectiveKind DKind, Expr *NestedLoopCountExpr, Built.CalcLastIteration = CalcLastIteration.get(); Built.PreCond = PreCond.get(); Built.Cond = Cond.get(); - Built.SeparatedCond = SeparatedCond.get(); Built.Init = Init.get(); Built.Inc = Inc.get(); Built.LB = LB.get(); @@ -3161,6 +3187,16 @@ StmtResult Sema::ActOnOpenMPForSimdDirective( assert((CurContext->isDependentContext() || B.builtAll()) && "omp for simd loop exprs were not built"); + if (!CurContext->isDependentContext()) { + // Finalize the clauses that need pre-built expressions for CodeGen. + for (auto C : Clauses) { + if (auto LC = dyn_cast<OMPLinearClause>(C)) + if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef), + B.NumIterations, *this, CurScope)) + return StmtError(); + } + } + getCurFunction()->setHasBranchProtectedScope(); return OMPForSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B); @@ -3310,6 +3346,16 @@ StmtResult Sema::ActOnOpenMPParallelForSimdDirective( if (NestedLoopCount == 0) return StmtError(); + if (!CurContext->isDependentContext()) { + // Finalize the clauses that need pre-built expressions for CodeGen. + for (auto C : Clauses) { + if (auto LC = dyn_cast<OMPLinearClause>(C)) + if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef), + B.NumIterations, *this, CurScope)) + return StmtError(); + } + } + getCurFunction()->setHasBranchProtectedScope(); return OMPParallelForSimdDirective::Create( Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B); @@ -3382,6 +3428,16 @@ StmtResult Sema::ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc, return OMPTaskwaitDirective::Create(Context, StartLoc, EndLoc); } +StmtResult Sema::ActOnOpenMPTaskgroupDirective(Stmt *AStmt, + SourceLocation StartLoc, + SourceLocation EndLoc) { + assert(AStmt && isa<CapturedStmt>(AStmt) && "Captured statement expected"); + + getCurFunction()->setHasBranchProtectedScope(); + + return OMPTaskgroupDirective::Create(Context, StartLoc, EndLoc, AStmt); +} + StmtResult Sema::ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses, SourceLocation StartLoc, SourceLocation EndLoc) { diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp index 9d87a103ac66..a0fdcd78e596 100644 --- a/lib/Sema/SemaOverload.cpp +++ b/lib/Sema/SemaOverload.cpp @@ -10507,7 +10507,8 @@ DiagnoseTwoPhaseLookup(Sema &SemaRef, SourceLocation FnLoc, const CXXScopeSpec &SS, LookupResult &R, OverloadCandidateSet::CandidateSetKind CSK, TemplateArgumentListInfo *ExplicitTemplateArgs, - ArrayRef<Expr *> Args) { + ArrayRef<Expr *> Args, + bool *DoDiagnoseEmptyLookup = nullptr) { if (SemaRef.ActiveTemplateInstantiations.empty() || !SS.isEmpty()) return false; @@ -10524,6 +10525,8 @@ DiagnoseTwoPhaseLookup(Sema &SemaRef, SourceLocation FnLoc, // Don't diagnose names we find in classes; we get much better // diagnostics for these from DiagnoseEmptyLookup. R.clear(); + if (DoDiagnoseEmptyLookup) + *DoDiagnoseEmptyLookup = true; return false; } @@ -10673,15 +10676,16 @@ BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(), Sema::LookupOrdinaryName); + bool DoDiagnoseEmptyLookup = EmptyLookup; if (!DiagnoseTwoPhaseLookup(SemaRef, Fn->getExprLoc(), SS, R, OverloadCandidateSet::CSK_Normal, - ExplicitTemplateArgs, Args) && - (!EmptyLookup || - SemaRef.DiagnoseEmptyLookup( - S, SS, R, - MakeValidator(SemaRef, dyn_cast<MemberExpr>(Fn), Args.size(), - ExplicitTemplateArgs != nullptr, AllowTypoCorrection), - ExplicitTemplateArgs, Args))) + ExplicitTemplateArgs, Args, + &DoDiagnoseEmptyLookup) && + (!DoDiagnoseEmptyLookup || SemaRef.DiagnoseEmptyLookup( + S, SS, R, + MakeValidator(SemaRef, dyn_cast<MemberExpr>(Fn), Args.size(), + ExplicitTemplateArgs != nullptr, AllowTypoCorrection), + ExplicitTemplateArgs, Args))) return ExprError(); assert(!R.empty() && "lookup results empty despite recovery"); @@ -10746,26 +10750,29 @@ bool Sema::buildOverloadedCallSet(Scope *S, Expr *Fn, // functions, including those from argument-dependent lookup. AddOverloadedCallCandidates(ULE, Args, *CandidateSet); - // If we found nothing, try to recover. - // BuildRecoveryCallExpr diagnoses the error itself, so we just bail - // out if it fails. - if (CandidateSet->empty()) { - // In Microsoft mode, if we are inside a template class member function then - // create a type dependent CallExpr. The goal is to postpone name lookup - // to instantiation time to be able to search into type dependent base - // classes. - if (getLangOpts().MSVCCompat && CurContext->isDependentContext() && - (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) { - CallExpr *CE = new (Context) CallExpr(Context, Fn, Args, - Context.DependentTy, VK_RValue, - RParenLoc); + if (getLangOpts().MSVCCompat && + CurContext->isDependentContext() && !isSFINAEContext() && + (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) { + + OverloadCandidateSet::iterator Best; + if (CandidateSet->empty() || + CandidateSet->BestViableFunction(*this, Fn->getLocStart(), Best) == + OR_No_Viable_Function) { + // In Microsoft mode, if we are inside a template class member function then + // create a type dependent CallExpr. The goal is to postpone name lookup + // to instantiation time to be able to search into type dependent base + // classes. + CallExpr *CE = new (Context) CallExpr( + Context, Fn, Args, Context.DependentTy, VK_RValue, RParenLoc); CE->setTypeDependent(true); *Result = CE; return true; } - return false; } + if (CandidateSet->empty()) + return false; + UnbridgedCasts.restore(); return false; } @@ -11253,7 +11260,7 @@ Sema::CreateOverloadedBinOp(SourceLocation OpLoc, if (Op == OO_Equal) DiagnoseSelfMove(Args[0], Args[1], OpLoc); - checkCall(FnDecl, ArgsArray, 0, isa<CXXMethodDecl>(FnDecl), OpLoc, + checkCall(FnDecl, nullptr, ArgsArray, isa<CXXMethodDecl>(FnDecl), OpLoc, TheCall->getSourceRange(), VariadicDoesNotApply); return MaybeBindToTemporary(TheCall); diff --git a/lib/Sema/SemaStmt.cpp b/lib/Sema/SemaStmt.cpp index 5c72529caa8a..50e4345216a6 100644 --- a/lib/Sema/SemaStmt.cpp +++ b/lib/Sema/SemaStmt.cpp @@ -3432,7 +3432,7 @@ class CatchHandlerType { public: /// Used when creating a CatchHandlerType from a handler type; will determine - /// whether the type is a pointer or reference and will strip off the the top + /// whether the type is a pointer or reference and will strip off the top /// level pointer and cv-qualifiers. CatchHandlerType(QualType Q) : QT(Q), IsPointer(false) { if (QT->isPointerType()) diff --git a/lib/Sema/SemaStmtAttr.cpp b/lib/Sema/SemaStmtAttr.cpp index 19e2c8ed652f..5b71c11b5297 100644 --- a/lib/Sema/SemaStmtAttr.cpp +++ b/lib/Sema/SemaStmtAttr.cpp @@ -105,6 +105,8 @@ static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const AttributeList &A, if (StateLoc && StateLoc->Ident) { if (StateLoc->Ident->isStr("disable")) State = LoopHintAttr::Disable; + else if (StateLoc->Ident->isStr("assume_safety")) + State = LoopHintAttr::AssumeSafety; else State = LoopHintAttr::Enable; } @@ -159,7 +161,7 @@ CheckForIncompatibleAttributes(Sema &S, const LoopHintAttr *PrevAttr; if (Option == LoopHintAttr::Vectorize || Option == LoopHintAttr::Interleave || Option == LoopHintAttr::Unroll) { - // Enable|disable hint. For example, vectorize(enable). + // Enable|Disable|AssumeSafety hint. For example, vectorize(enable). PrevAttr = CategoryState.StateAttr; CategoryState.StateAttr = LH; } else { diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp index 19c0f2a9390d..f4740a5cd855 100644 --- a/lib/Sema/SemaTemplate.cpp +++ b/lib/Sema/SemaTemplate.cpp @@ -602,7 +602,7 @@ Decl *Sema::ActOnTypeParameter(Scope *S, bool Typename, return Param; } - Param->setDefaultArgument(DefaultTInfo, false); + Param->setDefaultArgument(DefaultTInfo); } return Param; @@ -723,7 +723,7 @@ Decl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, } Default = DefaultRes.get(); - Param->setDefaultArgument(Default, false); + Param->setDefaultArgument(Default); } return Param; @@ -799,7 +799,7 @@ Decl *Sema::ActOnTemplateTemplateParameter(Scope* S, UPPC_DefaultArgument)) return Param; - Param->setDefaultArgument(DefaultArg, false); + Param->setDefaultArgument(Context, DefaultArg); } return Param; @@ -1310,15 +1310,11 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, // Merge default arguments for template type parameters. TemplateTypeParmDecl *OldTypeParm = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : nullptr; - // FIXME: There might be a visible declaration of this template parameter. - if (OldTypeParm && !LookupResult::isVisible(*this, OldTypeParm)) - OldTypeParm = nullptr; - if (NewTypeParm->isParameterPack()) { assert(!NewTypeParm->hasDefaultArgument() && "Parameter packs can't have a default argument!"); SawParameterPack = true; - } else if (OldTypeParm && OldTypeParm->hasDefaultArgument() && + } else if (OldTypeParm && hasVisibleDefaultArgument(OldTypeParm) && NewTypeParm->hasDefaultArgument()) { OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc(); NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc(); @@ -1328,8 +1324,7 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) { // Merge the default argument from the old declaration to the // new declaration. - NewTypeParm->setDefaultArgument(OldTypeParm->getDefaultArgumentInfo(), - true); + NewTypeParm->setInheritedDefaultArgument(Context, OldTypeParm); PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc(); } else if (NewTypeParm->hasDefaultArgument()) { SawDefaultArgument = true; @@ -1358,14 +1353,12 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, // Merge default arguments for non-type template parameters NonTypeTemplateParmDecl *OldNonTypeParm = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : nullptr; - if (OldNonTypeParm && !LookupResult::isVisible(*this, OldNonTypeParm)) - OldNonTypeParm = nullptr; if (NewNonTypeParm->isParameterPack()) { assert(!NewNonTypeParm->hasDefaultArgument() && "Parameter packs can't have a default argument!"); if (!NewNonTypeParm->isPackExpansion()) SawParameterPack = true; - } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument() && + } else if (OldNonTypeParm && hasVisibleDefaultArgument(OldNonTypeParm) && NewNonTypeParm->hasDefaultArgument()) { OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc(); NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc(); @@ -1375,12 +1368,7 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) { // Merge the default argument from the old declaration to the // new declaration. - // FIXME: We need to create a new kind of "default argument" - // expression that points to a previous non-type template - // parameter. - NewNonTypeParm->setDefaultArgument( - OldNonTypeParm->getDefaultArgument(), - /*Inherited=*/ true); + NewNonTypeParm->setInheritedDefaultArgument(Context, OldNonTypeParm); PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc(); } else if (NewNonTypeParm->hasDefaultArgument()) { SawDefaultArgument = true; @@ -1407,15 +1395,14 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, // Merge default arguments for template template parameters TemplateTemplateParmDecl *OldTemplateParm = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : nullptr; - if (OldTemplateParm && !LookupResult::isVisible(*this, OldTemplateParm)) - OldTemplateParm = nullptr; if (NewTemplateParm->isParameterPack()) { assert(!NewTemplateParm->hasDefaultArgument() && "Parameter packs can't have a default argument!"); if (!NewTemplateParm->isPackExpansion()) SawParameterPack = true; - } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument() && - NewTemplateParm->hasDefaultArgument()) { + } else if (OldTemplateParm && + hasVisibleDefaultArgument(OldTemplateParm) && + NewTemplateParm->hasDefaultArgument()) { OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation(); NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation(); SawDefaultArgument = true; @@ -1424,11 +1411,7 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) { // Merge the default argument from the old declaration to the // new declaration. - // FIXME: We need to create a new kind of "default argument" expression - // that points to a previous template template parameter. - NewTemplateParm->setDefaultArgument( - OldTemplateParm->getDefaultArgument(), - /*Inherited=*/ true); + NewTemplateParm->setInheritedDefaultArgument(Context, OldTemplateParm); PreviousDefaultArgLoc = OldTemplateParm->getDefaultArgument().getLocation(); } else if (NewTemplateParm->hasDefaultArgument()) { @@ -3316,7 +3299,7 @@ Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, HasDefaultArg = false; if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) { - if (!TypeParm->hasDefaultArgument()) + if (!hasVisibleDefaultArgument(TypeParm)) return TemplateArgumentLoc(); HasDefaultArg = true; @@ -3333,7 +3316,7 @@ Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, if (NonTypeTemplateParmDecl *NonTypeParm = dyn_cast<NonTypeTemplateParmDecl>(Param)) { - if (!NonTypeParm->hasDefaultArgument()) + if (!hasVisibleDefaultArgument(NonTypeParm)) return TemplateArgumentLoc(); HasDefaultArg = true; @@ -3351,7 +3334,7 @@ Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, TemplateTemplateParmDecl *TempTempParm = cast<TemplateTemplateParmDecl>(Param); - if (!TempTempParm->hasDefaultArgument()) + if (!hasVisibleDefaultArgument(TempTempParm)) return TemplateArgumentLoc(); HasDefaultArg = true; @@ -3661,6 +3644,35 @@ static Optional<unsigned> getExpandedPackSize(NamedDecl *Param) { return None; } +/// Diagnose a missing template argument. +template<typename TemplateParmDecl> +static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc, + TemplateDecl *TD, + const TemplateParmDecl *D, + TemplateArgumentListInfo &Args) { + // Dig out the most recent declaration of the template parameter; there may be + // declarations of the template that are more recent than TD. + D = cast<TemplateParmDecl>(cast<TemplateDecl>(TD->getMostRecentDecl()) + ->getTemplateParameters() + ->getParam(D->getIndex())); + + // If there's a default argument that's not visible, diagnose that we're + // missing a module import. + llvm::SmallVector<Module*, 8> Modules; + if (D->hasDefaultArgument() && !S.hasVisibleDefaultArgument(D, &Modules)) { + S.diagnoseMissingImport(Loc, cast<NamedDecl>(TD), + D->getDefaultArgumentLoc(), Modules, + Sema::MissingImportKind::DefaultArgument, + /*Recover*/ true); + return true; + } + + // FIXME: If there's a more recent default argument that *is* visible, + // diagnose that it was declared too late. + + return diagnoseArityMismatch(S, TD, Loc, Args); +} + /// \brief Check that the given template argument list is well-formed /// for specializing the given template. bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, @@ -3816,8 +3828,9 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, // (when the template parameter was part of a nested template) into // the default argument. if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) { - if (!TTP->hasDefaultArgument()) - return diagnoseArityMismatch(*this, Template, TemplateLoc, NewArgs); + if (!hasVisibleDefaultArgument(TTP)) + return diagnoseMissingArgument(*this, TemplateLoc, Template, TTP, + NewArgs); TypeSourceInfo *ArgType = SubstDefaultTemplateArgument(*this, Template, @@ -3832,8 +3845,9 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, ArgType); } else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { - if (!NTTP->hasDefaultArgument()) - return diagnoseArityMismatch(*this, Template, TemplateLoc, NewArgs); + if (!hasVisibleDefaultArgument(NTTP)) + return diagnoseMissingArgument(*this, TemplateLoc, Template, NTTP, + NewArgs); ExprResult E = SubstDefaultTemplateArgument(*this, Template, TemplateLoc, @@ -3849,8 +3863,9 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(*Param); - if (!TempParm->hasDefaultArgument()) - return diagnoseArityMismatch(*this, Template, TemplateLoc, NewArgs); + if (!hasVisibleDefaultArgument(TempParm)) + return diagnoseMissingArgument(*this, TemplateLoc, Template, TempParm, + NewArgs); NestedNameSpecifierLoc QualifierLoc; TemplateName Name = SubstDefaultTemplateArgument(*this, Template, diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp index 5c994f86bd2c..f35d1aaf77e9 100644 --- a/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -1922,12 +1922,12 @@ Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl( D->isParameterPack()); Inst->setAccess(AS_public); - if (D->hasDefaultArgument()) { + if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) { TypeSourceInfo *InstantiatedDefaultArg = SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs, D->getDefaultArgumentLoc(), D->getDeclName()); if (InstantiatedDefaultArg) - Inst->setDefaultArgument(InstantiatedDefaultArg, false); + Inst->setDefaultArgument(InstantiatedDefaultArg); } // Introduce this template parameter's instantiation into the instantiation @@ -2078,10 +2078,10 @@ Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl( if (Invalid) Param->setInvalidDecl(); - if (D->hasDefaultArgument()) { + if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) { ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs); if (!Value.isInvalid()) - Param->setDefaultArgument(Value.get(), false); + Param->setDefaultArgument(Value.get()); } // Introduce this template parameter's instantiation into the instantiation @@ -2205,7 +2205,7 @@ TemplateDeclInstantiator::VisitTemplateTemplateParmDecl( D->getPosition(), D->isParameterPack(), D->getIdentifier(), InstParams); - if (D->hasDefaultArgument()) { + if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) { NestedNameSpecifierLoc QualifierLoc = D->getDefaultArgument().getTemplateQualifierLoc(); QualifierLoc = @@ -2215,10 +2215,10 @@ TemplateDeclInstantiator::VisitTemplateTemplateParmDecl( D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs); if (!TName.isNull()) Param->setDefaultArgument( + SemaRef.Context, TemplateArgumentLoc(TemplateArgument(TName), D->getDefaultArgument().getTemplateQualifierLoc(), - D->getDefaultArgument().getTemplateNameLoc()), - false); + D->getDefaultArgument().getTemplateNameLoc())); } Param->setAccess(AS_public); diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp index 628eb734cdd6..d72f2595abe7 100644 --- a/lib/Sema/SemaType.cpp +++ b/lib/Sema/SemaType.cpp @@ -22,8 +22,10 @@ #include "clang/AST/Expr.h" #include "clang/AST/TypeLoc.h" #include "clang/AST/TypeLocVisitor.h" +#include "clang/Lex/Preprocessor.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/TargetInfo.h" +#include "clang/Lex/Preprocessor.h" #include "clang/Parse/ParseDiagnostic.h" #include "clang/Sema/DeclSpec.h" #include "clang/Sema/DelayedDiagnostic.h" @@ -121,6 +123,12 @@ static void diagnoseBadTypeAttribute(Sema &S, const AttributeList &attr, case AttributeList::AT_SPtr: \ case AttributeList::AT_UPtr +// Nullability qualifiers. +#define NULLABILITY_TYPE_ATTRS_CASELIST \ + case AttributeList::AT_TypeNonNull: \ + case AttributeList::AT_TypeNullable: \ + case AttributeList::AT_TypeNullUnspecified + namespace { /// An object which stores processing state for the entire /// GetTypeForDeclarator process. @@ -307,8 +315,12 @@ static bool handleObjCPointerTypeAttr(TypeProcessingState &state, /// /// \param i - a notional index which the search will start /// immediately inside +/// +/// \param onlyBlockPointers Whether we should only look into block +/// pointer types (vs. all pointer types). static DeclaratorChunk *maybeMovePastReturnType(Declarator &declarator, - unsigned i) { + unsigned i, + bool onlyBlockPointers) { assert(i <= declarator.getNumTypeObjects()); DeclaratorChunk *result = nullptr; @@ -329,20 +341,26 @@ static DeclaratorChunk *maybeMovePastReturnType(Declarator &declarator, return result; // If we do find a function declarator, scan inwards from that, - // looking for a block-pointer declarator. + // looking for a (block-)pointer declarator. case DeclaratorChunk::Function: for (--i; i != 0; --i) { - DeclaratorChunk &blockChunk = declarator.getTypeObject(i-1); - switch (blockChunk.Kind) { + DeclaratorChunk &ptrChunk = declarator.getTypeObject(i-1); + switch (ptrChunk.Kind) { case DeclaratorChunk::Paren: - case DeclaratorChunk::Pointer: case DeclaratorChunk::Array: case DeclaratorChunk::Function: case DeclaratorChunk::Reference: - case DeclaratorChunk::MemberPointer: continue; + + case DeclaratorChunk::MemberPointer: + case DeclaratorChunk::Pointer: + if (onlyBlockPointers) + continue; + + // fallthrough + case DeclaratorChunk::BlockPointer: - result = &blockChunk; + result = &ptrChunk; goto continue_outer; } llvm_unreachable("bad declarator chunk kind"); @@ -382,7 +400,8 @@ static void distributeObjCPointerTypeAttr(TypeProcessingState &state, DeclaratorChunk *destChunk = nullptr; if (state.isProcessingDeclSpec() && attr.getKind() == AttributeList::AT_ObjCOwnership) - destChunk = maybeMovePastReturnType(declarator, i - 1); + destChunk = maybeMovePastReturnType(declarator, i - 1, + /*onlyBlockPointers=*/true); if (!destChunk) destChunk = &chunk; moveAttrFromListToList(attr, state.getCurrentAttrListRef(), @@ -398,7 +417,9 @@ static void distributeObjCPointerTypeAttr(TypeProcessingState &state, case DeclaratorChunk::Function: if (state.isProcessingDeclSpec() && attr.getKind() == AttributeList::AT_ObjCOwnership) { - if (DeclaratorChunk *dest = maybeMovePastReturnType(declarator, i)) { + if (DeclaratorChunk *dest = maybeMovePastReturnType( + declarator, i, + /*onlyBlockPointers=*/true)) { moveAttrFromListToList(attr, state.getCurrentAttrListRef(), dest->getAttrListRef()); return; @@ -620,6 +641,10 @@ static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state, // Microsoft type attributes cannot go after the declarator-id. continue; + NULLABILITY_TYPE_ATTRS_CASELIST: + // Nullability specifiers cannot go after the declarator-id. + continue; + default: break; } @@ -2529,6 +2554,285 @@ getCCForDeclaratorChunk(Sema &S, Declarator &D, return CC; } +namespace { + /// A simple notion of pointer kinds, which matches up with the various + /// pointer declarators. + enum class SimplePointerKind { + Pointer, + BlockPointer, + MemberPointer, + }; +} + +IdentifierInfo *Sema::getNullabilityKeyword(NullabilityKind nullability) { + switch (nullability) { + case NullabilityKind::NonNull: + if (!Ident___nonnull) + Ident___nonnull = PP.getIdentifierInfo("__nonnull"); + return Ident___nonnull; + + case NullabilityKind::Nullable: + if (!Ident___nullable) + Ident___nullable = PP.getIdentifierInfo("__nullable"); + return Ident___nullable; + + case NullabilityKind::Unspecified: + if (!Ident___null_unspecified) + Ident___null_unspecified = PP.getIdentifierInfo("__null_unspecified"); + return Ident___null_unspecified; + } + llvm_unreachable("Unknown nullability kind."); +} + +/// Retrieve the identifier "NSError". +IdentifierInfo *Sema::getNSErrorIdent() { + if (!Ident_NSError) + Ident_NSError = PP.getIdentifierInfo("NSError"); + + return Ident_NSError; +} + +/// Check whether there is a nullability attribute of any kind in the given +/// attribute list. +static bool hasNullabilityAttr(const AttributeList *attrs) { + for (const AttributeList *attr = attrs; attr; + attr = attr->getNext()) { + if (attr->getKind() == AttributeList::AT_TypeNonNull || + attr->getKind() == AttributeList::AT_TypeNullable || + attr->getKind() == AttributeList::AT_TypeNullUnspecified) + return true; + } + + return false; +} + +namespace { + /// Describes the kind of a pointer a declarator describes. + enum class PointerDeclaratorKind { + // Not a pointer. + NonPointer, + // Single-level pointer. + SingleLevelPointer, + // Multi-level pointer (of any pointer kind). + MultiLevelPointer, + // CFFooRef* + MaybePointerToCFRef, + // CFErrorRef* + CFErrorRefPointer, + // NSError** + NSErrorPointerPointer, + }; +} + +/// Classify the given declarator, whose type-specified is \c type, based on +/// what kind of pointer it refers to. +/// +/// This is used to determine the default nullability. +static PointerDeclaratorKind classifyPointerDeclarator(Sema &S, + QualType type, + Declarator &declarator) { + unsigned numNormalPointers = 0; + + // For any dependent type, we consider it a non-pointer. + if (type->isDependentType()) + return PointerDeclaratorKind::NonPointer; + + // Look through the declarator chunks to identify pointers. + for (unsigned i = 0, n = declarator.getNumTypeObjects(); i != n; ++i) { + DeclaratorChunk &chunk = declarator.getTypeObject(i); + switch (chunk.Kind) { + case DeclaratorChunk::Array: + case DeclaratorChunk::Function: + break; + + case DeclaratorChunk::BlockPointer: + case DeclaratorChunk::MemberPointer: + return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer + : PointerDeclaratorKind::SingleLevelPointer; + + case DeclaratorChunk::Paren: + case DeclaratorChunk::Reference: + continue; + + case DeclaratorChunk::Pointer: + ++numNormalPointers; + if (numNormalPointers > 2) + return PointerDeclaratorKind::MultiLevelPointer; + continue; + } + } + + // Then, dig into the type specifier itself. + unsigned numTypeSpecifierPointers = 0; + do { + // Decompose normal pointers. + if (auto ptrType = type->getAs<PointerType>()) { + ++numNormalPointers; + + if (numNormalPointers > 2) + return PointerDeclaratorKind::MultiLevelPointer; + + type = ptrType->getPointeeType(); + ++numTypeSpecifierPointers; + continue; + } + + // Decompose block pointers. + if (type->getAs<BlockPointerType>()) { + return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer + : PointerDeclaratorKind::SingleLevelPointer; + } + + // Decompose member pointers. + if (type->getAs<MemberPointerType>()) { + return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer + : PointerDeclaratorKind::SingleLevelPointer; + } + + // Look at Objective-C object pointers. + if (auto objcObjectPtr = type->getAs<ObjCObjectPointerType>()) { + ++numNormalPointers; + ++numTypeSpecifierPointers; + + // If this is NSError**, report that. + if (auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) { + if (objcClassDecl->getIdentifier() == S.getNSErrorIdent() && + numNormalPointers == 2 && numTypeSpecifierPointers < 2) { + return PointerDeclaratorKind::NSErrorPointerPointer; + } + } + + break; + } + + // Look at Objective-C class types. + if (auto objcClass = type->getAs<ObjCInterfaceType>()) { + if (objcClass->getInterface()->getIdentifier() == S.getNSErrorIdent()) { + if (numNormalPointers == 2 && numTypeSpecifierPointers < 2) + return PointerDeclaratorKind::NSErrorPointerPointer;; + } + + break; + } + + // If at this point we haven't seen a pointer, we won't see one. + if (numNormalPointers == 0) + return PointerDeclaratorKind::NonPointer; + + if (auto recordType = type->getAs<RecordType>()) { + RecordDecl *recordDecl = recordType->getDecl(); + + bool isCFError = false; + if (S.CFError) { + // If we already know about CFError, test it directly. + isCFError = (S.CFError == recordDecl); + } else { + // Check whether this is CFError, which we identify based on its bridge + // to NSError. + if (recordDecl->getTagKind() == TTK_Struct && numNormalPointers > 0) { + if (auto bridgeAttr = recordDecl->getAttr<ObjCBridgeAttr>()) { + if (bridgeAttr->getBridgedType() == S.getNSErrorIdent()) { + S.CFError = recordDecl; + isCFError = true; + } + } + } + } + + // If this is CFErrorRef*, report it as such. + if (isCFError && numNormalPointers == 2 && numTypeSpecifierPointers < 2) { + return PointerDeclaratorKind::CFErrorRefPointer; + } + break; + } + + break; + } while (true); + + + switch (numNormalPointers) { + case 0: + return PointerDeclaratorKind::NonPointer; + + case 1: + return PointerDeclaratorKind::SingleLevelPointer; + + case 2: + return PointerDeclaratorKind::MaybePointerToCFRef; + + default: + return PointerDeclaratorKind::MultiLevelPointer; + } +} + +static FileID getNullabilityCompletenessCheckFileID(Sema &S, + SourceLocation loc) { + // If we're anywhere in a function, method, or closure context, don't perform + // completeness checks. + for (DeclContext *ctx = S.CurContext; ctx; ctx = ctx->getParent()) { + if (ctx->isFunctionOrMethod()) + return FileID(); + + if (ctx->isFileContext()) + break; + } + + // We only care about the expansion location. + loc = S.SourceMgr.getExpansionLoc(loc); + FileID file = S.SourceMgr.getFileID(loc); + if (file.isInvalid()) + return FileID(); + + // Retrieve file information. + bool invalid = false; + const SrcMgr::SLocEntry &sloc = S.SourceMgr.getSLocEntry(file, &invalid); + if (invalid || !sloc.isFile()) + return FileID(); + + // We don't want to perform completeness checks on the main file or in + // system headers. + const SrcMgr::FileInfo &fileInfo = sloc.getFile(); + if (fileInfo.getIncludeLoc().isInvalid()) + return FileID(); + if (fileInfo.getFileCharacteristic() != SrcMgr::C_User && + S.Diags.getSuppressSystemWarnings()) { + return FileID(); + } + + return file; +} + +/// Check for consistent use of nullability. +static void checkNullabilityConsistency(TypeProcessingState &state, + SimplePointerKind pointerKind, + SourceLocation pointerLoc) { + Sema &S = state.getSema(); + + // Determine which file we're performing consistency checking for. + FileID file = getNullabilityCompletenessCheckFileID(S, pointerLoc); + if (file.isInvalid()) + return; + + // If we haven't seen any type nullability in this file, we won't warn now + // about anything. + FileNullability &fileNullability = S.NullabilityMap[file]; + if (!fileNullability.SawTypeNullability) { + // If this is the first pointer declarator in the file, record it. + if (fileNullability.PointerLoc.isInvalid() && + !S.Context.getDiagnostics().isIgnored(diag::warn_nullability_missing, + pointerLoc)) { + fileNullability.PointerLoc = pointerLoc; + fileNullability.PointerKind = static_cast<unsigned>(pointerKind); + } + + return; + } + + // Complain about missing nullability. + S.Diag(pointerLoc, diag::warn_nullability_missing) + << static_cast<unsigned>(pointerKind); +} + static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) { @@ -2596,6 +2900,245 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, } } + // Determine whether we should infer __nonnull on pointer types. + Optional<NullabilityKind> inferNullability; + bool inferNullabilityCS = false; + bool inferNullabilityInnerOnly = false; + bool inferNullabilityInnerOnlyComplete = false; + + // Are we in an assume-nonnull region? + bool inAssumeNonNullRegion = false; + if (S.PP.getPragmaAssumeNonNullLoc().isValid() && + !state.getDeclarator().isObjCWeakProperty() && + !S.deduceWeakPropertyFromType(T)) { + inAssumeNonNullRegion = true; + // Determine which file we saw the assume-nonnull region in. + FileID file = getNullabilityCompletenessCheckFileID( + S, S.PP.getPragmaAssumeNonNullLoc()); + if (!file.isInvalid()) { + FileNullability &fileNullability = S.NullabilityMap[file]; + + // If we haven't seen any type nullability before, now we have. + if (!fileNullability.SawTypeNullability) { + if (fileNullability.PointerLoc.isValid()) { + S.Diag(fileNullability.PointerLoc, diag::warn_nullability_missing) + << static_cast<unsigned>(fileNullability.PointerKind); + } + + fileNullability.SawTypeNullability = true; + } + } + } + + // Whether to complain about missing nullability specifiers or not. + enum { + /// Never complain. + CAMN_No, + /// Complain on the inner pointers (but not the outermost + /// pointer). + CAMN_InnerPointers, + /// Complain about any pointers that don't have nullability + /// specified or inferred. + CAMN_Yes + } complainAboutMissingNullability = CAMN_No; + unsigned NumPointersRemaining = 0; + + if (IsTypedefName) { + // For typedefs, we do not infer any nullability (the default), + // and we only complain about missing nullability specifiers on + // inner pointers. + complainAboutMissingNullability = CAMN_InnerPointers; + + if (T->canHaveNullability() && !T->getNullability(S.Context)) { + ++NumPointersRemaining; + } + + for (unsigned i = 0, n = D.getNumTypeObjects(); i != n; ++i) { + DeclaratorChunk &chunk = D.getTypeObject(i); + switch (chunk.Kind) { + case DeclaratorChunk::Array: + case DeclaratorChunk::Function: + break; + + case DeclaratorChunk::BlockPointer: + case DeclaratorChunk::MemberPointer: + ++NumPointersRemaining; + break; + + case DeclaratorChunk::Paren: + case DeclaratorChunk::Reference: + continue; + + case DeclaratorChunk::Pointer: + ++NumPointersRemaining; + continue; + } + } + } else { + bool isFunctionOrMethod = false; + switch (auto context = state.getDeclarator().getContext()) { + case Declarator::ObjCParameterContext: + case Declarator::ObjCResultContext: + case Declarator::PrototypeContext: + case Declarator::TrailingReturnContext: + isFunctionOrMethod = true; + // fallthrough + + case Declarator::MemberContext: + if (state.getDeclarator().isObjCIvar() && !isFunctionOrMethod) { + complainAboutMissingNullability = CAMN_No; + break; + } + // fallthrough + + case Declarator::FileContext: + case Declarator::KNRTypeListContext: + complainAboutMissingNullability = CAMN_Yes; + + // Nullability inference depends on the type and declarator. + switch (classifyPointerDeclarator(S, T, D)) { + case PointerDeclaratorKind::NonPointer: + case PointerDeclaratorKind::MultiLevelPointer: + // Cannot infer nullability. + break; + + case PointerDeclaratorKind::SingleLevelPointer: + // Infer __nonnull if we are in an assumes-nonnull region. + if (inAssumeNonNullRegion) { + inferNullability = NullabilityKind::NonNull; + inferNullabilityCS = (context == Declarator::ObjCParameterContext || + context == Declarator::ObjCResultContext); + } + break; + + case PointerDeclaratorKind::CFErrorRefPointer: + case PointerDeclaratorKind::NSErrorPointerPointer: + // Within a function or method signature, infer __nullable at both + // levels. + if (isFunctionOrMethod && inAssumeNonNullRegion) + inferNullability = NullabilityKind::Nullable; + break; + + case PointerDeclaratorKind::MaybePointerToCFRef: + if (isFunctionOrMethod) { + // On pointer-to-pointer parameters marked cf_returns_retained or + // cf_returns_not_retained, if the outer pointer is explicit then + // infer the inner pointer as __nullable. + auto hasCFReturnsAttr = [](const AttributeList *NextAttr) -> bool { + while (NextAttr) { + if (NextAttr->getKind() == AttributeList::AT_CFReturnsRetained || + NextAttr->getKind() == AttributeList::AT_CFReturnsNotRetained) + return true; + NextAttr = NextAttr->getNext(); + } + return false; + }; + if (const auto *InnermostChunk = D.getInnermostNonParenChunk()) { + if (hasCFReturnsAttr(D.getAttributes()) || + hasCFReturnsAttr(InnermostChunk->getAttrs()) || + hasCFReturnsAttr(D.getDeclSpec().getAttributes().getList())) { + inferNullability = NullabilityKind::Nullable; + inferNullabilityInnerOnly = true; + } + } + } + break; + } + break; + + case Declarator::ConversionIdContext: + complainAboutMissingNullability = CAMN_Yes; + break; + + case Declarator::AliasDeclContext: + case Declarator::AliasTemplateContext: + case Declarator::BlockContext: + case Declarator::BlockLiteralContext: + case Declarator::ConditionContext: + case Declarator::CXXCatchContext: + case Declarator::CXXNewContext: + case Declarator::ForContext: + case Declarator::LambdaExprContext: + case Declarator::LambdaExprParameterContext: + case Declarator::ObjCCatchContext: + case Declarator::TemplateParamContext: + case Declarator::TemplateTypeArgContext: + case Declarator::TypeNameContext: + // Don't infer in these contexts. + break; + } + } + + // Local function that checks the nullability for a given pointer declarator. + // Returns true if __nonnull was inferred. + auto inferPointerNullability = [&](SimplePointerKind pointerKind, + SourceLocation pointerLoc, + AttributeList *&attrs) -> AttributeList * { + // We've seen a pointer. + if (NumPointersRemaining > 0) + --NumPointersRemaining; + + // If a nullability attribute is present, there's nothing to do. + if (hasNullabilityAttr(attrs)) + return nullptr; + + // If we're supposed to infer nullability, do so now. + if (inferNullability && !inferNullabilityInnerOnlyComplete) { + AttributeList::Syntax syntax + = inferNullabilityCS ? AttributeList::AS_ContextSensitiveKeyword + : AttributeList::AS_Keyword; + AttributeList *nullabilityAttr = state.getDeclarator().getAttributePool() + .create( + S.getNullabilityKeyword( + *inferNullability), + SourceRange(pointerLoc), + nullptr, SourceLocation(), + nullptr, 0, syntax); + + spliceAttrIntoList(*nullabilityAttr, attrs); + + if (inferNullabilityInnerOnly) + inferNullabilityInnerOnlyComplete = true; + return nullabilityAttr; + } + + // If we're supposed to complain about missing nullability, do so + // now if it's truly missing. + switch (complainAboutMissingNullability) { + case CAMN_No: + break; + + case CAMN_InnerPointers: + if (NumPointersRemaining == 0) + break; + // Fallthrough. + + case CAMN_Yes: + checkNullabilityConsistency(state, pointerKind, pointerLoc); + } + + return nullptr; + }; + + // If the type itself could have nullability but does not, infer pointer + // nullability and perform consistency checking. + if (T->canHaveNullability() && S.ActiveTemplateInstantiations.empty() && + !T->getNullability(S.Context)) { + SimplePointerKind pointerKind = SimplePointerKind::Pointer; + if (T->isBlockPointerType()) + pointerKind = SimplePointerKind::BlockPointer; + else if (T->isMemberPointerType()) + pointerKind = SimplePointerKind::MemberPointer; + + if (auto *attr = inferPointerNullability( + pointerKind, D.getDeclSpec().getTypeSpecTypeLoc(), + D.getMutableDeclSpec().getAttributes().getListRef())) { + T = Context.getAttributedType( + AttributedType::getNullabilityAttrKind(*inferNullability), T, T); + attr->setUsedAsTypeAttr(); + } + } + // Walk the DeclTypeInfo, building the recursive type as we go. // DeclTypeInfos are ordered from the identifier out, which is // opposite of what we want :). @@ -2613,6 +3156,10 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, if (!LangOpts.Blocks) S.Diag(DeclType.Loc, diag::err_blocks_disable); + // Handle pointer nullability. + inferPointerNullability(SimplePointerKind::BlockPointer, + DeclType.Loc, DeclType.getAttrListRef()); + T = S.BuildBlockPointerType(T, D.getIdentifierLoc(), Name); if (DeclType.Cls.TypeQuals) T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Cls.TypeQuals); @@ -2625,6 +3172,11 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, D.setInvalidType(true); // Build the type anyway. } + + // Handle pointer nullability + inferPointerNullability(SimplePointerKind::Pointer, DeclType.Loc, + DeclType.getAttrListRef()); + if (LangOpts.ObjC1 && T->getAs<ObjCObjectType>()) { T = Context.getObjCObjectPointerType(T); if (DeclType.Ptr.TypeQuals) @@ -3066,6 +3618,11 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, // The scope spec must refer to a class, or be dependent. CXXScopeSpec &SS = DeclType.Mem.Scope(); QualType ClsType; + + // Handle pointer nullability. + inferPointerNullability(SimplePointerKind::MemberPointer, + DeclType.Loc, DeclType.getAttrListRef()); + if (SS.isInvalid()) { // Avoid emitting extra errors if we already errored on the scope. D.setInvalidType(true); @@ -3495,6 +4052,12 @@ static AttributeList::Kind getAttrListKind(AttributedType::Kind kind) { return AttributeList::AT_SPtr; case AttributedType::attr_uptr: return AttributeList::AT_UPtr; + case AttributedType::attr_nonnull: + return AttributeList::AT_TypeNonNull; + case AttributedType::attr_nullable: + return AttributeList::AT_TypeNullable; + case AttributedType::attr_null_unspecified: + return AttributeList::AT_TypeNullUnspecified; } llvm_unreachable("unexpected attribute kind!"); } @@ -4114,7 +4677,8 @@ static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, // just be the return type of a block pointer. if (state.isProcessingDeclSpec()) { Declarator &D = state.getDeclarator(); - if (maybeMovePastReturnType(D, D.getNumTypeObjects())) + if (maybeMovePastReturnType(D, D.getNumTypeObjects(), + /*onlyBlockPointers=*/true)) return false; } } @@ -4491,6 +5055,212 @@ static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &State, return false; } +bool Sema::checkNullabilityTypeSpecifier(QualType &type, + NullabilityKind nullability, + SourceLocation nullabilityLoc, + bool isContextSensitive) { + // We saw a nullability type specifier. If this is the first one for + // this file, note that. + FileID file = getNullabilityCompletenessCheckFileID(*this, nullabilityLoc); + if (!file.isInvalid()) { + FileNullability &fileNullability = NullabilityMap[file]; + if (!fileNullability.SawTypeNullability) { + // If we have already seen a pointer declarator without a nullability + // annotation, complain about it. + if (fileNullability.PointerLoc.isValid()) { + Diag(fileNullability.PointerLoc, diag::warn_nullability_missing) + << static_cast<unsigned>(fileNullability.PointerKind); + } + + fileNullability.SawTypeNullability = true; + } + } + + // Check for existing nullability attributes on the type. + QualType desugared = type; + while (auto attributed = dyn_cast<AttributedType>(desugared.getTypePtr())) { + // Check whether there is already a null + if (auto existingNullability = attributed->getImmediateNullability()) { + // Duplicated nullability. + if (nullability == *existingNullability) { + Diag(nullabilityLoc, diag::warn_nullability_duplicate) + << static_cast<unsigned>(nullability) + << isContextSensitive + << FixItHint::CreateRemoval(nullabilityLoc); + + break; + } + + // Conflicting nullability. + Diag(nullabilityLoc, diag::err_nullability_conflicting) + << static_cast<unsigned>(nullability) + << isContextSensitive + << static_cast<unsigned>(*existingNullability) + << false; + return true; + } + + desugared = attributed->getModifiedType(); + } + + // If there is already a different nullability specifier, complain. + // This (unlike the code above) looks through typedefs that might + // have nullability specifiers on them, which means we cannot + // provide a useful Fix-It. + if (auto existingNullability = desugared->getNullability(Context)) { + if (nullability != *existingNullability) { + Diag(nullabilityLoc, diag::err_nullability_conflicting) + << static_cast<unsigned>(nullability) + << isContextSensitive + << static_cast<unsigned>(*existingNullability) + << false; + + // Try to find the typedef with the existing nullability specifier. + if (auto typedefType = desugared->getAs<TypedefType>()) { + TypedefNameDecl *typedefDecl = typedefType->getDecl(); + QualType underlyingType = typedefDecl->getUnderlyingType(); + if (auto typedefNullability + = AttributedType::stripOuterNullability(underlyingType)) { + if (*typedefNullability == *existingNullability) { + Diag(typedefDecl->getLocation(), diag::note_nullability_here) + << static_cast<unsigned>(*existingNullability); + } + } + } + + return true; + } + } + + // If this definitely isn't a pointer type, reject the specifier. + if (!desugared->canHaveNullability()) { + Diag(nullabilityLoc, diag::err_nullability_nonpointer) + << static_cast<unsigned>(nullability) << isContextSensitive << type; + return true; + } + + // For the context-sensitive keywords/Objective-C property + // attributes, require that the type be a single-level pointer. + if (isContextSensitive) { + // Make sure that the pointee isn't itself a pointer type. + QualType pointeeType = desugared->getPointeeType(); + if (pointeeType->isAnyPointerType() || + pointeeType->isObjCObjectPointerType() || + pointeeType->isMemberPointerType()) { + Diag(nullabilityLoc, diag::err_nullability_cs_multilevel) + << static_cast<unsigned>(nullability) + << type; + Diag(nullabilityLoc, diag::note_nullability_type_specifier) + << static_cast<unsigned>(nullability) + << type + << FixItHint::CreateReplacement(nullabilityLoc, + getNullabilitySpelling(nullability)); + return true; + } + } + + // Form the attributed type. + type = Context.getAttributedType( + AttributedType::getNullabilityAttrKind(nullability), type, type); + return false; +} + +/// Map a nullability attribute kind to a nullability kind. +static NullabilityKind mapNullabilityAttrKind(AttributeList::Kind kind) { + switch (kind) { + case AttributeList::AT_TypeNonNull: + return NullabilityKind::NonNull; + + case AttributeList::AT_TypeNullable: + return NullabilityKind::Nullable; + + case AttributeList::AT_TypeNullUnspecified: + return NullabilityKind::Unspecified; + + default: + llvm_unreachable("not a nullability attribute kind"); + } +} + +/// Distribute a nullability type attribute that cannot be applied to +/// the type specifier to a pointer, block pointer, or member pointer +/// declarator, complaining if necessary. +/// +/// \returns true if the nullability annotation was distributed, false +/// otherwise. +static bool distributeNullabilityTypeAttr(TypeProcessingState &state, + QualType type, + AttributeList &attr) { + Declarator &declarator = state.getDeclarator(); + + /// Attempt to move the attribute to the specified chunk. + auto moveToChunk = [&](DeclaratorChunk &chunk, bool inFunction) -> bool { + // If there is already a nullability attribute there, don't add + // one. + if (hasNullabilityAttr(chunk.getAttrListRef())) + return false; + + // Complain about the nullability qualifier being in the wrong + // place. + unsigned pointerKind + = chunk.Kind == DeclaratorChunk::Pointer ? (inFunction ? 3 : 0) + : chunk.Kind == DeclaratorChunk::BlockPointer ? 1 + : inFunction? 4 : 2; + + auto diag = state.getSema().Diag(attr.getLoc(), + diag::warn_nullability_declspec) + << static_cast<unsigned>(mapNullabilityAttrKind(attr.getKind())) + << type + << pointerKind; + + // FIXME: MemberPointer chunks don't carry the location of the *. + if (chunk.Kind != DeclaratorChunk::MemberPointer) { + diag << FixItHint::CreateRemoval(attr.getLoc()) + << FixItHint::CreateInsertion( + state.getSema().getPreprocessor() + .getLocForEndOfToken(chunk.Loc), + " " + attr.getName()->getName().str() + " "); + } + + moveAttrFromListToList(attr, state.getCurrentAttrListRef(), + chunk.getAttrListRef()); + return true; + }; + + // Move it to the outermost pointer, member pointer, or block + // pointer declarator. + for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) { + DeclaratorChunk &chunk = declarator.getTypeObject(i-1); + switch (chunk.Kind) { + case DeclaratorChunk::Pointer: + case DeclaratorChunk::BlockPointer: + case DeclaratorChunk::MemberPointer: + return moveToChunk(chunk, false); + + case DeclaratorChunk::Paren: + case DeclaratorChunk::Array: + continue; + + case DeclaratorChunk::Function: + // Try to move past the return type to a function/block/member + // function pointer. + if (DeclaratorChunk *dest = maybeMovePastReturnType( + declarator, i, + /*onlyBlockPointers=*/false)) { + return moveToChunk(*dest, true); + } + + return false; + + // Don't walk through these. + case DeclaratorChunk::Reference: + return false; + } + } + + return false; +} + static AttributedType::Kind getCCTypeAttrKind(AttributeList &Attr) { assert(!Attr.isInvalid()); switch (Attr.getKind()) { @@ -4997,6 +5767,24 @@ static void processTypeAttrs(TypeProcessingState &state, QualType &type, attr.setUsedAsTypeAttr(); break; + NULLABILITY_TYPE_ATTRS_CASELIST: + // Either add nullability here or try to distribute it. We + // don't want to distribute the nullability specifier past any + // dependent type, because that complicates the user model. + if (type->canHaveNullability() || type->isDependentType() || + !distributeNullabilityTypeAttr(state, type, attr)) { + if (state.getSema().checkNullabilityTypeSpecifier( + type, + mapNullabilityAttrKind(attr.getKind()), + attr.getLoc(), + attr.isContextSensitiveKeywordAttribute())) { + attr.setInvalid(); + } + + attr.setUsedAsTypeAttr(); + } + break; + case AttributeList::AT_NSReturnsRetained: if (!state.getSema().getLangOpts().ObjCAutoRefCount) break; @@ -5153,7 +5941,7 @@ bool Sema::RequireCompleteType(SourceLocation Loc, QualType T, /// in order to provide a definition of this entity. bool Sema::hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested) { // Easy case: if we don't have modules, all declarations are visible. - if (!getLangOpts().Modules) + if (!getLangOpts().Modules && !getLangOpts().ModulesLocalVisibility) return true; // If this definition was instantiated from a template, map back to the @@ -5185,10 +5973,18 @@ bool Sema::hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested) { } assert(D && "missing definition for pattern of instantiated definition"); - // FIXME: If we merged any other decl into D, and that declaration is visible, - // then we should consider a definition to be visible. *Suggested = D; - return LookupResult::isVisible(*this, D); + if (LookupResult::isVisible(*this, D)) + return true; + + // The external source may have additional definitions of this type that are + // visible, so complete the redeclaration chain now and ask again. + if (auto *Source = Context.getExternalSource()) { + Source->CompleteRedeclChain(D); + return LookupResult::isVisible(*this, D); + } + + return false; } /// Locks in the inheritance model for the given class and all of its bases. @@ -5239,20 +6035,8 @@ bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T, // If we know about the definition but it is not visible, complain. NamedDecl *SuggestedDef = nullptr; if (!Diagnoser.Suppressed && Def && - !hasVisibleDefinition(Def, &SuggestedDef)) { - // Suppress this error outside of a SFINAE context if we've already - // emitted the error once for this type. There's no usefulness in - // repeating the diagnostic. - // FIXME: Add a Fix-It that imports the corresponding module or includes - // the header. - Module *Owner = getOwningModule(SuggestedDef); - Diag(Loc, diag::err_module_private_definition) - << T << Owner->getFullModuleName(); - Diag(SuggestedDef->getLocation(), diag::note_previous_definition); - - // Try to recover by implicitly importing this module. - createImplicitModuleImportForErrorRecovery(Loc, Owner); - } + !hasVisibleDefinition(Def, &SuggestedDef)) + diagnoseMissingImport(Loc, SuggestedDef, /*NeedDefinition*/true); // We lock in the inheritance model once somebody has asked us to ensure // that a pointer-to-member type is complete. diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h index f5249fdeb017..73dde7c97fc2 100644 --- a/lib/Sema/TreeTransform.h +++ b/lib/Sema/TreeTransform.h @@ -5386,6 +5386,17 @@ QualType TreeTransform<Derived>::TransformAttributedType( = getDerived().TransformType(oldType->getEquivalentType()); if (equivalentType.isNull()) return QualType(); + + // Check whether we can add nullability; it is only represented as + // type sugar, and therefore cannot be diagnosed in any other way. + if (auto nullability = oldType->getImmediateNullability()) { + if (!modifiedType->canHaveNullability()) { + SemaRef.Diag(TL.getAttrNameLoc(), diag::err_nullability_nonpointer) + << static_cast<unsigned>(*nullability) << false << modifiedType; + return QualType(); + } + } + result = SemaRef.Context.getAttributedType(oldType->getAttrKind(), modifiedType, equivalentType); @@ -6871,6 +6882,17 @@ TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) { } template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective( + OMPTaskgroupDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_taskgroup, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> StmtResult TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) { DeclarationNameInfo DirName; @@ -7950,6 +7972,25 @@ TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { E->usesGNUSyntax(), Init.get()); } +// Seems that if TransformInitListExpr() only works on the syntactic form of an +// InitListExpr, then a DesignatedInitUpdateExpr is not encountered. +template<typename Derived> +ExprResult +TreeTransform<Derived>::TransformDesignatedInitUpdateExpr( + DesignatedInitUpdateExpr *E) { + llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of " + "initializer"); + return ExprError(); +} + +template<typename Derived> +ExprResult +TreeTransform<Derived>::TransformNoInitExpr( + NoInitExpr *E) { + llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer"); + return ExprError(); +} + template<typename Derived> ExprResult TreeTransform<Derived>::TransformImplicitValueInitExpr( diff --git a/lib/Serialization/ASTReader.cpp b/lib/Serialization/ASTReader.cpp index 609c25da3ebd..d75b5eb73d51 100644 --- a/lib/Serialization/ASTReader.cpp +++ b/lib/Serialization/ASTReader.cpp @@ -19,6 +19,7 @@ #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" +#include "clang/Frontend/PCHContainerOperations.h" #include "clang/AST/NestedNameSpecifier.h" #include "clang/AST/Type.h" #include "clang/AST/TypeLocVisitor.h" @@ -3590,6 +3591,7 @@ ASTReader::ReadASTCore(StringRef FileName, ModuleFile &F = *M; BitstreamCursor &Stream = F.Stream; + PCHContainerOps.ExtractPCH(F.Buffer->getMemBufferRef(), F.StreamFile); Stream.init(&F.StreamFile); F.SizeInBits = F.Buffer->getBufferSize() * 8; @@ -3858,9 +3860,9 @@ static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile){ /// \brief Retrieve the name of the original source file name /// directly from the AST file, without actually loading the AST /// file. -std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, - FileManager &FileMgr, - DiagnosticsEngine &Diags) { +std::string ASTReader::getOriginalSourceFile( + const std::string &ASTFileName, FileManager &FileMgr, + const PCHContainerOperations &PCHContainerOps, DiagnosticsEngine &Diags) { // Open the AST file. auto Buffer = FileMgr.getBufferForFile(ASTFileName); if (!Buffer) { @@ -3871,8 +3873,7 @@ std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, // Initialize the stream llvm::BitstreamReader StreamFile; - StreamFile.init((const unsigned char *)(*Buffer)->getBufferStart(), - (const unsigned char *)(*Buffer)->getBufferEnd()); + PCHContainerOps.ExtractPCH((*Buffer)->getMemBufferRef(), StreamFile); BitstreamCursor Stream(StreamFile); // Sniff for the signature. @@ -3954,9 +3955,10 @@ namespace { }; } -bool ASTReader::readASTFileControlBlock(StringRef Filename, - FileManager &FileMgr, - ASTReaderListener &Listener) { +bool ASTReader::readASTFileControlBlock( + StringRef Filename, FileManager &FileMgr, + const PCHContainerOperations &PCHContainerOps, + ASTReaderListener &Listener) { // Open the AST file. // FIXME: This allows use of the VFS; we do not allow use of the // VFS when actually loading a module. @@ -4147,16 +4149,15 @@ bool ASTReader::readASTFileControlBlock(StringRef Filename, } } - -bool ASTReader::isAcceptableASTFile(StringRef Filename, - FileManager &FileMgr, - const LangOptions &LangOpts, - const TargetOptions &TargetOpts, - const PreprocessorOptions &PPOpts, - std::string ExistingModuleCachePath) { +bool ASTReader::isAcceptableASTFile( + StringRef Filename, FileManager &FileMgr, + const PCHContainerOperations &PCHContainerOps, const LangOptions &LangOpts, + const TargetOptions &TargetOpts, const PreprocessorOptions &PPOpts, + std::string ExistingModuleCachePath) { SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts, ExistingModuleCachePath, FileMgr); - return !readASTFileControlBlock(Filename, FileMgr, validator); + return !readASTFileControlBlock(Filename, FileMgr, PCHContainerOps, + validator); } ASTReader::ASTReadResult @@ -8407,24 +8408,26 @@ void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) { } } -ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, StringRef isysroot, - bool DisableValidation, bool AllowASTWithCompilerErrors, +ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, + const PCHContainerOperations &PCHContainerOps, + StringRef isysroot, bool DisableValidation, + bool AllowASTWithCompilerErrors, bool AllowConfigurationMismatch, bool ValidateSystemInputs, bool UseGlobalIndex) : Listener(new PCHValidator(PP, *this)), DeserializationListener(nullptr), OwnsDeserializationListener(false), SourceMgr(PP.getSourceManager()), - FileMgr(PP.getFileManager()), Diags(PP.getDiagnostics()), - SemaObj(nullptr), PP(PP), Context(Context), Consumer(nullptr), - ModuleMgr(PP.getFileManager()), isysroot(isysroot), - DisableValidation(DisableValidation), + FileMgr(PP.getFileManager()), PCHContainerOps(PCHContainerOps), + Diags(PP.getDiagnostics()), SemaObj(nullptr), PP(PP), Context(Context), + Consumer(nullptr), ModuleMgr(PP.getFileManager(), PCHContainerOps), + isysroot(isysroot), DisableValidation(DisableValidation), AllowASTWithCompilerErrors(AllowASTWithCompilerErrors), AllowConfigurationMismatch(AllowConfigurationMismatch), ValidateSystemInputs(ValidateSystemInputs), UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false), - CurrSwitchCaseStmts(&SwitchCaseStmts), - NumSLocEntriesRead(0), TotalNumSLocEntries(0), NumStatementsRead(0), - TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0), - NumIdentifierLookups(0), NumIdentifierLookupHits(0), NumSelectorsRead(0), + CurrSwitchCaseStmts(&SwitchCaseStmts), NumSLocEntriesRead(0), + TotalNumSLocEntries(0), NumStatementsRead(0), TotalNumStatements(0), + NumMacrosRead(0), TotalNumMacros(0), NumIdentifierLookups(0), + NumIdentifierLookupHits(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolLookups(0), NumMethodPoolHits(0), NumMethodPoolTableLookups(0), NumMethodPoolTableHits(0), TotalNumMethodPoolEntries(0), diff --git a/lib/Serialization/ASTReaderDecl.cpp b/lib/Serialization/ASTReaderDecl.cpp index 02273ed229a5..00ebd3ebe8e4 100644 --- a/lib/Serialization/ASTReaderDecl.cpp +++ b/lib/Serialization/ASTReaderDecl.cpp @@ -365,9 +365,72 @@ namespace clang { void VisitObjCPropertyDecl(ObjCPropertyDecl *D); void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D); + + /// We've merged the definition \p MergedDef into the existing definition + /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made + /// visible. + void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef) { + if (Def->isHidden()) { + // If MergedDef is visible or becomes visible, make the definition visible. + if (!MergedDef->isHidden()) + Def->Hidden = false; + else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) { + Reader.getContext().mergeDefinitionIntoModule( + Def, MergedDef->getImportedOwningModule(), + /*NotifyListeners*/ false); + Reader.PendingMergedDefinitionsToDeduplicate.insert(Def); + } else { + auto SubmoduleID = MergedDef->getOwningModuleID(); + assert(SubmoduleID && "hidden definition in no module"); + Reader.HiddenNamesMap[Reader.getSubmodule(SubmoduleID)].push_back(Def); + } + } + } }; } +namespace { +/// Iterator over the redeclarations of a declaration that have already +/// been merged into the same redeclaration chain. +template<typename DeclT> +class MergedRedeclIterator { + DeclT *Start, *Canonical, *Current; +public: + MergedRedeclIterator() : Current(nullptr) {} + MergedRedeclIterator(DeclT *Start) + : Start(Start), Canonical(nullptr), Current(Start) {} + + DeclT *operator*() { return Current; } + + MergedRedeclIterator &operator++() { + if (Current->isFirstDecl()) { + Canonical = Current; + Current = Current->getMostRecentDecl(); + } else + Current = Current->getPreviousDecl(); + + // If we started in the merged portion, we'll reach our start position + // eventually. Otherwise, we'll never reach it, but the second declaration + // we reached was the canonical declaration, so stop when we see that one + // again. + if (Current == Start || Current == Canonical) + Current = nullptr; + return *this; + } + + friend bool operator!=(const MergedRedeclIterator &A, + const MergedRedeclIterator &B) { + return A.Current != B.Current; + } +}; +} +template<typename DeclT> +llvm::iterator_range<MergedRedeclIterator<DeclT>> merged_redecls(DeclT *D) { + return llvm::iterator_range<MergedRedeclIterator<DeclT>>( + MergedRedeclIterator<DeclT>(D), + MergedRedeclIterator<DeclT>()); +} + uint64_t ASTDeclReader::GetCurrentCursorOffset() { return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset; } @@ -585,9 +648,21 @@ void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) { if (ED->IsCompleteDefinition && Reader.getContext().getLangOpts().Modules && Reader.getContext().getLangOpts().CPlusPlus) { - if (EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()]) { + EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()]; + if (!OldDef) { + // This is the first time we've seen an imported definition. Look for a + // local definition before deciding that we are the first definition. + for (auto *D : merged_redecls(ED->getCanonicalDecl())) { + if (!D->isFromASTFile() && D->isCompleteDefinition()) { + OldDef = D; + break; + } + } + } + if (OldDef) { Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef)); ED->IsCompleteDefinition = false; + mergeDefinitionVisibility(OldDef, ED); } else { OldDef = ED; } @@ -967,7 +1042,9 @@ void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { VisitNamedDecl(D); D->setAtLoc(ReadSourceLocation(Record, Idx)); D->setLParenLoc(ReadSourceLocation(Record, Idx)); - D->setType(GetTypeSourceInfo(Record, Idx)); + QualType T = Reader.readType(F, Record, Idx); + TypeSourceInfo *TSI = GetTypeSourceInfo(Record, Idx); + D->setType(T, TSI); // FIXME: stable encoding D->setPropertyAttributes( (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]); @@ -1391,32 +1468,22 @@ void ASTDeclReader::MergeDefinitionData( "merging class definition into non-definition"); auto &DD = *D->DefinitionData.getNotUpdated(); - // If the new definition has new special members, let the name lookup - // code know that it needs to look in the new definition too. - // - // FIXME: We only need to do this if the merged definition declares members - // that this definition did not declare, or if it defines members that this - // definition did not define. if (DD.Definition != MergeDD.Definition) { + // If the new definition has new special members, let the name lookup + // code know that it needs to look in the new definition too. + // + // FIXME: We only need to do this if the merged definition declares members + // that this definition did not declare, or if it defines members that this + // definition did not define. Reader.MergedLookups[DD.Definition].push_back(MergeDD.Definition); DD.Definition->setHasExternalVisibleStorage(); - if (DD.Definition->isHidden()) { - // If MergeDD is visible or becomes visible, make the definition visible. - if (!MergeDD.Definition->isHidden()) - DD.Definition->Hidden = false; - else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) { - Reader.getContext().mergeDefinitionIntoModule( - DD.Definition, MergeDD.Definition->getImportedOwningModule(), - /*NotifyListeners*/ false); - Reader.PendingMergedDefinitionsToDeduplicate.insert(DD.Definition); - } else { - auto SubmoduleID = MergeDD.Definition->getOwningModuleID(); - assert(SubmoduleID && "hidden definition in no module"); - Reader.HiddenNamesMap[Reader.getSubmodule(SubmoduleID)].push_back( - DD.Definition); - } - } + // Track that we merged the definitions. + Reader.MergedDeclContexts.insert(std::make_pair(MergeDD.Definition, + DD.Definition)); + Reader.PendingDefinitions.erase(MergeDD.Definition); + MergeDD.Definition->IsCompleteDefinition = false; + mergeDefinitionVisibility(DD.Definition, MergeDD.Definition); } auto PFDI = Reader.PendingFakeDefinitionData.find(&DD); @@ -1525,42 +1592,21 @@ void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update) { // because we're reading an update record, or because we've already done some // merging. Either way, just merge into it. CXXRecordDecl *Canon = D->getCanonicalDecl(); - if (auto *CanonDD = Canon->DefinitionData.getNotUpdated()) { - if (CanonDD->Definition != DD->Definition) - Reader.MergedDeclContexts.insert( - std::make_pair(DD->Definition, CanonDD->Definition)); + if (Canon->DefinitionData.getNotUpdated()) { MergeDefinitionData(Canon, std::move(*DD)); D->DefinitionData = Canon->DefinitionData; return; } - // Propagate the DefinitionData pointer to the canonical declaration, so - // that all other deserialized declarations will see it. - if (Canon == D) { - D->DefinitionData = DD; - D->IsCompleteDefinition = true; - - // If this is an update record, we can have redeclarations already. Make a - // note that we need to propagate the DefinitionData pointer onto them. - if (Update) - Reader.PendingDefinitions.insert(D); - } else if (auto *CanonDD = Canon->DefinitionData.getNotUpdated()) { - // We have already deserialized a definition of this record. This - // definition is no longer really a definition. Note that the pre-existing - // definition is the *real* definition. - Reader.MergedDeclContexts.insert( - std::make_pair(D, CanonDD->Definition)); - D->DefinitionData = Canon->DefinitionData; - D->IsCompleteDefinition = false; - MergeDefinitionData(D, std::move(*DD)); - } else { - Canon->DefinitionData = DD; - D->DefinitionData = Canon->DefinitionData; - D->IsCompleteDefinition = true; + // Mark this declaration as being a definition. + D->IsCompleteDefinition = true; + D->DefinitionData = DD; - // Note that we have deserialized a definition. Any declarations - // deserialized before this one will be be given the DefinitionData - // pointer at the end. + // If this is not the first declaration or is an update record, we can have + // other redeclarations already. Make a note that we need to propagate the + // DefinitionData pointer onto them. + if (Update || Canon != D) { + Canon->DefinitionData = D->DefinitionData; Reader.PendingDefinitions.insert(D); } } @@ -1880,15 +1926,10 @@ ASTDeclReader::VisitClassTemplateSpecializationDeclImpl( // This declaration might be a definition. Merge with any existing // definition. if (auto *DDD = D->DefinitionData.getNotUpdated()) { - if (auto *CanonDD = CanonSpec->DefinitionData.getNotUpdated()) { + if (CanonSpec->DefinitionData.getNotUpdated()) MergeDefinitionData(CanonSpec, std::move(*DDD)); - Reader.PendingDefinitions.erase(D); - Reader.MergedDeclContexts.insert( - std::make_pair(D, CanonDD->Definition)); - D->IsCompleteDefinition = false; - } else { + else CanonSpec->DefinitionData = D->DefinitionData; - } } D->DefinitionData = CanonSpec->DefinitionData; } @@ -2033,9 +2074,8 @@ void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { D->setDeclaredWithTypename(Record[Idx++]); - bool Inherited = Record[Idx++]; - TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx); - D->setDefaultArgument(DefArg, Inherited); + if (Record[Idx++]) + D->setDefaultArgument(GetTypeSourceInfo(Record, Idx)); } void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { @@ -2052,11 +2092,8 @@ void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { } else { // Rest of NonTypeTemplateParmDecl. D->ParameterPack = Record[Idx++]; - if (Record[Idx++]) { - Expr *DefArg = Reader.ReadExpr(F); - bool Inherited = Record[Idx++]; - D->setDefaultArgument(DefArg, Inherited); - } + if (Record[Idx++]) + D->setDefaultArgument(Reader.ReadExpr(F)); } } @@ -2072,10 +2109,10 @@ void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx); } else { // Rest of TemplateTemplateParmDecl. - TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx); - bool IsInherited = Record[Idx++]; - D->setDefaultArgument(Arg, IsInherited); D->ParameterPack = Record[Idx++]; + if (Record[Idx++]) + D->setDefaultArgument(Reader.getContext(), + Reader.ReadTemplateArgumentLoc(F, Record, Idx)); } } @@ -2189,14 +2226,12 @@ void ASTDeclReader::mergeTemplatePattern(RedeclarableTemplateDecl *D, auto *ExistingClass = cast<CXXRecordDecl>(ExistingPattern)->getCanonicalDecl(); if (auto *DDD = DClass->DefinitionData.getNotUpdated()) { - if (auto *ExistingDD = ExistingClass->DefinitionData.getNotUpdated()) { + if (ExistingClass->DefinitionData.getNotUpdated()) { MergeDefinitionData(ExistingClass, std::move(*DDD)); - Reader.PendingDefinitions.erase(DClass); - Reader.MergedDeclContexts.insert( - std::make_pair(DClass, ExistingDD->Definition)); - DClass->IsCompleteDefinition = false; } else { ExistingClass->DefinitionData = DClass->DefinitionData; + // We may have skipped this before because we thought that DClass + // was the canonical declaration. Reader.PendingDefinitions.insert(DClass); } } @@ -2904,6 +2939,43 @@ void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader, ...) { llvm_unreachable("attachPreviousDecl on non-redeclarable declaration"); } +/// Inherit the default template argument from \p From to \p To. Returns +/// \c false if there is no default template for \p From. +template <typename ParmDecl> +static bool inheritDefaultTemplateArgument(ASTContext &Context, ParmDecl *From, + Decl *ToD) { + auto *To = cast<ParmDecl>(ToD); + if (!From->hasDefaultArgument()) + return false; + To->setInheritedDefaultArgument(Context, From); + return true; +} + +static void inheritDefaultTemplateArguments(ASTContext &Context, + TemplateDecl *From, + TemplateDecl *To) { + auto *FromTP = From->getTemplateParameters(); + auto *ToTP = To->getTemplateParameters(); + assert(FromTP->size() == ToTP->size() && "merged mismatched templates?"); + + for (unsigned I = 0, N = FromTP->size(); I != N; ++I) { + NamedDecl *FromParam = FromTP->getParam(N - I - 1); + NamedDecl *ToParam = ToTP->getParam(N - I - 1); + + if (auto *FTTP = dyn_cast<TemplateTypeParmDecl>(FromParam)) { + if (!inheritDefaultTemplateArgument(Context, FTTP, ToParam)) + break; + } else if (auto *FNTTP = dyn_cast<NonTypeTemplateParmDecl>(FromParam)) { + if (!inheritDefaultTemplateArgument(Context, FNTTP, ToParam)) + break; + } else { + if (!inheritDefaultTemplateArgument( + Context, cast<TemplateTemplateParmDecl>(FromParam), ToParam)) + break; + } + } +} + void ASTDeclReader::attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous, Decl *Canon) { assert(D && Previous); @@ -2930,6 +3002,12 @@ void ASTDeclReader::attachPreviousDecl(ASTReader &Reader, Decl *D, // be too. if (Previous->Used) D->Used = true; + + // If the declaration declares a template, it may inherit default arguments + // from the previous declaration. + if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D)) + inheritDefaultTemplateArguments(Reader.getContext(), + cast<TemplateDecl>(Previous), TD); } template<typename DeclT> @@ -3579,48 +3657,6 @@ void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID, ModuleMgr.visit(ObjCCategoriesVisitor::visit, &Visitor); } -namespace { -/// Iterator over the redeclarations of a declaration that have already -/// been merged into the same redeclaration chain. -template<typename DeclT> -class MergedRedeclIterator { - DeclT *Start, *Canonical, *Current; -public: - MergedRedeclIterator() : Current(nullptr) {} - MergedRedeclIterator(DeclT *Start) - : Start(Start), Canonical(nullptr), Current(Start) {} - - DeclT *operator*() { return Current; } - - MergedRedeclIterator &operator++() { - if (Current->isFirstDecl()) { - Canonical = Current; - Current = Current->getMostRecentDecl(); - } else - Current = Current->getPreviousDecl(); - - // If we started in the merged portion, we'll reach our start position - // eventually. Otherwise, we'll never reach it, but the second declaration - // we reached was the canonical declaration, so stop when we see that one - // again. - if (Current == Start || Current == Canonical) - Current = nullptr; - return *this; - } - - friend bool operator!=(const MergedRedeclIterator &A, - const MergedRedeclIterator &B) { - return A.Current != B.Current; - } -}; -} -template<typename DeclT> -llvm::iterator_range<MergedRedeclIterator<DeclT>> merged_redecls(DeclT *D) { - return llvm::iterator_range<MergedRedeclIterator<DeclT>>( - MergedRedeclIterator<DeclT>(D), - MergedRedeclIterator<DeclT>()); -} - template<typename DeclT, typename Fn> static void forAllLaterRedecls(DeclT *D, Fn F) { F(D); @@ -3854,6 +3890,9 @@ void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile, case UPD_DECL_EXPORTED: unsigned SubmoduleID = readSubmoduleID(Record, Idx); + auto *Exported = cast<NamedDecl>(D); + if (auto *TD = dyn_cast<TagDecl>(Exported)) + Exported = TD->getDefinition(); Module *Owner = SubmoduleID ? Reader.getSubmodule(SubmoduleID) : nullptr; if (Reader.getContext().getLangOpts().ModulesLocalVisibility) { // FIXME: This doesn't send the right notifications if there are diff --git a/lib/Serialization/ASTReaderStmt.cpp b/lib/Serialization/ASTReaderStmt.cpp index d1ecd4672488..c15f6b0b552f 100644 --- a/lib/Serialization/ASTReaderStmt.cpp +++ b/lib/Serialization/ASTReaderStmt.cpp @@ -801,6 +801,16 @@ void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { Designators.data(), Designators.size()); } +void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { + VisitExpr(E); + E->setBase(Reader.ReadSubExpr()); + E->setUpdater(Reader.ReadSubExpr()); +} + +void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) { + VisitExpr(E); +} + void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { VisitExpr(E); } @@ -2063,9 +2073,7 @@ void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) { D->setLastIteration(Reader.ReadSubExpr()); D->setCalcLastIteration(Reader.ReadSubExpr()); D->setPreCond(Reader.ReadSubExpr()); - auto Fst = Reader.ReadSubExpr(); - auto Snd = Reader.ReadSubExpr(); - D->setCond(Fst, Snd); + D->setCond(Reader.ReadSubExpr()); D->setInit(Reader.ReadSubExpr()); D->setInc(Reader.ReadSubExpr()); if (isOpenMPWorksharingDirective(D->getDirectiveKind())) { @@ -2181,6 +2189,11 @@ void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { VisitOMPExecutableDirective(D); } +void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); +} + void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. @@ -2549,10 +2562,18 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { break; + case EXPR_DESIGNATED_INIT_UPDATE: + S = new (Context) DesignatedInitUpdateExpr(Empty); + break; + case EXPR_IMPLICIT_VALUE_INIT: S = new (Context) ImplicitValueInitExpr(Empty); break; + case EXPR_NO_INIT: + S = new (Context) NoInitExpr(Empty); + break; + case EXPR_VA_ARG: S = new (Context) VAArgExpr(Empty); break; @@ -2787,6 +2808,10 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { S = OMPTaskwaitDirective::CreateEmpty(Context, Empty); break; + case STMT_OMP_TASKGROUP_DIRECTIVE: + S = OMPTaskgroupDirective::CreateEmpty(Context, Empty); + break; + case STMT_OMP_FLUSH_DIRECTIVE: S = OMPFlushDirective::CreateEmpty( Context, Record[ASTStmtReader::NumStmtFields], Empty); diff --git a/lib/Serialization/ASTWriter.cpp b/lib/Serialization/ASTWriter.cpp index e689234c20e9..5bb0bec4f569 100644 --- a/lib/Serialization/ASTWriter.cpp +++ b/lib/Serialization/ASTWriter.cpp @@ -774,7 +774,9 @@ static void AddStmtsExprs(llvm::BitstreamWriter &Stream, RECORD(EXPR_EXT_VECTOR_ELEMENT); RECORD(EXPR_INIT_LIST); RECORD(EXPR_DESIGNATED_INIT); + RECORD(EXPR_DESIGNATED_INIT_UPDATE); RECORD(EXPR_IMPLICIT_VALUE_INIT); + RECORD(EXPR_NO_INIT); RECORD(EXPR_VA_ARG); RECORD(EXPR_ADDR_LABEL); RECORD(EXPR_STMT); @@ -5762,8 +5764,5 @@ void ASTWriter::DeclarationMarkedOpenMPThreadPrivate(const Decl *D) { void ASTWriter::RedefinedHiddenDefinition(const NamedDecl *D, Module *M) { assert(!WritingAST && "Already writing the AST!"); assert(D->isHidden() && "expected a hidden declaration"); - if (!D->isFromASTFile()) - return; - DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_EXPORTED, M)); } diff --git a/lib/Serialization/ASTWriterDecl.cpp b/lib/Serialization/ASTWriterDecl.cpp index 0fa4f936a35a..6c5bc5bbd483 100644 --- a/lib/Serialization/ASTWriterDecl.cpp +++ b/lib/Serialization/ASTWriterDecl.cpp @@ -190,8 +190,7 @@ namespace clang { assert(D->isCanonicalDecl() && "non-canonical decl in set"); Writer.AddDeclRef(D, Record); } - for (DeclID ID : LazySpecializations) - Record.push_back(ID); + Record.append(LazySpecializations.begin(), LazySpecializations.end()); } }; } @@ -543,7 +542,7 @@ void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) { // FIXME: stable encoding for @required/@optional Record.push_back(D->getImplementationControl()); - // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway + // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway/nullability Record.push_back(D->getObjCDeclQualifier()); Record.push_back(D->hasRelatedResultType()); Writer.AddTypeRef(D->getReturnType(), Record); @@ -679,6 +678,7 @@ void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { VisitNamedDecl(D); Writer.AddSourceLocation(D->getAtLoc(), Record); Writer.AddSourceLocation(D->getLParenLoc(), Record); + Writer.AddTypeRef(D->getType(), Record); Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record); // FIXME: stable encoding Record.push_back((unsigned)D->getPropertyAttributes()); @@ -1380,8 +1380,12 @@ void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { VisitTypeDecl(D); Record.push_back(D->wasDeclaredWithTypename()); - Record.push_back(D->defaultArgumentWasInherited()); - Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record); + + bool OwnsDefaultArg = D->hasDefaultArgument() && + !D->defaultArgumentWasInherited(); + Record.push_back(OwnsDefaultArg); + if (OwnsDefaultArg) + Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record); Code = serialization::DECL_TEMPLATE_TYPE_PARM; } @@ -1408,11 +1412,11 @@ void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { } else { // Rest of NonTypeTemplateParmDecl. Record.push_back(D->isParameterPack()); - Record.push_back(D->getDefaultArgument() != nullptr); - if (D->getDefaultArgument()) { + bool OwnsDefaultArg = D->hasDefaultArgument() && + !D->defaultArgumentWasInherited(); + Record.push_back(OwnsDefaultArg); + if (OwnsDefaultArg) Writer.AddStmt(D->getDefaultArgument()); - Record.push_back(D->defaultArgumentWasInherited()); - } Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM; } } @@ -1437,9 +1441,12 @@ void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK; } else { // Rest of TemplateTemplateParmDecl. - Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record); - Record.push_back(D->defaultArgumentWasInherited()); Record.push_back(D->isParameterPack()); + bool OwnsDefaultArg = D->hasDefaultArgument() && + !D->defaultArgumentWasInherited(); + Record.push_back(OwnsDefaultArg); + if (OwnsDefaultArg) + Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record); Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM; } } diff --git a/lib/Serialization/ASTWriterStmt.cpp b/lib/Serialization/ASTWriterStmt.cpp index ec822f02c67f..a461d3f66390 100644 --- a/lib/Serialization/ASTWriterStmt.cpp +++ b/lib/Serialization/ASTWriterStmt.cpp @@ -738,6 +738,18 @@ void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) { Code = serialization::EXPR_DESIGNATED_INIT; } +void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { + VisitExpr(E); + Writer.AddStmt(E->getBase()); + Writer.AddStmt(E->getUpdater()); + Code = serialization::EXPR_DESIGNATED_INIT_UPDATE; +} + +void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) { + VisitExpr(E); + Code = serialization::EXPR_NO_INIT; +} + void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { VisitExpr(E); Code = serialization::EXPR_IMPLICIT_VALUE_INIT; @@ -1917,8 +1929,7 @@ void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) { Writer.AddStmt(D->getLastIteration()); Writer.AddStmt(D->getCalcLastIteration()); Writer.AddStmt(D->getPreCond()); - Writer.AddStmt(D->getCond(/* SeparateIter */ false)); - Writer.AddStmt(D->getCond(/* SeparateIter */ true)); + Writer.AddStmt(D->getCond()); Writer.AddStmt(D->getInit()); Writer.AddStmt(D->getInc()); if (isOpenMPWorksharingDirective(D->getDirectiveKind())) { @@ -2060,6 +2071,12 @@ void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE; } +void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); + Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE; +} + void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) { VisitStmt(D); Record.push_back(D->getNumClauses()); diff --git a/lib/Serialization/GeneratePCH.cpp b/lib/Serialization/GeneratePCH.cpp index b5031fdf92a4..c50b3f9bb9e2 100644 --- a/lib/Serialization/GeneratePCH.cpp +++ b/lib/Serialization/GeneratePCH.cpp @@ -24,16 +24,14 @@ using namespace clang; -PCHGenerator::PCHGenerator(const Preprocessor &PP, - StringRef OutputFile, - clang::Module *Module, - StringRef isysroot, - raw_ostream *OS, bool AllowASTWithErrors) - : PP(PP), OutputFile(OutputFile), Module(Module), - isysroot(isysroot.str()), Out(OS), - SemaPtr(nullptr), Stream(Buffer), Writer(Stream), - AllowASTWithErrors(AllowASTWithErrors), - HasEmittedPCH(false) { +PCHGenerator::PCHGenerator(const Preprocessor &PP, StringRef OutputFile, + clang::Module *Module, StringRef isysroot, + std::shared_ptr<PCHBuffer> Buffer, + bool AllowASTWithErrors) + : PP(PP), OutputFile(OutputFile), Module(Module), isysroot(isysroot.str()), + SemaPtr(nullptr), Buffer(Buffer), Stream(Buffer->Data), Writer(Stream), + AllowASTWithErrors(AllowASTWithErrors) { + Buffer->IsComplete = false; } PCHGenerator::~PCHGenerator() { @@ -47,21 +45,12 @@ void PCHGenerator::HandleTranslationUnit(ASTContext &Ctx) { bool hasErrors = PP.getDiagnostics().hasErrorOccurred(); if (hasErrors && !AllowASTWithErrors) return; - - // Emit the PCH file + + // Emit the PCH file to the Buffer. assert(SemaPtr && "No Sema?"); Writer.WriteAST(*SemaPtr, OutputFile, Module, isysroot, hasErrors); - // Write the generated bitstream to "Out". - Out->write((char *)&Buffer.front(), Buffer.size()); - - // Make sure it hits disk now. - Out->flush(); - - // Free up some memory, in case the process is kept alive. - Buffer.clear(); - - HasEmittedPCH = true; + Buffer->IsComplete = true; } ASTMutationListener *PCHGenerator::GetASTMutationListener() { diff --git a/lib/Serialization/GlobalModuleIndex.cpp b/lib/Serialization/GlobalModuleIndex.cpp index 1b52b441134f..2c7da3e82a44 100644 --- a/lib/Serialization/GlobalModuleIndex.cpp +++ b/lib/Serialization/GlobalModuleIndex.cpp @@ -12,6 +12,7 @@ //===----------------------------------------------------------------------===// #include "ASTReaderInternals.h" +#include "clang/Frontend/PCHContainerOperations.h" #include "clang/Basic/FileManager.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Serialization/ASTBitCodes.h" @@ -384,6 +385,7 @@ namespace { /// \brief Builder that generates the global module index file. class GlobalModuleIndexBuilder { FileManager &FileMgr; + const PCHContainerOperations &PCHContainerOps; /// \brief Mapping from files to module file information. typedef llvm::MapVector<const FileEntry *, ModuleFileInfo> ModuleFilesMap; @@ -416,7 +418,9 @@ namespace { } public: - explicit GlobalModuleIndexBuilder(FileManager &FileMgr) : FileMgr(FileMgr){} + explicit GlobalModuleIndexBuilder( + FileManager &FileMgr, const PCHContainerOperations &PCHContainerOps) + : FileMgr(FileMgr), PCHContainerOps(PCHContainerOps) {} /// \brief Load the contents of the given module file into the builder. /// @@ -501,8 +505,7 @@ bool GlobalModuleIndexBuilder::loadModuleFile(const FileEntry *File) { // Initialize the input stream llvm::BitstreamReader InStreamFile; - InStreamFile.init((const unsigned char *)(*Buffer)->getBufferStart(), - (const unsigned char *)(*Buffer)->getBufferEnd()); + PCHContainerOps.ExtractPCH((*Buffer)->getMemBufferRef(), InStreamFile); llvm::BitstreamCursor InStream(InStreamFile); // Sniff for the signature. @@ -764,7 +767,9 @@ void GlobalModuleIndexBuilder::writeIndex(llvm::BitstreamWriter &Stream) { } GlobalModuleIndex::ErrorCode -GlobalModuleIndex::writeIndex(FileManager &FileMgr, StringRef Path) { +GlobalModuleIndex::writeIndex(FileManager &FileMgr, + const PCHContainerOperations &PCHContainerOps, + StringRef Path) { llvm::SmallString<128> IndexPath; IndexPath += Path; llvm::sys::path::append(IndexPath, IndexFileName); @@ -787,8 +792,8 @@ GlobalModuleIndex::writeIndex(FileManager &FileMgr, StringRef Path) { } // The module index builder. - GlobalModuleIndexBuilder Builder(FileMgr); - + GlobalModuleIndexBuilder Builder(FileMgr, PCHContainerOps); + // Load each of the module files. std::error_code EC; for (llvm::sys::fs::directory_iterator D(Path, EC), DEnd; diff --git a/lib/Serialization/ModuleManager.cpp b/lib/Serialization/ModuleManager.cpp index 30d9c89a1244..03d8ed0e2467 100644 --- a/lib/Serialization/ModuleManager.cpp +++ b/lib/Serialization/ModuleManager.cpp @@ -11,6 +11,7 @@ // modules for the ASTReader. // //===----------------------------------------------------------------------===// +#include "clang/Frontend/PCHContainerOperations.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/ModuleMap.h" #include "clang/Serialization/GlobalModuleIndex.h" @@ -136,10 +137,9 @@ ModuleManager::addModule(StringRef FileName, ModuleKind Type, New->Buffer = std::move(*Buf); } - - // Initialize the stream - New->StreamFile.init((const unsigned char *)New->Buffer->getBufferStart(), - (const unsigned char *)New->Buffer->getBufferEnd()); + + // Initialize the stream. + PCHContainerOps.ExtractPCH(New->Buffer->getMemBufferRef(), New->StreamFile); } if (ExpectedSignature) { @@ -289,8 +289,10 @@ void ModuleManager::moduleFileAccepted(ModuleFile *MF) { ModulesInCommonWithGlobalIndex.push_back(MF); } -ModuleManager::ModuleManager(FileManager &FileMgr) - : FileMgr(FileMgr), GlobalIndex(), FirstVisitState(nullptr) {} +ModuleManager::ModuleManager(FileManager &FileMgr, + const PCHContainerOperations &PCHContainerOps) + : FileMgr(FileMgr), PCHContainerOps(PCHContainerOps), GlobalIndex(), + FirstVisitState(nullptr) {} ModuleManager::~ModuleManager() { for (unsigned i = 0, e = Chain.size(); i != e; ++i) diff --git a/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp b/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp index d1938a0f7f7e..4f0b7e51da10 100644 --- a/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp @@ -29,7 +29,8 @@ using namespace ento; namespace { class ObjCContainersChecker : public Checker< check::PreStmt<CallExpr>, - check::PostStmt<CallExpr> > { + check::PostStmt<CallExpr>, + check::PointerEscape> { mutable std::unique_ptr<BugType> BT; inline void initBugType() const { if (!BT) @@ -52,6 +53,10 @@ public: void checkPostStmt(const CallExpr *CE, CheckerContext &C) const; void checkPreStmt(const CallExpr *CE, CheckerContext &C) const; + ProgramStateRef checkPointerEscape(ProgramStateRef State, + const InvalidatedSymbols &Escaped, + const CallEvent *Call, + PointerEscapeKind Kind) const; }; } // end anonymous namespace @@ -146,6 +151,24 @@ void ObjCContainersChecker::checkPreStmt(const CallExpr *CE, } } +ProgramStateRef +ObjCContainersChecker::checkPointerEscape(ProgramStateRef State, + const InvalidatedSymbols &Escaped, + const CallEvent *Call, + PointerEscapeKind Kind) const { + for (InvalidatedSymbols::const_iterator I = Escaped.begin(), + E = Escaped.end(); + I != E; ++I) { + SymbolRef Sym = *I; + // When a symbol for a mutable array escapes, we can't reason precisely + // about its size any more -- so remove it from the map. + // Note that we aren't notified here when a CFMutableArrayRef escapes as a + // CFArrayRef. This is because CFArrayRef is typedef'd as a pointer to a + // const-qualified type. + State = State->remove<ArraySizeMap>(Sym); + } + return State; +} /// Register checker. void ento::registerObjCContainersChecker(CheckerManager &mgr) { mgr.registerChecker<ObjCContainersChecker>(); diff --git a/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp b/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp index 58c27d49acce..49eef236e906 100644 --- a/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp @@ -906,6 +906,8 @@ static ArgEffect getStopTrackingHardEquivalent(ArgEffect E) { case IncRef: case IncRefMsg: case MakeCollectable: + case UnretainedOutParameter: + case RetainedOutParameter: case MayEscape: case StopTracking: case StopTrackingHard: @@ -1335,7 +1337,18 @@ RetainSummaryManager::updateSummaryFromAnnotations(const RetainSummary *&Summ, if (pd->hasAttr<NSConsumedAttr>()) Template->addArg(AF, parm_idx, DecRefMsg); else if (pd->hasAttr<CFConsumedAttr>()) - Template->addArg(AF, parm_idx, DecRef); + Template->addArg(AF, parm_idx, DecRef); + else if (pd->hasAttr<CFReturnsRetainedAttr>()) { + QualType PointeeTy = pd->getType()->getPointeeType(); + if (!PointeeTy.isNull()) + if (coreFoundation::isCFObjectRef(PointeeTy)) + Template->addArg(AF, parm_idx, RetainedOutParameter); + } else if (pd->hasAttr<CFReturnsNotRetainedAttr>()) { + QualType PointeeTy = pd->getType()->getPointeeType(); + if (!PointeeTy.isNull()) + if (coreFoundation::isCFObjectRef(PointeeTy)) + Template->addArg(AF, parm_idx, UnretainedOutParameter); + } } QualType RetTy = FD->getReturnType(); @@ -1366,7 +1379,17 @@ RetainSummaryManager::updateSummaryFromAnnotations(const RetainSummary *&Summ, Template->addArg(AF, parm_idx, DecRefMsg); else if (pd->hasAttr<CFConsumedAttr>()) { Template->addArg(AF, parm_idx, DecRef); - } + } else if (pd->hasAttr<CFReturnsRetainedAttr>()) { + QualType PointeeTy = pd->getType()->getPointeeType(); + if (!PointeeTy.isNull()) + if (coreFoundation::isCFObjectRef(PointeeTy)) + Template->addArg(AF, parm_idx, RetainedOutParameter); + } else if (pd->hasAttr<CFReturnsNotRetainedAttr>()) { + QualType PointeeTy = pd->getType()->getPointeeType(); + if (!PointeeTy.isNull()) + if (coreFoundation::isCFObjectRef(PointeeTy)) + Template->addArg(AF, parm_idx, UnretainedOutParameter); + } } QualType RetTy = MD->getReturnType(); @@ -2746,7 +2769,6 @@ void RetainCountChecker::checkPostStmt(const CastExpr *CE, if (hasErr) { // FIXME: If we get an error during a bridge cast, should we report it? - // Should we assert that there is no error? return; } @@ -2951,6 +2973,40 @@ void RetainCountChecker::processSummaryOfInlined(const RetainSummary &Summ, C.addTransition(state); } +static ProgramStateRef updateOutParameter(ProgramStateRef State, + SVal ArgVal, + ArgEffect Effect) { + auto *ArgRegion = dyn_cast_or_null<TypedValueRegion>(ArgVal.getAsRegion()); + if (!ArgRegion) + return State; + + QualType PointeeTy = ArgRegion->getValueType(); + if (!coreFoundation::isCFObjectRef(PointeeTy)) + return State; + + SVal PointeeVal = State->getSVal(ArgRegion); + SymbolRef Pointee = PointeeVal.getAsLocSymbol(); + if (!Pointee) + return State; + + switch (Effect) { + case UnretainedOutParameter: + State = setRefBinding(State, Pointee, + RefVal::makeNotOwned(RetEffect::CF, PointeeTy)); + break; + case RetainedOutParameter: + // Do nothing. Retained out parameters will either point to a +1 reference + // or NULL, but the way you check for failure differs depending on the API. + // Consequently, we don't have a good way to track them yet. + break; + + default: + llvm_unreachable("only for out parameters"); + } + + return State; +} + void RetainCountChecker::checkSummary(const RetainSummary &Summ, const CallEvent &CallOrMsg, CheckerContext &C) const { @@ -2964,9 +3020,12 @@ void RetainCountChecker::checkSummary(const RetainSummary &Summ, for (unsigned idx = 0, e = CallOrMsg.getNumArgs(); idx != e; ++idx) { SVal V = CallOrMsg.getArgSVal(idx); - if (SymbolRef Sym = V.getAsLocSymbol()) { + ArgEffect Effect = Summ.getArg(idx); + if (Effect == RetainedOutParameter || Effect == UnretainedOutParameter) { + state = updateOutParameter(state, V, Effect); + } else if (SymbolRef Sym = V.getAsLocSymbol()) { if (const RefVal *T = getRefBinding(state, Sym)) { - state = updateSymbol(state, Sym, *T, Summ.getArg(idx), hasErr, C); + state = updateSymbol(state, Sym, *T, Effect, hasErr, C); if (hasErr) { ErrorRange = CallOrMsg.getArgSourceRange(idx); ErrorSym = Sym; @@ -3115,6 +3174,11 @@ RetainCountChecker::updateSymbol(ProgramStateRef state, SymbolRef sym, case DecRefMsgAndStopTrackingHard: llvm_unreachable("DecRefMsg/IncRefMsg/MakeCollectable already converted"); + case UnretainedOutParameter: + case RetainedOutParameter: + llvm_unreachable("Applies to pointer-to-pointer parameters, which should " + "not have ref state."); + case Dealloc: // Any use of -dealloc in GC is *bad*. if (C.isObjCGCEnabled()) { diff --git a/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp b/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp index b906cc9e7624..fa7884f4a462 100644 --- a/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp +++ b/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp @@ -1529,7 +1529,7 @@ LikelyFalsePositiveSuppressionBRVisitor::getEndPath(BugReporterContext &BRC, return nullptr; } else { - // If the the complete 'std' suppression is not enabled, suppress reports + // If the complete 'std' suppression is not enabled, suppress reports // from the 'std' namespace that are known to produce false positives. // The analyzer issues a false use-after-free when std::list::pop_front diff --git a/lib/StaticAnalyzer/Core/CallEvent.cpp b/lib/StaticAnalyzer/Core/CallEvent.cpp index f67354466006..8542f7d6a86b 100644 --- a/lib/StaticAnalyzer/Core/CallEvent.cpp +++ b/lib/StaticAnalyzer/Core/CallEvent.cpp @@ -785,7 +785,7 @@ RuntimeDefinition ObjCMethodCall::getRuntimeDefinition() const { if (E->isInstanceMessage()) { - // Find the the receiver type. + // Find the receiver type. const ObjCObjectPointerType *ReceiverT = nullptr; bool CanBeSubClassed = false; QualType SupersType = E->getSuperType(); diff --git a/lib/StaticAnalyzer/Core/ExprEngine.cpp b/lib/StaticAnalyzer/Core/ExprEngine.cpp index 8b7f18fdf6ac..ef515fb5937b 100644 --- a/lib/StaticAnalyzer/Core/ExprEngine.cpp +++ b/lib/StaticAnalyzer/Core/ExprEngine.cpp @@ -816,6 +816,7 @@ void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred, case Stmt::OMPTaskyieldDirectiveClass: case Stmt::OMPBarrierDirectiveClass: case Stmt::OMPTaskwaitDirectiveClass: + case Stmt::OMPTaskgroupDirectiveClass: case Stmt::OMPFlushDirectiveClass: case Stmt::OMPOrderedDirectiveClass: case Stmt::OMPAtomicDirectiveClass: @@ -859,6 +860,7 @@ void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred, // Cases not handled yet; but will handle some day. case Stmt::DesignatedInitExprClass: + case Stmt::DesignatedInitUpdateExprClass: case Stmt::ExtVectorElementExprClass: case Stmt::ImaginaryLiteralClass: case Stmt::ObjCAtCatchStmtClass: @@ -891,6 +893,7 @@ void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred, case Stmt::CXXBoolLiteralExprClass: case Stmt::ObjCBoolLiteralExprClass: case Stmt::FloatingLiteralClass: + case Stmt::NoInitExprClass: case Stmt::SizeOfPackExprClass: case Stmt::StringLiteralClass: case Stmt::ObjCStringLiteralClass: diff --git a/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp b/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp index 3c1a3b4111d1..cfcf7c6a990b 100644 --- a/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp +++ b/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp @@ -22,6 +22,7 @@ #include "clang/Rewrite/Core/Rewriter.h" #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/CheckerManager.h" +#include "llvm/Support/Errc.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" @@ -306,7 +307,7 @@ void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D, FD, llvm::sys::fs::F_RW | llvm::sys::fs::F_Excl); - if (EC && EC != std::errc::file_exists) { + if (EC && EC != llvm::errc::file_exists) { llvm::errs() << "warning: could not create file '" << Model << "': " << EC.message() << '\n'; return; diff --git a/lib/StaticAnalyzer/Frontend/ModelInjector.cpp b/lib/StaticAnalyzer/Frontend/ModelInjector.cpp index 699549f81767..ee2c3f513cdf 100644 --- a/lib/StaticAnalyzer/Frontend/ModelInjector.cpp +++ b/lib/StaticAnalyzer/Frontend/ModelInjector.cpp @@ -76,7 +76,7 @@ void ModelInjector::onBodySynthesis(const NamedDecl *D) { // Modules are parsed by a separate CompilerInstance, so this code mimics that // behavior for models - CompilerInstance Instance; + CompilerInstance Instance(CI.getPCHContainerOperations()); Instance.setInvocation(&*Invocation); Instance.createDiagnostics( new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()), diff --git a/lib/Tooling/Core/Replacement.cpp b/lib/Tooling/Core/Replacement.cpp index 32e8e5bd6b97..6d37a49db381 100644 --- a/lib/Tooling/Core/Replacement.cpp +++ b/lib/Tooling/Core/Replacement.cpp @@ -88,8 +88,13 @@ std::string Replacement::toString() const { bool operator<(const Replacement &LHS, const Replacement &RHS) { if (LHS.getOffset() != RHS.getOffset()) return LHS.getOffset() < RHS.getOffset(); + + // Apply longer replacements first, specifically so that deletions are + // executed before insertions. It is (hopefully) never the intention to + // delete parts of newly inserted code. if (LHS.getLength() != RHS.getLength()) - return LHS.getLength() < RHS.getLength(); + return LHS.getLength() > RHS.getLength(); + if (LHS.getFilePath() != RHS.getFilePath()) return LHS.getFilePath() < RHS.getFilePath(); return LHS.getReplacementText() < RHS.getReplacementText(); diff --git a/lib/Tooling/Refactoring.cpp b/lib/Tooling/Refactoring.cpp index c8173060d8c1..d32452f6f293 100644 --- a/lib/Tooling/Refactoring.cpp +++ b/lib/Tooling/Refactoring.cpp @@ -25,9 +25,10 @@ namespace clang { namespace tooling { -RefactoringTool::RefactoringTool(const CompilationDatabase &Compilations, - ArrayRef<std::string> SourcePaths) - : ClangTool(Compilations, SourcePaths) {} +RefactoringTool::RefactoringTool( + const CompilationDatabase &Compilations, ArrayRef<std::string> SourcePaths, + std::shared_ptr<PCHContainerOperations> PCHContainerOps) + : ClangTool(Compilations, SourcePaths, PCHContainerOps) {} Replacements &RefactoringTool::getReplacements() { return Replace; } diff --git a/lib/Tooling/Tooling.cpp b/lib/Tooling/Tooling.cpp index e100003cee87..f9cb7c641344 100644 --- a/lib/Tooling/Tooling.cpp +++ b/lib/Tooling/Tooling.cpp @@ -105,9 +105,10 @@ clang::CompilerInvocation *newInvocation( } bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code, - const Twine &FileName) { - return runToolOnCodeWithArgs( - ToolAction, Code, std::vector<std::string>(), FileName); + const Twine &FileName, + std::shared_ptr<PCHContainerOperations> PCHContainerOps) { + return runToolOnCodeWithArgs(ToolAction, Code, std::vector<std::string>(), + FileName, PCHContainerOps); } static std::vector<std::string> @@ -121,17 +122,18 @@ getSyntaxOnlyToolArgs(const std::vector<std::string> &ExtraArgs, return Args; } -bool runToolOnCodeWithArgs(clang::FrontendAction *ToolAction, const Twine &Code, - const std::vector<std::string> &Args, - const Twine &FileName, - const FileContentMappings &VirtualMappedFiles) { +bool runToolOnCodeWithArgs( + clang::FrontendAction *ToolAction, const Twine &Code, + const std::vector<std::string> &Args, const Twine &FileName, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + const FileContentMappings &VirtualMappedFiles) { SmallString<16> FileNameStorage; StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage); llvm::IntrusiveRefCntPtr<FileManager> Files( new FileManager(FileSystemOptions())); ToolInvocation Invocation(getSyntaxOnlyToolArgs(Args, FileNameRef), - ToolAction, Files.get()); + ToolAction, Files.get(), PCHContainerOps); SmallString<1024> CodeStorage; Invocation.mapVirtualFile(FileNameRef, @@ -173,21 +175,18 @@ public: } -ToolInvocation::ToolInvocation(std::vector<std::string> CommandLine, - ToolAction *Action, FileManager *Files) - : CommandLine(std::move(CommandLine)), - Action(Action), - OwnsAction(false), - Files(Files), - DiagConsumer(nullptr) {} +ToolInvocation::ToolInvocation( + std::vector<std::string> CommandLine, ToolAction *Action, + FileManager *Files, std::shared_ptr<PCHContainerOperations> PCHContainerOps) + : CommandLine(std::move(CommandLine)), Action(Action), OwnsAction(false), + Files(Files), PCHContainerOps(PCHContainerOps), DiagConsumer(nullptr) {} -ToolInvocation::ToolInvocation(std::vector<std::string> CommandLine, - FrontendAction *FAction, FileManager *Files) +ToolInvocation::ToolInvocation( + std::vector<std::string> CommandLine, FrontendAction *FAction, + FileManager *Files, std::shared_ptr<PCHContainerOperations> PCHContainerOps) : CommandLine(std::move(CommandLine)), - Action(new SingleFrontendActionFactory(FAction)), - OwnsAction(true), - Files(Files), - DiagConsumer(nullptr) {} + Action(new SingleFrontendActionFactory(FAction)), OwnsAction(true), + Files(Files), PCHContainerOps(PCHContainerOps), DiagConsumer(nullptr) {} ToolInvocation::~ToolInvocation() { if (OwnsAction) @@ -232,13 +231,14 @@ bool ToolInvocation::run() { Invocation->getPreprocessorOpts().addRemappedFile(It.getKey(), Input.release()); } - return runInvocation(BinaryName, Compilation.get(), Invocation.release()); + return runInvocation(BinaryName, Compilation.get(), Invocation.release(), + PCHContainerOps); } bool ToolInvocation::runInvocation( - const char *BinaryName, - clang::driver::Compilation *Compilation, - clang::CompilerInvocation *Invocation) { + const char *BinaryName, clang::driver::Compilation *Compilation, + clang::CompilerInvocation *Invocation, + std::shared_ptr<PCHContainerOperations> PCHContainerOps) { // Show the invocation, with -v. if (Invocation->getHeaderSearchOpts().Verbose) { llvm::errs() << "clang Invocation:\n"; @@ -246,14 +246,16 @@ bool ToolInvocation::runInvocation( llvm::errs() << "\n"; } - return Action->runInvocation(Invocation, Files, DiagConsumer); + return Action->runInvocation(Invocation, Files, PCHContainerOps, + DiagConsumer); } -bool FrontendActionFactory::runInvocation(CompilerInvocation *Invocation, - FileManager *Files, - DiagnosticConsumer *DiagConsumer) { +bool FrontendActionFactory::runInvocation( + CompilerInvocation *Invocation, FileManager *Files, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, + DiagnosticConsumer *DiagConsumer) { // Create a compiler instance to handle the actual work. - clang::CompilerInstance Compiler; + clang::CompilerInstance Compiler(PCHContainerOps); Compiler.setInvocation(Invocation); Compiler.setFileManager(Files); @@ -276,8 +278,10 @@ bool FrontendActionFactory::runInvocation(CompilerInvocation *Invocation, } ClangTool::ClangTool(const CompilationDatabase &Compilations, - ArrayRef<std::string> SourcePaths) + ArrayRef<std::string> SourcePaths, + std::shared_ptr<PCHContainerOperations> PCHContainerOps) : Compilations(Compilations), SourcePaths(SourcePaths), + PCHContainerOps(PCHContainerOps), Files(new FileManager(FileSystemOptions())), DiagConsumer(nullptr) { appendArgumentsAdjuster(getClangStripOutputAdjuster()); appendArgumentsAdjuster(getClangSyntaxOnlyAdjuster()); @@ -357,7 +361,8 @@ int ClangTool::run(ToolAction *Action) { // FIXME: We need a callback mechanism for the tool writer to output a // customized message for each file. DEBUG({ llvm::dbgs() << "Processing: " << File << ".\n"; }); - ToolInvocation Invocation(std::move(CommandLine), Action, Files.get()); + ToolInvocation Invocation(std::move(CommandLine), Action, Files.get(), + PCHContainerOps); Invocation.setDiagnosticConsumer(DiagConsumer); for (const auto &MappedFile : MappedFileContents) Invocation.mapVirtualFile(MappedFile.first, MappedFile.second); @@ -385,12 +390,14 @@ public: ASTBuilderAction(std::vector<std::unique_ptr<ASTUnit>> &ASTs) : ASTs(ASTs) {} bool runInvocation(CompilerInvocation *Invocation, FileManager *Files, + std::shared_ptr<PCHContainerOperations> PCHContainerOps, DiagnosticConsumer *DiagConsumer) override { // FIXME: This should use the provided FileManager. std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation( - Invocation, CompilerInstance::createDiagnostics( - &Invocation->getDiagnosticOpts(), DiagConsumer, - /*ShouldOwnClient=*/false)); + Invocation, PCHContainerOps, + CompilerInstance::createDiagnostics(&Invocation->getDiagnosticOpts(), + DiagConsumer, + /*ShouldOwnClient=*/false)); if (!AST) return false; @@ -406,22 +413,24 @@ int ClangTool::buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs) { return run(&Action); } -std::unique_ptr<ASTUnit> buildASTFromCode(const Twine &Code, - const Twine &FileName) { - return buildASTFromCodeWithArgs(Code, std::vector<std::string>(), FileName); +std::unique_ptr<ASTUnit> +buildASTFromCode(const Twine &Code, const Twine &FileName, + std::shared_ptr<PCHContainerOperations> PCHContainerOps) { + return buildASTFromCodeWithArgs(Code, std::vector<std::string>(), FileName, + PCHContainerOps); } -std::unique_ptr<ASTUnit> -buildASTFromCodeWithArgs(const Twine &Code, - const std::vector<std::string> &Args, - const Twine &FileName) { +std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs( + const Twine &Code, const std::vector<std::string> &Args, + const Twine &FileName, + std::shared_ptr<PCHContainerOperations> PCHContainerOps) { SmallString<16> FileNameStorage; StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage); std::vector<std::unique_ptr<ASTUnit>> ASTs; ASTBuilderAction Action(ASTs); ToolInvocation Invocation(getSyntaxOnlyToolArgs(Args, FileNameRef), &Action, - nullptr); + nullptr, PCHContainerOps); SmallString<1024> CodeStorage; Invocation.mapVirtualFile(FileNameRef, diff --git a/test/ARCMT/migrate-on-pch-and-module.m b/test/ARCMT/migrate-on-pch-and-module.m index c98ce467f6c7..51babf6cf483 100644 --- a/test/ARCMT/migrate-on-pch-and-module.m +++ b/test/ARCMT/migrate-on-pch-and-module.m @@ -1,6 +1,6 @@ // RUN: rm -rf %t-mcp -// RUN: %clang_cc1 -objcmt-migrate-subscripting -emit-pch -o %t.pch %s -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -F %S/Inputs -fmodules -fmodules-cache-path=%t-mcp -w -// RUN: %clang_cc1 -objcmt-migrate-subscripting -include-pch %t.pch %s -migrate -o %t.remap -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -F %S/Inputs -fmodules -fmodules-cache-path=%t-mcp +// RUN: %clang_cc1 -objcmt-migrate-subscripting -emit-pch -o %t.pch %s -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -F %S/Inputs -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-mcp -w +// RUN: %clang_cc1 -objcmt-migrate-subscripting -include-pch %t.pch %s -migrate -o %t.remap -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -F %S/Inputs -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-mcp #ifndef HEADER #define HEADER diff --git a/test/Analysis/CFContainers.mm b/test/Analysis/CFContainers.mm index b01942310f7b..f315bc9f045c 100644 --- a/test/Analysis/CFContainers.mm +++ b/test/Analysis/CFContainers.mm @@ -19,6 +19,7 @@ typedef struct { } CFArrayCallBacks; typedef const struct __CFArray * CFArrayRef; CFArrayRef CFArrayCreate(CFAllocatorRef allocator, const void **values, CFIndex numValues, const CFArrayCallBacks *callBacks); +typedef struct __CFArray * CFMutableArrayRef; typedef const struct __CFString * CFStringRef; enum { kCFNumberSInt8Type = 1, @@ -202,3 +203,24 @@ void TestConst(CFArrayRef A, CFIndex sIndex, void* x[]) { void TestNullArray() { CFArrayGetValueAtIndex(0, 0); } + +void ArrayRefMutableEscape(CFMutableArrayRef a); +void ArrayRefEscape(CFArrayRef a); + +void TestCFMutableArrayRefEscapeViaMutableArgument(CFMutableArrayRef a) { + CFIndex aLen = CFArrayGetCount(a); + ArrayRefMutableEscape(a); + + // ArrayRefMutableEscape could mutate a to make it have + // at least aLen + 1 elements, so do not report an error here. + CFArrayGetValueAtIndex(a, aLen); +} + +void TestCFMutableArrayRefEscapeViaImmutableArgument(CFMutableArrayRef a) { + CFIndex aLen = CFArrayGetCount(a); + ArrayRefEscape(a); + + // ArrayRefEscape is declared to take a CFArrayRef (i.e, an immutable array) + // so we assume it does not change the length of a. + CFArrayGetValueAtIndex(a, aLen); // expected-warning {{Index is out of bounds}} +} diff --git a/test/Analysis/designated-initializer.c b/test/Analysis/designated-initializer.c new file mode 100644 index 000000000000..b601f872571f --- /dev/null +++ b/test/Analysis/designated-initializer.c @@ -0,0 +1,41 @@ +// RUN: %clang_cc1 -analyze -analyzer-checker=debug.DumpCFG %s 2>&1 \ +// RUN: | FileCheck %s + +struct Q { int a, b, c; }; +union UQ { struct Q q; }; +union UQ getUQ() { + union UQ u = { { 1, 2, 3 } }; + return u; +} + +void test() { + struct LUQ { union UQ uq; } var = { getUQ(), .uq.q.a = 100 }; + struct Q s[] = { + [0] = (struct Q){1, 2}, + [0].c = 3 + }; +} + +// CHECK: void test() +// CHECK: [B1] +// CHECK: 1: getUQ +// CHECK: 2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, union UQ (*)()) +// CHECK: 3: [B1.2]() +// CHECK: 4: 100 +// CHECK: 5: /*no init*/ +// CHECK: 6: /*no init*/ +// CHECK: 7: {[B1.4], [B1.5], [B1.6]} +// CHECK: 8: {[B1.7]} +// CHECK: 9: {/*base*/[B1.3], /*updater*/[B1.8]} +// CHECK: 10: {[B1.3], .uq.q.a = [B1.4]} +// CHECK: 11: struct LUQ var = {getUQ(), .uq.q.a = 100}; +// CHECK: 12: 1 +// CHECK: 13: 2 +// CHECK: 14: /*implicit*/(int)0 +// CHECK: 15: {[B1.12], [B1.13]} +// CHECK: 18: /*no init*/ +// CHECK: 19: /*no init*/ +// CHECK: 20: 3 +// CHECK: 21: {[B1.18], [B1.19], [B1.20]} +// CHECK: 22: {/*base*/[B1.17], /*updater*/[B1.21]} +// CHECK: 24: struct Q s[] = {[0] = (struct Q){1, 2}, [0].c = 3}; diff --git a/test/Analysis/retain-release.m b/test/Analysis/retain-release.m index 6973f9bcd67d..1dbcda507c17 100644 --- a/test/Analysis/retain-release.m +++ b/test/Analysis/retain-release.m @@ -2153,6 +2153,40 @@ id returnNSNull() { return [NSNull null]; // no-warning } +//===----------------------------------------------------------------------===// +// cf_returns_[not_]retained on parameters +//===----------------------------------------------------------------------===// + +void testCFReturnsNotRetained() { + extern void getViaParam(CFTypeRef * CF_RETURNS_NOT_RETAINED outObj); + CFTypeRef obj; + getViaParam(&obj); + CFRelease(obj); // // expected-warning {{Incorrect decrement of the reference count of an object that is not owned at this point by the caller}} +} + +void testCFReturnsNotRetainedAnnotated() { + extern void getViaParam2(CFTypeRef * __nonnull CF_RETURNS_NOT_RETAINED outObj); + CFTypeRef obj; + getViaParam2(&obj); + CFRelease(obj); // // expected-warning {{Incorrect decrement of the reference count of an object that is not owned at this point by the caller}} +} + +void testCFReturnsRetained() { + extern int copyViaParam(CFTypeRef * CF_RETURNS_RETAINED outObj); + CFTypeRef obj; + copyViaParam(&obj); + CFRelease(obj); + CFRelease(obj); // // FIXME-warning {{Incorrect decrement of the reference count of an object that is not owned at this point by the caller}} +} + +void testCFReturnsRetainedError() { + extern int copyViaParam(CFTypeRef * CF_RETURNS_RETAINED outObj); + CFTypeRef obj; + if (copyViaParam(&obj) == -42) + return; // no-warning + CFRelease(obj); +} + // CHECK: <key>diagnostics</key> // CHECK-NEXT: <array> // CHECK-NEXT: <dict> diff --git a/test/CXX/except/except.spec/p9-dynamic.cpp b/test/CXX/except/except.spec/p9-dynamic.cpp index 4559e0d467b1..1e7b29479fbd 100644 --- a/test/CXX/except/except.spec/p9-dynamic.cpp +++ b/test/CXX/except/except.spec/p9-dynamic.cpp @@ -7,6 +7,6 @@ void target() throw(int) // CHECK: invoke void @_Z8externalv() external(); } -// CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) +// CHECK: landingpad { i8*, i32 } // CHECK-NEXT: filter [1 x i8*] [i8* bitcast (i8** @_ZTIi to i8*)] // CHECK: call void @__cxa_call_unexpected diff --git a/test/CXX/except/except.spec/p9-noexcept.cpp b/test/CXX/except/except.spec/p9-noexcept.cpp index 3fd45c55dadc..d8cda2f62285 100644 --- a/test/CXX/except/except.spec/p9-noexcept.cpp +++ b/test/CXX/except/except.spec/p9-noexcept.cpp @@ -7,7 +7,7 @@ void target() noexcept // CHECK: invoke void @_Z8externalv() external(); } -// CHECK: [[T0:%.*]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) +// CHECK: [[T0:%.*]] = landingpad { i8*, i32 } // CHECK-NEXT: catch i8* null // CHECK-NEXT: [[T1:%.*]] = extractvalue { i8*, i32 } [[T0]], 0 // CHECK-NEXT: call void @__clang_call_terminate(i8* [[T1]]) [[NR_NUW:#[0-9]+]] diff --git a/test/CodeGen/2004-06-17-UnorderedCompares.c b/test/CodeGen/2004-06-17-UnorderedCompares.c index 2c80180d2c86..38eafd0d5455 100644 --- a/test/CodeGen/2004-06-17-UnorderedCompares.c +++ b/test/CodeGen/2004-06-17-UnorderedCompares.c @@ -1,6 +1,6 @@ // RUN: %clang_cc1 -std=c99 %s -emit-llvm -o - | FileCheck %s // CHECK: @Test -// CHECK-NOT: call +// CHECK-NOT: call{{ }} _Bool A, B, C, D, E, F; void TestF(float X, float Y) { diff --git a/test/CodeGen/address-safety-attr-kasan.cpp b/test/CodeGen/address-safety-attr-kasan.cpp new file mode 100644 index 000000000000..c84ba88291da --- /dev/null +++ b/test/CodeGen/address-safety-attr-kasan.cpp @@ -0,0 +1,38 @@ +// Make sure the sanitize_address attribute is emitted when using both ASan and KASan. +// Also document that __attribute__((no_sanitize_address)) doesn't disable KASan instrumentation. + +/// RUN: %clang_cc1 -triple i386-unknown-linux -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-NOASAN %s +/// RUN: %clang_cc1 -triple i386-unknown-linux -fsanitize=address -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-ASAN %s +/// RUN: %clang_cc1 -triple i386-unknown-linux -fsanitize=kernel-address -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-KASAN %s + +int HasSanitizeAddress() { + return 1; +} +// CHECK-NOASAN: {{Function Attrs: nounwind$}} +// CHECK-ASAN: Function Attrs: nounwind sanitize_address +// CHECK-KASAN: Function Attrs: nounwind sanitize_address + +__attribute__((no_sanitize("address"))) +int NoSanitizeQuoteAddress() { + return 0; +} +// CHECK-NOASAN: {{Function Attrs: nounwind$}} +// CHECK-ASAN: {{Function Attrs: nounwind$}} +// CHECK-KASAN: {{Function Attrs: nounwind sanitize_address$}} + +__attribute__((no_sanitize_address)) +int NoSanitizeAddress() { + return 0; +} +// CHECK-NOASAN: {{Function Attrs: nounwind$}} +// CHECK-ASAN: {{Function Attrs: nounwind$}} +// CHECK-KASAN: {{Function Attrs: nounwind sanitize_address$}} + +__attribute__((no_sanitize("kernel-address"))) +int NoSanitizeKernelAddress() { + return 0; +} + +// CHECK-NOASAN: {{Function Attrs: nounwind$}} +// CHECK-ASAN: {{Function Attrs: nounwind sanitize_address$}} +// CHECK-KASAN: {{Function Attrs: nounwind$}} diff --git a/test/CodeGen/arm-interrupt-attr.c b/test/CodeGen/arm-interrupt-attr.c index 73f1cfee0502..fcbf1c721bd1 100644 --- a/test/CodeGen/arm-interrupt-attr.c +++ b/test/CodeGen/arm-interrupt-attr.c @@ -28,11 +28,11 @@ __attribute__((interrupt("UNDEF"))) void test_undef_interrupt() { // CHECK: define arm_aapcscc void @test_undef_interrupt() [[UNDEF_ATTR:#[0-9]+]] } -// CHECK: attributes [[GENERIC_ATTR]] = { nounwind alignstack=8 {{"interrupt"[^=]}} -// CHECK: attributes [[IRQ_ATTR]] = { nounwind alignstack=8 "interrupt"="IRQ" -// CHECK: attributes [[FIQ_ATTR]] = { nounwind alignstack=8 "interrupt"="FIQ" -// CHECK: attributes [[SWI_ATTR]] = { nounwind alignstack=8 "interrupt"="SWI" -// CHECK: attributes [[ABORT_ATTR]] = { nounwind alignstack=8 "interrupt"="ABORT" -// CHECK: attributes [[UNDEF_ATTR]] = { nounwind alignstack=8 "interrupt"="UNDEF" - -// CHECK-APCS: attributes [[GENERIC_ATTR]] = { nounwind "interrupt" +// CHECK: attributes [[GENERIC_ATTR]] = { {{.*}} {{"interrupt"[^=]}} +// CHECK: attributes [[IRQ_ATTR]] = { {{.*}} "interrupt"="IRQ" +// CHECK: attributes [[FIQ_ATTR]] = { {{.*}} "interrupt"="FIQ" +// CHECK: attributes [[SWI_ATTR]] = { {{.*}} "interrupt"="SWI" +// CHECK: attributes [[ABORT_ATTR]] = { {{.*}} "interrupt"="ABORT" +// CHECK: attributes [[UNDEF_ATTR]] = { {{.*}} "interrupt"="UNDEF" + +// CHECK-APCS: attributes [[GENERIC_ATTR]] = { {{.*}} "interrupt" diff --git a/test/CodeGen/arm_acle.c b/test/CodeGen/arm_acle.c index 5b024506a50e..a2eb900761b3 100644 --- a/test/CodeGen/arm_acle.c +++ b/test/CodeGen/arm_acle.c @@ -336,3 +336,69 @@ uint32_t test_crc32cw(uint32_t a, uint32_t b) { uint32_t test_crc32cd(uint32_t a, uint64_t b) { return __crc32cd(a, b); } + +/* 10.1 Special register intrinsics */ +// ARM-LABEL: test_rsr +// AArch64: call i64 @llvm.read_register.i64(metadata ![[M0:[0-9]]]) +// AArch32: call i32 @llvm.read_register.i32(metadata ![[M2:[0-9]]]) +uint32_t test_rsr() { +#ifdef __ARM_32BIT_STATE + return __arm_rsr("cp1:2:c3:c4:5"); +#else + return __arm_rsr("1:2:3:4:5"); +#endif +} + +// ARM-LABEL: test_rsr64 +// AArch64: call i64 @llvm.read_register.i64(metadata ![[M0:[0-9]]]) +// AArch32: call i64 @llvm.read_register.i64(metadata ![[M3:[0-9]]]) +uint64_t test_rsr64() { +#ifdef __ARM_32BIT_STATE + return __arm_rsr64("cp1:2:c3"); +#else + return __arm_rsr64("1:2:3:4:5"); +#endif +} + +// ARM-LABEL: test_rsrp +// AArch64: call i64 @llvm.read_register.i64(metadata ![[M1:[0-9]]]) +// AArch32: call i32 @llvm.read_register.i32(metadata ![[M4:[0-9]]]) +void *test_rsrp() { + return __arm_rsrp("sysreg"); +} + +// ARM-LABEL: test_wsr +// AArch64: call void @llvm.write_register.i64(metadata ![[M0:[0-9]]], i64 %{{.*}}) +// AArch32: call void @llvm.write_register.i32(metadata ![[M2:[0-9]]], i32 %{{.*}}) +void test_wsr(uint32_t v) { +#ifdef __ARM_32BIT_STATE + __arm_wsr("cp1:2:c3:c4:5", v); +#else + __arm_wsr("1:2:3:4:5", v); +#endif +} + +// ARM-LABEL: test_wsr64 +// AArch64: call void @llvm.write_register.i64(metadata ![[M0:[0-9]]], i64 %{{.*}}) +// AArch32: call void @llvm.write_register.i64(metadata ![[M3:[0-9]]], i64 %{{.*}}) +void test_wsr64(uint64_t v) { +#ifdef __ARM_32BIT_STATE + __arm_wsr64("cp1:2:c3", v); +#else + __arm_wsr64("1:2:3:4:5", v); +#endif +} + +// ARM-LABEL: test_wsrp +// AArch64: call void @llvm.write_register.i64(metadata ![[M1:[0-9]]], i64 %{{.*}}) +// AArch32: call void @llvm.write_register.i32(metadata ![[M4:[0-9]]], i32 %{{.*}}) +void test_wsrp(void *v) { + __arm_wsrp("sysreg", v); +} + +// AArch32: ![[M2]] = !{!"cp1:2:c3:c4:5"} +// AArch32: ![[M3]] = !{!"cp1:2:c3"} +// AArch32: ![[M4]] = !{!"sysreg"} + +// AArch64: ![[M0]] = !{!"1:2:3:4:5"} +// AArch64: ![[M1]] = !{!"sysreg"} diff --git a/test/CodeGen/arm_neon_intrinsics.c b/test/CodeGen/arm_neon_intrinsics.c index 756e3b43fc54..d92c32c476ae 100644 --- a/test/CodeGen/arm_neon_intrinsics.c +++ b/test/CodeGen/arm_neon_intrinsics.c @@ -2399,6 +2399,12 @@ float32_t test_vget_lane_f32(float32x2_t a) { return vget_lane_f32(a, 1); } +// CHECK-LABEL: test_vget_lane_f16 +// CHECK: vmov +float32_t test_vget_lane_f16(float16x4_t a) { + return vget_lane_f16(a, 1); +} + // CHECK-LABEL: test_vgetq_lane_u8 // CHECK: vmov uint8_t test_vgetq_lane_u8(uint8x16_t a) { @@ -2453,6 +2459,12 @@ float32_t test_vgetq_lane_f32(float32x4_t a) { return vgetq_lane_f32(a, 3); } +// CHECK-LABEL: test_vgetq_lane_f16 +// CHECK: vmov +float32_t test_vgetq_lane_f16(float16x8_t a) { + return vgetq_lane_f16(a, 3); +} + // CHECK-LABEL: test_vget_lane_s64 // The optimizer is able to remove all moves now. int64_t test_vget_lane_s64(int64x1_t a) { @@ -9157,6 +9169,12 @@ float32x2_t test_vset_lane_f32(float32_t a, float32x2_t b) { return vset_lane_f32(a, b, 1); } +// CHECK-LABEL: test_vset_lane_f16 +// CHECK: mov +float16x4_t test_vset_lane_f16(float16_t *a, float16x4_t b) { + return vset_lane_f16(*a, b, 1); +} + // CHECK-LABEL: test_vsetq_lane_u8 // CHECK: vmov uint8x16_t test_vsetq_lane_u8(uint8_t a, uint8x16_t b) { @@ -9211,6 +9229,12 @@ float32x4_t test_vsetq_lane_f32(float32_t a, float32x4_t b) { return vsetq_lane_f32(a, b, 3); } +// CHECK-LABEL: test_vsetq_lane_f16 +// CHECK: vmov +float16x8_t test_vsetq_lane_f16(float16_t *a, float16x8_t b) { + return vsetq_lane_f16(*a, b, 3); +} + // CHECK-LABEL: test_vset_lane_s64 // The optimizer is able to get rid of all moves now. int64x1_t test_vset_lane_s64(int64_t a, int64x1_t b) { diff --git a/test/CodeGen/attr-disable-tail-calls.c b/test/CodeGen/attr-disable-tail-calls.c new file mode 100644 index 000000000000..81413492ff3f --- /dev/null +++ b/test/CodeGen/attr-disable-tail-calls.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -triple x86_64-apple-macosx10.7.0 %s -emit-llvm -mdisable-tail-calls -o - | FileCheck %s -check-prefix=CHECK -check-prefix=DISABLE +// RUN: %clang_cc1 -triple x86_64-apple-macosx10.7.0 %s -emit-llvm -o - | FileCheck %s -check-prefix=CHECK -check-prefix=ENABLE + +// CHECK: define i32 @f1() [[ATTR:#[0-9]+]] { + +int f1() { + return 0; +} + +// DISABLE: attributes [[ATTR]] = { {{.*}} "disable-tail-calls"="true" {{.*}} } +// ENABLE: attributes [[ATTR]] = { {{.*}} "disable-tail-calls"="false" {{.*}} } diff --git a/test/CodeGen/attr-mode-vector-types.c b/test/CodeGen/attr-mode-vector-types.c new file mode 100644 index 000000000000..3c028fbd2882 --- /dev/null +++ b/test/CodeGen/attr-mode-vector-types.c @@ -0,0 +1,41 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -emit-llvm -o - | FileCheck %s + +typedef int __attribute__((mode(byte))) __attribute__((vector_size(4))) vec_t1; +typedef int __attribute__((mode(QI))) __attribute__((vector_size(8))) vec_t2; +typedef int __attribute__((mode(SI))) __attribute__((vector_size(16))) vec_t3; +typedef int __attribute__((mode(DI))) __attribute__((vector_size(64)))vec_t4; +typedef float __attribute__((mode(SF))) __attribute__((vector_size(128))) vec_t5; +typedef float __attribute__((mode(DF))) __attribute__((vector_size(256))) vec_t6; + +void check() { + // CHECK: alloca <4 x i8> + vec_t1 v1; + // CHECK: alloca <8 x i8> + vec_t2 v2; + // CHECK: alloca <4 x i32> + vec_t3 v3; + // CHECK: alloca <8 x i64> + vec_t4 v4; + // CHECK: alloca <32 x float> + vec_t5 v5; + // CHECK: alloca <32 x double> + vec_t6 v6; +} + +// CHECK: ret i32 4 +int check_size1() { return sizeof(vec_t1); } + +// CHECK: ret i32 8 +int check_size2() { return sizeof(vec_t2); } + +// CHECK: ret i32 16 +int check_size3() { return sizeof(vec_t3); } + +// CHECK: ret i32 64 +int check_size4() { return sizeof(vec_t4); } + +// CHECK: ret i32 128 +int check_size5() { return sizeof(vec_t5); } + +// CHECK: ret i32 256 +int check_size6() { return sizeof(vec_t6); } diff --git a/test/CodeGen/attr-target.c b/test/CodeGen/attr-target.c new file mode 100644 index 000000000000..8c0f335f857d --- /dev/null +++ b/test/CodeGen/attr-target.c @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -triple x86_64-linux-gnu -target-cpu x86-64 -emit-llvm %s -o - | FileCheck %s + +int baz(int a) { return 4; } + +int __attribute__((target("avx,sse4.2,arch=ivybridge"))) foo(int a) { return 4; } + +int __attribute__((target("tune=sandybridge"))) walrus(int a) { return 4; } +int __attribute__((target("fpmath=387"))) koala(int a) { return 4; } + +int __attribute__((target("mno-sse2"))) echidna(int a) { return 4; } + +int bar(int a) { return baz(a) + foo(a); } + +// Check that we emit the additional subtarget and cpu features for foo and not for baz or bar. +// CHECK: baz{{.*}} #0 +// CHECK: foo{{.*}} #1 +// We ignore the tune attribute so walrus should be identical to baz and bar. +// CHECK: walrus{{.*}} #0 +// We're currently ignoring the fpmath attribute so koala should be identical to baz and bar. +// CHECK: koala{{.*}} #0 +// CHECK: echidna{{.*}} #2 +// CHECK: bar{{.*}} #0 +// CHECK: #0 = {{.*}}"target-cpu"="x86-64" "target-features"="+sse,+sse2" +// CHECK: #1 = {{.*}}"target-cpu"="ivybridge" "target-features"="+sse,+sse2,+avx,+sse4.2" +// CHECK: #2 = {{.*}}"target-cpu"="x86-64" "target-features"="+sse,+sse2,-sse2" diff --git a/test/CodeGen/bounds-checking.c b/test/CodeGen/bounds-checking.c index d93cd3ede7d6..90b7f0f6523e 100644 --- a/test/CodeGen/bounds-checking.c +++ b/test/CodeGen/bounds-checking.c @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -fsanitize=local-bounds -emit-llvm -triple x86_64-apple-darwin10 %s -o - | FileCheck %s -// RUN: %clang_cc1 -fsanitize=array-bounds -O -fsanitize-undefined-trap-on-error -emit-llvm -triple x86_64-apple-darwin10 -DNO_DYNAMIC %s -o - | FileCheck %s +// RUN: %clang_cc1 -fsanitize=array-bounds -O -fsanitize-trap=array-bounds -emit-llvm -triple x86_64-apple-darwin10 -DNO_DYNAMIC %s -o - | FileCheck %s // CHECK-LABEL: @f double f(int b, int i) { diff --git a/test/CodeGen/builtins-arm.c b/test/CodeGen/builtins-arm.c index 9f3ed9ac78a1..2b81856e6b48 100644 --- a/test/CodeGen/builtins-arm.c +++ b/test/CodeGen/builtins-arm.c @@ -84,3 +84,42 @@ void prefetch(int i) { __builtin_arm_prefetch(&i, 1, 0); // CHECK: call {{.*}} @llvm.prefetch(i8* %{{.*}}, i32 1, i32 3, i32 0) } + +unsigned rsr() { + // CHECK: [[V0:[%A-Za-z0-9.]+]] = {{.*}} call i32 @llvm.read_register.i32(metadata !7) + // CHECK-NEXT: ret i32 [[V0]] + return __builtin_arm_rsr("cp1:2:c3:c4:5"); +} + +unsigned long long rsr64() { + // CHECK: [[V0:[%A-Za-z0-9.]+]] = {{.*}} call i64 @llvm.read_register.i64(metadata !8) + // CHECK-NEXT: ret i64 [[V0]] + return __builtin_arm_rsr64("cp1:2:c3"); +} + +void *rsrp() { + // CHECK: [[V0:[%A-Za-z0-9.]+]] = {{.*}} call i32 @llvm.read_register.i32(metadata !9) + // CHECK-NEXT: [[V1:[%A-Za-z0-9.]+]] = inttoptr i32 [[V0]] to i8* + // CHECK-NEXT: ret i8* [[V1]] + return __builtin_arm_rsrp("sysreg"); +} + +void wsr(unsigned v) { + // CHECK: call void @llvm.write_register.i32(metadata !7, i32 %v) + __builtin_arm_wsr("cp1:2:c3:c4:5", v); +} + +void wsr64(unsigned long long v) { + // CHECK: call void @llvm.write_register.i64(metadata !8, i64 %v) + __builtin_arm_wsr64("cp1:2:c3", v); +} + +void wsrp(void *v) { + // CHECK: [[V0:[%A-Za-z0-9.]+]] = ptrtoint i8* %v to i32 + // CHECK-NEXT: call void @llvm.write_register.i32(metadata !9, i32 [[V0]]) + __builtin_arm_wsrp("sysreg", v); +} + +// CHECK: !7 = !{!"cp1:2:c3:c4:5"} +// CHECK: !8 = !{!"cp1:2:c3"} +// CHECK: !9 = !{!"sysreg"} diff --git a/test/CodeGen/builtins-arm64.c b/test/CodeGen/builtins-arm64.c index cc1f54732b30..f2c1c5454548 100644 --- a/test/CodeGen/builtins-arm64.c +++ b/test/CodeGen/builtins-arm64.c @@ -43,3 +43,39 @@ void prefetch() { __builtin_arm_prefetch(0, 0, 0, 0, 0); // plil1keep // CHECK: call {{.*}} @llvm.prefetch(i8* null, i32 0, i32 3, i32 0) } + +unsigned rsr() { + // CHECK: [[V0:[%A-Za-z0-9.]+]] = {{.*}} call i64 @llvm.read_register.i64(metadata ![[M0:[0-9]]]) + // CHECK-NEXT: trunc i64 [[V0]] to i32 + return __builtin_arm_rsr("1:2:3:4:5"); +} + +unsigned long rsr64() { + // CHECK: call i64 @llvm.read_register.i64(metadata ![[M0:[0-9]]]) + return __builtin_arm_rsr64("1:2:3:4:5"); +} + +void *rsrp() { + // CHECK: [[V0:[%A-Za-z0-9.]+]] = {{.*}} call i64 @llvm.read_register.i64(metadata ![[M0:[0-9]]]) + // CHECK-NEXT: inttoptr i64 [[V0]] to i8* + return __builtin_arm_rsrp("1:2:3:4:5"); +} + +void wsr(unsigned v) { + // CHECK: [[V0:[%A-Za-z0-9.]+]] = zext i32 %v to i64 + // CHECK-NEXT: call void @llvm.write_register.i64(metadata ![[M0:[0-9]]], i64 [[V0]]) + __builtin_arm_wsr("1:2:3:4:5", v); +} + +void wsr64(unsigned long v) { + // CHECK: call void @llvm.write_register.i64(metadata ![[M0:[0-9]]], i64 %v) + __builtin_arm_wsr64("1:2:3:4:5", v); +} + +void wsrp(void *v) { + // CHECK: [[V0:[%A-Za-z0-9.]+]] = ptrtoint i8* %v to i64 + // CHECK-NEXT: call void @llvm.write_register.i64(metadata ![[M0:[0-9]]], i64 [[V0]]) + __builtin_arm_wsrp("1:2:3:4:5", v); +} + +// CHECK: ![[M0]] = !{!"1:2:3:4:5"} diff --git a/test/CodeGen/builtins-ppc-p8vector.c b/test/CodeGen/builtins-ppc-p8vector.c index f74bbad9daf0..ac4079016aee 100644 --- a/test/CodeGen/builtins-ppc-p8vector.c +++ b/test/CodeGen/builtins-ppc-p8vector.c @@ -3,6 +3,8 @@ // RUN: %clang_cc1 -faltivec -target-feature +power8-vector -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-LE // RUN: not %clang_cc1 -faltivec -triple powerpc64-unknown-unknown -emit-llvm %s -o - 2>&1 | FileCheck %s -check-prefix=CHECK-PPC +vector signed char vsc = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5 }; +vector unsigned char vuc = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5 }; vector int vi = { -1, 2, -3, 4 }; vector unsigned int vui = { 1, 2, 3, 4 }; vector bool int vbi = {0, -1, -1, 0}; @@ -11,6 +13,8 @@ vector signed long long vsll = { 1, 2 }; vector unsigned long long vull = { 1, 2 }; int res_i; +vector signed char res_vsc; +vector unsigned char res_vuc; vector int res_vi; vector unsigned int res_vui; vector bool int res_vbi; @@ -737,4 +741,23 @@ void test1() { // CHECK: @llvm.ppc.altivec.vminud // CHECK-LE: @llvm.ppc.altivec.vminud + /* vec_vbpermq */ + res_vsll = vec_vbpermq(vsc, vsc); +// CHECK: llvm.ppc.altivec.vbpermq +// CHECK-LE: llvm.ppc.altivec.vbpermq + + res_vull = vec_vbpermq(vuc, vuc); +// CHECK: llvm.ppc.altivec.vbpermq +// CHECK-LE: llvm.ppc.altivec.vbpermq +// CHECK-PPC: warning: implicit declaration of function 'vec_vbpermq' + + /* vec_vgbbd */ + res_vsc = vec_vgbbd(vsc); +// CHECK: llvm.ppc.altivec.vgbbd +// CHECK-LE: llvm.ppc.altivec.vgbbd + + res_vuc = vec_vgbbd(vuc); +// CHECK: llvm.ppc.altivec.vgbbd +// CHECK-LE: llvm.ppc.altivec.vgbbd +// CHECK-PPC: warning: implicit declaration of function 'vec_vgbbd' } diff --git a/test/CodeGen/catch-undef-behavior.c b/test/CodeGen/catch-undef-behavior.c index 66954190aff7..78755360e103 100644 --- a/test/CodeGen/catch-undef-behavior.c +++ b/test/CodeGen/catch-undef-behavior.c @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -fsanitize=alignment,null,object-size,shift-base,shift-exponent,return,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool,returns-nonnull-attribute,nonnull-attribute -fsanitize-recover=alignment,null,object-size,shift-base,shift-exponent,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool,returns-nonnull-attribute,nonnull-attribute -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-COMMON --check-prefix=CHECK-UBSAN -// RUN: %clang_cc1 -fsanitize-undefined-trap-on-error -fsanitize=alignment,null,object-size,shift-base,shift-exponent,return,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool,returns-nonnull-attribute,nonnull-attribute -fsanitize-recover=alignment,null,object-size,shift-base,shift-exponent,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool,returns-nonnull-attribute,nonnull-attribute -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-COMMON --check-prefix=CHECK-TRAP +// RUN: %clang_cc1 -fsanitize-trap=alignment,null,object-size,shift-base,shift-exponent,return,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool,returns-nonnull-attribute,nonnull-attribute -fsanitize-recover=alignment,null,object-size,shift-base,shift-exponent,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool,returns-nonnull-attribute,nonnull-attribute -fsanitize=alignment,null,object-size,shift-base,shift-exponent,return,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool,returns-nonnull-attribute,nonnull-attribute -fsanitize-recover=alignment,null,object-size,shift-base,shift-exponent,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool,returns-nonnull-attribute,nonnull-attribute -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-COMMON --check-prefix=CHECK-TRAP // RUN: %clang_cc1 -fsanitize=null -fsanitize-recover=null -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-NULL // RUN: %clang_cc1 -fsanitize=signed-integer-overflow -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-OVERFLOW // REQUIRES: asserts diff --git a/test/CodeGen/cleanup-destslot-simple.c b/test/CodeGen/cleanup-destslot-simple.c index bae97c81cbba..b8328af83d2a 100644 --- a/test/CodeGen/cleanup-destslot-simple.c +++ b/test/CodeGen/cleanup-destslot-simple.c @@ -13,7 +13,9 @@ int test() { return *p; // CHECK: [[X:%.*]] = alloca i32 // CHECK: [[P:%.*]] = alloca i32* -// LIFETIME: call void @llvm.lifetime.start(i64 4, i8* %{{.*}}) -// LIFETIME: call void @llvm.lifetime.start(i64 8, i8* %{{.*}}) +// LIFETIME: call void @llvm.lifetime.start(i64 4, i8* %{{.*}}){{( #[0-9]+)?}}, !dbg +// LIFETIME: call void @llvm.lifetime.start(i64 8, i8* %{{.*}}){{( #[0-9]+)?}}, !dbg // CHECK-NOT: store i32 %{{.*}}, i32* %cleanup.dest.slot +// LIFETIME: call void @llvm.lifetime.end(i64 8, {{.*}}){{( #[0-9]+)?}}, !dbg +// LIFETIME: call void @llvm.lifetime.end(i64 4, {{.*}}){{( #[0-9]+)?}}, !dbg } diff --git a/test/CodeGen/exceptions-seh.c b/test/CodeGen/exceptions-seh.c index d8135e805c6b..1b77ad616278 100644 --- a/test/CodeGen/exceptions-seh.c +++ b/test/CodeGen/exceptions-seh.c @@ -19,12 +19,12 @@ int safe_div(int numerator, int denominator, int *res) { *res = myres; return success; } -// CHECK-LABEL: define i32 @safe_div(i32 %numerator, i32 %denominator, i32* %res) +// CHECK-LABEL: define i32 @safe_div(i32 %numerator, i32 %denominator, i32* %res) {{.*}} personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) // CHECK: invoke void @try_body(i32 %{{.*}}, i32 %{{.*}}, i32* %{{.*}}) #[[NOINLINE:[0-9]+]] // CHECK: to label %{{.*}} unwind label %[[lpad:[^ ]*]] // // CHECK: [[lpad]] -// CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) +// CHECK: landingpad { i8*, i32 } // CHECK-NEXT: catch i8* null // CHECK-NOT: br i1 // CHECK: br label %[[except:[^ ]*]] @@ -46,7 +46,7 @@ int filter_expr_capture(void) { return r; } -// CHECK-LABEL: define i32 @filter_expr_capture() +// CHECK-LABEL: define i32 @filter_expr_capture() {{.*}} personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) // CHECK: call void (...) @llvm.frameescape(i32* %[[r:[^ ,]*]]) // CHECK: store i32 42, i32* %[[r]] // CHECK: invoke void @j() #[[NOINLINE]] @@ -77,7 +77,7 @@ int nested_try(void) { } return r; } -// CHECK-LABEL: define i32 @nested_try() +// CHECK-LABEL: define i32 @nested_try() {{.*}} personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) // CHECK: store i32 42, i32* %[[r:[^ ,]*]] // CHECK: invoke void @j() #[[NOINLINE]] // CHECK: to label %[[cont:[^ ]*]] unwind label %[[lpad:[^ ]*]] @@ -87,7 +87,7 @@ int nested_try(void) { // CHECK: br label %[[inner_try_cont:[^ ]*]] // // CHECK: [[lpad]] -// CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) +// CHECK: landingpad { i8*, i32 } // CHECK: catch i8* bitcast (i32 (i8*, i8*)* @"\01?filt$1@0@nested_try@@" to i8*) // CHECK: catch i8* bitcast (i32 (i8*, i8*)* @"\01?filt$0@0@nested_try@@" to i8*) // CHECK: store i8* %{{.*}}, i8** %[[ehptr_slot:[^ ]*]] @@ -125,7 +125,7 @@ void basic_finally(void) { --g; } } -// CHECK-LABEL: define void @basic_finally() +// CHECK-LABEL: define void @basic_finally() {{.*}} personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) // CHECK: load i32, i32* @g // CHECK: add i32 %{{.*}}, 1 // CHECK: store i32 %{{.*}}, i32* @g @@ -139,7 +139,7 @@ void basic_finally(void) { // CHECK: ret void // // CHECK: [[lpad]] -// CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) +// CHECK: landingpad { i8*, i32 } // CHECK-NEXT: cleanup // CHECK: %[[fp:[^ ]*]] = call i8* @llvm.frameaddress(i32 0) // CHECK: call void @"\01?fin$0@0@basic_finally@@"(i8 1, i8* %[[fp]]) diff --git a/test/CodeGen/exceptions.c b/test/CodeGen/exceptions.c index ae0af4dd9d84..039ec84d2e53 100644 --- a/test/CodeGen/exceptions.c +++ b/test/CodeGen/exceptions.c @@ -5,8 +5,8 @@ void test1() { extern void test1_helper(void (^)(int)); - // CHECK-LABEL: define void @test1() - // CHECK-ARM-LABEL: define arm_aapcscc void @test1() + // CHECK-LABEL: define void @test1() {{.*}} personality i8* bitcast (i32 (...)* @__gcc_personality_v0 to i8*) + // CHECK-ARM-LABEL: define arm_aapcscc void @test1() {{.*}} personality i8* bitcast (i32 (...)* @__gcc_personality_sj0 to i8*) __block int x = 10; @@ -14,9 +14,9 @@ void test1() { // CHECK-ARM: invoke arm_aapcscc void @test1_helper( test1_helper(^(int v) { x = v; }); - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gcc_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: cleanup - // CHECK-ARM: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gcc_personality_sj0 to i8*) + // CHECK-ARM: landingpad { i8*, i32 } // CHECK-ARM-NEXT: cleanup } diff --git a/test/CodeGen/inline-asm-immediate-ubsan.c b/test/CodeGen/inline-asm-immediate-ubsan.c new file mode 100644 index 000000000000..77d5e4f557c0 --- /dev/null +++ b/test/CodeGen/inline-asm-immediate-ubsan.c @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s \ +// RUN: -fsanitize=signed-integer-overflow \ +// RUN: | FileCheck %s --check-prefix=CHECK + +// Verify we emit constants for "immediate" inline assembly arguments. +// Emitting a scalar expression can make the immediate be generated as +// overflow intrinsics, if the overflow sanitizer is enabled. + +// Check both 'i' and 'I': +// - 'i' accepts symbolic constants. +// - 'I' doesn't, and is really an immediate-required constraint. + +// See also PR23517. + +// CHECK-LABEL: @test_inlineasm_i +// CHECK: call void asm sideeffect "int $0", "i{{.*}}"(i32 2) +void test_inlineasm_i() { + __asm__ __volatile__("int %0" :: "i"(1 + 1)); +} + +// CHECK-LABEL: @test_inlineasm_I +// CHECK: call void asm sideeffect "int $0", "I{{.*}}"(i32 2) +// CHECK: call void asm sideeffect "int $0", "I{{.*}}"(i32 3) +void test_inlineasm_I() { + __asm__ __volatile__("int %0" :: "I"(1 + 1)); + + // Also check a C non-ICE. + static const int N = 1; + __asm__ __volatile__("int %0" :: "I"(N + 2)); +} diff --git a/test/CodeGen/ms-inline-asm.c b/test/CodeGen/ms-inline-asm.c index a6f1b71b392b..d98b498a36fa 100644 --- a/test/CodeGen/ms-inline-asm.c +++ b/test/CodeGen/ms-inline-asm.c @@ -432,6 +432,8 @@ void t37() { // CHECK: mov eax, $$4294967292 __asm mov eax, ~15 // CHECK: mov eax, $$4294967280 + __asm mov eax, 6 ^ 3 +// CHECK: mov eax, $$5 // CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"() } diff --git a/test/CodeGen/partial-reinitialization1.c b/test/CodeGen/partial-reinitialization1.c new file mode 100644 index 000000000000..6a764b7fb02d --- /dev/null +++ b/test/CodeGen/partial-reinitialization1.c @@ -0,0 +1,74 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -emit-llvm -o - | FileCheck %s + +struct P1 { + struct Q1 { + char a[6]; + char b[6]; + } q; +}; + +// CHECK: { [6 x i8] c"foo\00\00\00", [6 x i8] c"\00x\00\00\00\00" } +struct P1 l1 = { + (struct Q1){ "foo", "bar" }, + .q.b = { "boo" }, + .q.b = { [1] = 'x' } +}; + +// CHECK: { [6 x i8] c"foo\00\00\00", [6 x i8] c"bxo\00\00\00" } +struct P1 l1a = { + (struct Q1){ "foo", "bar" }, + .q.b = { "boo" }, + .q.b[1] = 'x' +}; + + +struct P2 { char x[6]; }; + +// CHECK: { [6 x i8] c"n\00\00\00\00\00" } +struct P2 l2 = { + .x = { [1] = 'o' }, + .x = { [0] = 'n' } +}; + +struct P3 { + struct Q3 { + struct R1 { + int a, b, c; + } r1; + + struct R2 { + int d, e, f; + } r2; + } q; +}; + +// CHECK: @l3 = global %struct.P3 { %struct.Q3 { %struct.R1 { i32 1, i32 2, i32 3 }, %struct.R2 { i32 0, i32 10, i32 0 } } } +struct P3 l3 = { + (struct Q3){ { 1, 2, 3 }, { 4, 5, 6 } }, + .q.r2 = { 7, 8, 9 }, + .q.r2 = { .e = 10 } +}; + +// This bit is taken from Sema/wchar.c so we can avoid the wchar.h include. +typedef __WCHAR_TYPE__ wchar_t; + +struct P4 { + wchar_t x[6]; +}; + +// CHECK: { [6 x i32] [i32 102, i32 111, i32 120, i32 0, i32 0, i32 0] } +struct P4 l4 = { { L"foo" }, .x[2] = L'x' }; + +struct P5 { + int x; + struct Q5 { + int a, b, c; + } q; + int y; +}; + +// A three-pass test +// CHECK: @l5 = global %struct.P5 { i32 1, %struct.Q5 { i32 6, i32 9, i32 8 }, i32 5 } +struct P5 l5 = { 1, { 2, 3, 4 }, 5, + .q = { 6, 7, 8 }, + .q.b = 9 }; diff --git a/test/CodeGen/partial-reinitialization2.c b/test/CodeGen/partial-reinitialization2.c new file mode 100644 index 000000000000..c4f6567b36ce --- /dev/null +++ b/test/CodeGen/partial-reinitialization2.c @@ -0,0 +1,108 @@ +// RUN: %clang_cc1 %s -triple x86_64-unknown-unknown -emit-llvm -o - | FileCheck %s + +struct P1 { char x[6]; } g1 = { "foo" }; +struct LP1 { struct P1 p1; }; + +struct P2 { int a, b, c; } g2 = { 1, 2, 3 }; +struct LP2 { struct P2 p2; }; +struct LP2P2 { struct P2 p1, p2; }; +union UP2 { struct P2 p2; }; + +struct LP3 { struct P1 p1[2]; } g3 = { { "dog" }, { "cat" } }; +struct LLP3 { struct LP3 l3; }; +union ULP3 { struct LP3 l3; }; + +// CHECK-LABEL: test1 +void test1(void) +{ + // CHECK: call void @llvm.memcpy{{.*}}%struct.P1, %struct.P1* @g1{{.*}}i64 6, i32 {{[0-9]}}, i1 false) + // CHECK: store i8 120, i8* % + + struct LP1 l = { .p1 = g1, .p1.x[2] = 'x' }; +} + +// CHECK-LABEL: test2 +void test2(void) +{ + // CHECK: call void @llvm.memcpy{{.*}}%struct.P1, %struct.P1* @g1{{.*}}i64 6, i32 {{[0-9]}}, i1 false) + // CHECK: store i8 114, i8* % + + struct LP1 l = { .p1 = g1, .p1.x[1] = 'r' }; +} + +// CHECK-LABEL: test3 +void test3(void) +{ + // CHECK: call void @llvm.memcpy{{.*}}%struct.P2* @g2{{.*}}i64 12, i32 {{[0-9]}}, i1 false) + // CHECK: store i32 10, i32* % + + struct LP2 l = { .p2 = g2, .p2.b = 10 }; +} + +// CHECK-LABEL: get235 +struct P2 get235() +{ + struct P2 p = { 2, 3, 5 }; + return p; +} + +// CHECK-LABEL: get456789 +struct LP2P2 get456789() +{ + struct LP2P2 l = { { 4, 5, 6 }, { 7, 8, 9 } }; + return l; +} + +// CHECK-LABEL: get123 +union UP2 get123() +{ + union UP2 u = { { 1, 2, 3 } }; + return u; +} + +// CHECK-LABEL: test4 +void test4(void) +{ + // CHECK: [[CALL:%[a-z0-9]+]] = call {{.*}}@get123() + // CHECK: store{{.*}}[[CALL]], {{.*}}[[TMP0:%[a-z0-9]+]] + // CHECK: [[TMP1:%[a-z0-9]+]] = bitcast {{.*}}[[TMP0]] + // CHECK: call void @llvm.memcpy{{.*}}[[TMP1]], i64 12, i32 {{[0-9]}}, i1 false) + // CHECK: store i32 100, i32* % + + struct LUP2 { union UP2 up; } var = { get123(), .up.p2.a = 100 }; +} + +// CHECK-LABEL: test5 +void test5(void) +{ + // .l3 = g3 + // CHECK: call void @llvm.memcpy{{.*}}%struct.LP3, %struct.LP3* @g3{{.*}}i64 12, i32 {{[0-9]}}, i1 false) + + // .l3.p1 = { [0] = g1 } implicitly sets [1] to zero + // CHECK: call void @llvm.memcpy{{.*}}%struct.P1, %struct.P1* @g1{{.*}}i64 6, i32 {{[0-9]}}, i1 false) + // CHECK: getelementptr{{.*}}%struct.P1, %struct.P1*{{.*}}i64 1 + // CHECK: call void @llvm.memset{{.*}}i8 0, i64 6, i32 {{[0-9]}}, i1 false) + + // .l3.p1[1].x[1] = 'x' + // CHECK: store i8 120, i8* % + + struct LLP3 var = { .l3 = g3, .l3.p1 = { [0] = g1 }, .l3.p1[1].x[1] = 'x' }; +} + +// CHECK-LABEL: test6 +void test6(void) +{ + // CHECK: [[LP:%[a-z0-9]+]] = getelementptr{{.*}}%struct.LLP2P2, %struct.LLP2P2*{{.*}}, i32 0, i32 0 + // CHECK: call {{.*}}get456789(%struct.LP2P2* {{.*}}[[LP]]) + + // CHECK: [[CALL:%[a-z0-9]+]] = call {{.*}}@get235() + // CHECK: store{{.*}}[[CALL]], {{.*}}[[TMP0:%[a-z0-9]+]] + // CHECK: [[TMP1:%[a-z0-9]+]] = bitcast {{.*}}[[TMP0]] + // CHECK: call void @llvm.memcpy{{.*}}[[TMP1]], i64 12, i32 {{[0-9]}}, i1 false) + + // CHECK: store i32 10, i32* % + + struct LLP2P2 { struct LP2P2 lp; } var = { get456789(), + .lp.p1 = get235(), + .lp.p1.b = 10 }; +} diff --git a/test/CodeGen/safestack-attr.cpp b/test/CodeGen/safestack-attr.cpp new file mode 100644 index 000000000000..9d1ed0d2e493 --- /dev/null +++ b/test/CodeGen/safestack-attr.cpp @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -triple x86_64-linux-unknown -emit-llvm -o - %s -fsanitize=safe-stack | FileCheck -check-prefix=SP %s + +__attribute__((no_sanitize("safe-stack"))) +int foo(int *a) { return *a; } + +// SP-NOT: attributes #{{.*}} = { {{.*}}safestack{{.*}} } diff --git a/test/CodeGen/sanitize-trap.c b/test/CodeGen/sanitize-trap.c new file mode 100644 index 000000000000..76ac1f0ad718 --- /dev/null +++ b/test/CodeGen/sanitize-trap.c @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -emit-llvm -o - %s -fsanitize=signed-integer-overflow,integer-divide-by-zero -fsanitize-trap=integer-divide-by-zero | FileCheck %s + +int f(int x, int y) { + // CHECK: %[[B1:.*]] = icmp ne i32 %[[D:.*]], 0 + // CHECK: %[[B2:.*]] = icmp ne i32 %[[N:.*]], -2147483648 + // CHECK: %[[B3:.*]] = icmp ne i32 %[[D]], -1 + // CHECK: %[[B4:.*]] = or i1 %[[B2]], %[[B3]] + // CHECK: br i1 %[[B1]], label %[[L1:[0-9a-z_.]*]], label %[[L2:[0-9a-z_.]*]] + + // CHECK: [[L2]] + // CHECK-NEXT: call void @llvm.trap() + // CHECK-NEXT: unreachable + + // CHECK: [[L1]] + // CHECK-NEXT: br i1 %[[B4]], label %[[L3:[0-9a-z_.]*]], label %[[L4:[0-9a-z_.]*]] + + // CHECK: [[L4]] + // CHECK-NEXT: zext + // CHECK-NEXT: zext + // CHECK-NEXT: __ubsan_handle_divrem_overflow + + // CHECK: [[L3]] + // CHECK-NEXT: sdiv i32 %[[N]], %[[D]] + return x / y; +} diff --git a/test/CodeGen/stack-protector.c b/test/CodeGen/stack-protector.c index 2fb9b2cf7e65..8039b6059efd 100644 --- a/test/CodeGen/stack-protector.c +++ b/test/CodeGen/stack-protector.c @@ -6,6 +6,8 @@ // SSPSTRONG: define void @test1(i8* %msg) #0 { // RUN: %clang_cc1 -emit-llvm -o - %s -stack-protector 3 | FileCheck -check-prefix=SSPREQ %s // SSPREQ: define void @test1(i8* %msg) #0 { +// RUN: %clang_cc1 -emit-llvm -o - %s -fsanitize=safe-stack | FileCheck -check-prefix=SAFESTACK %s +// SAFESTACK: define void @test1(i8* %msg) #0 { typedef __SIZE_TYPE__ size_t; @@ -26,3 +28,5 @@ void test1(const char *msg) { // SSPSTRONG: attributes #{{.*}} = { nounwind sspstrong{{.*}} } // SSPREQ: attributes #{{.*}} = { nounwind sspreq{{.*}} } + +// SAFESTACK: attributes #{{.*}} = { nounwind safestack{{.*}} } diff --git a/test/CodeGen/systemz-inline-asm.c b/test/CodeGen/systemz-inline-asm.c index 92ed4bb03243..7d5a6b2ee8dc 100644 --- a/test/CodeGen/systemz-inline-asm.c +++ b/test/CodeGen/systemz-inline-asm.c @@ -6,31 +6,31 @@ unsigned long gl; void test_store_m(unsigned int i) { asm("st %1, %0" : "=m" (gi) : "r" (i)); // CHECK-LABEL: define void @test_store_m(i32 zeroext %i) -// CHECK: call void asm "st $1, $0", "=*m,r"(i32* @gi, i32 %i) +// CHECK: call void asm "st $1, $0", "=*m,r"(i32* nonnull @gi, i32 %i) } void test_store_Q(unsigned int i) { asm("st %1, %0" : "=Q" (gi) : "r" (i)); // CHECK-LABEL: define void @test_store_Q(i32 zeroext %i) -// CHECK: call void asm "st $1, $0", "=*Q,r"(i32* @gi, i32 %i) +// CHECK: call void asm "st $1, $0", "=*Q,r"(i32* nonnull @gi, i32 %i) } void test_store_R(unsigned int i) { asm("st %1, %0" : "=R" (gi) : "r" (i)); // CHECK-LABEL: define void @test_store_R(i32 zeroext %i) -// CHECK: call void asm "st $1, $0", "=*R,r"(i32* @gi, i32 %i) +// CHECK: call void asm "st $1, $0", "=*R,r"(i32* nonnull @gi, i32 %i) } void test_store_S(unsigned int i) { asm("st %1, %0" : "=S" (gi) : "r" (i)); // CHECK-LABEL: define void @test_store_S(i32 zeroext %i) -// CHECK: call void asm "st $1, $0", "=*S,r"(i32* @gi, i32 %i) +// CHECK: call void asm "st $1, $0", "=*S,r"(i32* nonnull @gi, i32 %i) } void test_store_T(unsigned int i) { asm("st %1, %0" : "=T" (gi) : "r" (i)); // CHECK-LABEL: define void @test_store_T(i32 zeroext %i) -// CHECK: call void asm "st $1, $0", "=*T,r"(i32* @gi, i32 %i) +// CHECK: call void asm "st $1, $0", "=*T,r"(i32* nonnull @gi, i32 %i) } int test_load_m() { @@ -38,7 +38,7 @@ int test_load_m() { asm("l %0, %1" : "=r" (i) : "m" (gi)); return i; // CHECK-LABEL: define signext i32 @test_load_m() -// CHECK: call i32 asm "l $0, $1", "=r,*m"(i32* @gi) +// CHECK: call i32 asm "l $0, $1", "=r,*m"(i32* nonnull @gi) } int test_load_Q() { @@ -46,7 +46,7 @@ int test_load_Q() { asm("l %0, %1" : "=r" (i) : "Q" (gi)); return i; // CHECK-LABEL: define signext i32 @test_load_Q() -// CHECK: call i32 asm "l $0, $1", "=r,*Q"(i32* @gi) +// CHECK: call i32 asm "l $0, $1", "=r,*Q"(i32* nonnull @gi) } int test_load_R() { @@ -54,7 +54,7 @@ int test_load_R() { asm("l %0, %1" : "=r" (i) : "R" (gi)); return i; // CHECK-LABEL: define signext i32 @test_load_R() -// CHECK: call i32 asm "l $0, $1", "=r,*R"(i32* @gi) +// CHECK: call i32 asm "l $0, $1", "=r,*R"(i32* nonnull @gi) } int test_load_S() { @@ -62,7 +62,7 @@ int test_load_S() { asm("l %0, %1" : "=r" (i) : "S" (gi)); return i; // CHECK-LABEL: define signext i32 @test_load_S() -// CHECK: call i32 asm "l $0, $1", "=r,*S"(i32* @gi) +// CHECK: call i32 asm "l $0, $1", "=r,*S"(i32* nonnull @gi) } int test_load_T() { @@ -70,7 +70,7 @@ int test_load_T() { asm("l %0, %1" : "=r" (i) : "T" (gi)); return i; // CHECK-LABEL: define signext i32 @test_load_T() -// CHECK: call i32 asm "l $0, $1", "=r,*T"(i32* @gi) +// CHECK: call i32 asm "l $0, $1", "=r,*T"(i32* nonnull @gi) } void test_mI(unsigned char *c) { diff --git a/test/CodeGen/target-data.c b/test/CodeGen/target-data.c index d601158af63a..3c3ea0400787 100644 --- a/test/CodeGen/target-data.c +++ b/test/CodeGen/target-data.c @@ -174,3 +174,11 @@ // RUN: %clang_cc1 -triple spir64-unknown -o - -emit-llvm %s | \ // RUN: FileCheck %s -check-prefix=SPIR64 // SPIR64: target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024" + +// RUN: %clang_cc1 -triple bpfel -o - -emit-llvm %s | \ +// RUN: FileCheck %s -check-prefix=BPFEL +// BPFEL: target datalayout = "e-m:e-p:64:64-i64:64-n32:64-S128" + +// RUN: %clang_cc1 -triple bpfeb -o - -emit-llvm %s | \ +// RUN: FileCheck %s -check-prefix=BPFEB +// BPFEB: target datalayout = "E-m:e-p:64:64-i64:64-n32:64-S128" diff --git a/test/CodeGenCXX/arm.cpp b/test/CodeGenCXX/arm.cpp index 7d94cba7ff11..0fadfe97b49a 100644 --- a/test/CodeGenCXX/arm.cpp +++ b/test/CodeGenCXX/arm.cpp @@ -291,7 +291,7 @@ namespace test7 { // Static and guard tested at top of file - // CHECK-LABEL: define void @_ZN5test74testEv() + // CHECK-LABEL: define void @_ZN5test74testEv() {{.*}} personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) void test() { // CHECK: [[T0:%.*]] = load atomic i8, i8* bitcast (i32* @_ZGVZN5test74testEvE1x to i8*) acquire, align 1 // CHECK-NEXT: [[T1:%.*]] = and i8 [[T0]], 1 @@ -311,7 +311,7 @@ namespace test7 { // CHECK: ret void static int x = foo(); - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: cleanup // CHECK: call void @__cxa_guard_abort(i32* @_ZGVZN5test74testEvE1x) // CHECK: resume { i8*, i32 } @@ -326,7 +326,7 @@ namespace test8 { // Static and guard tested at top of file - // CHECK-LABEL: define void @_ZN5test84testEv() + // CHECK-LABEL: define void @_ZN5test84testEv() {{.*}} personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) void test() { // CHECK: [[T0:%.*]] = load atomic i8, i8* bitcast (i32* @_ZGVZN5test84testEvE1x to i8*) acquire, align 1 // CHECK-NEXT: [[T1:%.*]] = and i8 [[T0]], 1 @@ -351,7 +351,7 @@ namespace test8 { // CHECK: ret void static A x; - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: cleanup // CHECK: call void @__cxa_guard_abort(i32* @_ZGVZN5test84testEvE1x) // CHECK: resume { i8*, i32 } diff --git a/test/CodeGenCXX/atomicinit.cpp b/test/CodeGenCXX/atomicinit.cpp index a47099c11b44..5e5174bd06e4 100644 --- a/test/CodeGenCXX/atomicinit.cpp +++ b/test/CodeGenCXX/atomicinit.cpp @@ -65,15 +65,15 @@ namespace PR18097 { }; // CHECK-LABEL: define {{.*}} @__cxx_global_var_init - // CHECK: call void @_ZN7PR180977dynamic1XC1Ei({{.*}}* @_ZN7PR180977dynamic1aE, i32 1) + // CHECK: call void @_ZN7PR180977dynamic1XC1Ei({{.*}}* nonnull @_ZN7PR180977dynamic1aE, i32 1) _Atomic(X) a = X(1); // CHECK-LABEL: define {{.*}} @__cxx_global_var_init - // CHECK: call void @_ZN7PR180977dynamic1XC1Ei({{.*}}* @_ZN7PR180977dynamic1bE, i32 2) + // CHECK: call void @_ZN7PR180977dynamic1XC1Ei({{.*}}* nonnull @_ZN7PR180977dynamic1bE, i32 2) _Atomic(X) b(X(2)); // CHECK-LABEL: define {{.*}} @__cxx_global_var_init - // CHECK: call void @_ZN7PR180977dynamic1XC1Ei({{.*}}* @_ZN7PR180977dynamic1cE, i32 3) + // CHECK: call void @_ZN7PR180977dynamic1XC1Ei({{.*}}* nonnull @_ZN7PR180977dynamic1cE, i32 3) _Atomic(X) c{X(3)}; struct Y { diff --git a/test/CodeGenCXX/cfi-cast.cpp b/test/CodeGenCXX/cfi-cast.cpp index c671bad7efa2..09089634442c 100644 --- a/test/CodeGenCXX/cfi-cast.cpp +++ b/test/CodeGenCXX/cfi-cast.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -triple x86_64-unknown-linux -fsanitize=cfi-derived-cast -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-DCAST %s -// RUN: %clang_cc1 -triple x86_64-unknown-linux -fsanitize=cfi-unrelated-cast -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-UCAST %s -// RUN: %clang_cc1 -triple x86_64-unknown-linux -fsanitize=cfi-unrelated-cast,cfi-cast-strict -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-UCAST-STRICT %s +// RUN: %clang_cc1 -triple x86_64-unknown-linux -fsanitize=cfi-derived-cast -fsanitize-trap=cfi-derived-cast -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-DCAST %s +// RUN: %clang_cc1 -triple x86_64-unknown-linux -fsanitize=cfi-unrelated-cast -fsanitize-trap=cfi-unrelated-cast -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-UCAST %s +// RUN: %clang_cc1 -triple x86_64-unknown-linux -fsanitize=cfi-unrelated-cast,cfi-cast-strict -fsanitize-trap=cfi-unrelated-cast,cfi-cast-strict -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-UCAST-STRICT %s // In this test the main thing we are searching for is something like // 'metadata !"1B"' where "1B" is the mangled name of the class we are @@ -19,7 +19,7 @@ struct C : A {}; // CHECK-DCAST-LABEL: define void @_Z3abpP1A void abp(A *a) { // CHECK-DCAST: [[P:%[^ ]*]] = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"1B") - // CHECK-DCAST-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ]*]] + // CHECK-DCAST-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ,]*]] // CHECK-DCAST: [[TRAPBB]] // CHECK-DCAST-NEXT: call void @llvm.trap() @@ -33,7 +33,7 @@ void abp(A *a) { // CHECK-DCAST-LABEL: define void @_Z3abrR1A void abr(A &a) { // CHECK-DCAST: [[P:%[^ ]*]] = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"1B") - // CHECK-DCAST-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ]*]] + // CHECK-DCAST-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ,]*]] // CHECK-DCAST: [[TRAPBB]] // CHECK-DCAST-NEXT: call void @llvm.trap() @@ -47,7 +47,7 @@ void abr(A &a) { // CHECK-DCAST-LABEL: define void @_Z4abrrO1A void abrr(A &&a) { // CHECK-DCAST: [[P:%[^ ]*]] = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"1B") - // CHECK-DCAST-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ]*]] + // CHECK-DCAST-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ,]*]] // CHECK-DCAST: [[TRAPBB]] // CHECK-DCAST-NEXT: call void @llvm.trap() @@ -61,7 +61,7 @@ void abrr(A &&a) { // CHECK-UCAST-LABEL: define void @_Z3vbpPv void vbp(void *p) { // CHECK-UCAST: [[P:%[^ ]*]] = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"1B") - // CHECK-UCAST-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ]*]] + // CHECK-UCAST-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ,]*]] // CHECK-UCAST: [[TRAPBB]] // CHECK-UCAST-NEXT: call void @llvm.trap() @@ -75,7 +75,7 @@ void vbp(void *p) { // CHECK-UCAST-LABEL: define void @_Z3vbrRc void vbr(char &r) { // CHECK-UCAST: [[P:%[^ ]*]] = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"1B") - // CHECK-UCAST-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ]*]] + // CHECK-UCAST-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ,]*]] // CHECK-UCAST: [[TRAPBB]] // CHECK-UCAST-NEXT: call void @llvm.trap() @@ -89,7 +89,7 @@ void vbr(char &r) { // CHECK-UCAST-LABEL: define void @_Z4vbrrOc void vbrr(char &&r) { // CHECK-UCAST: [[P:%[^ ]*]] = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"1B") - // CHECK-UCAST-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ]*]] + // CHECK-UCAST-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ,]*]] // CHECK-UCAST: [[TRAPBB]] // CHECK-UCAST-NEXT: call void @llvm.trap() diff --git a/test/CodeGenCXX/cfi-vcall.cpp b/test/CodeGenCXX/cfi-vcall.cpp index b0f79d9ec0ea..333c7bd1f160 100644 --- a/test/CodeGenCXX/cfi-vcall.cpp +++ b/test/CodeGenCXX/cfi-vcall.cpp @@ -1,4 +1,15 @@ -// RUN: %clang_cc1 -triple x86_64-unknown-linux -fsanitize=cfi-vcall -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-unknown-linux -fsanitize=cfi-vcall -fsanitize-trap=cfi-vcall -emit-llvm -o - %s | FileCheck --check-prefix=CHECK --check-prefix=ITANIUM --check-prefix=NDIAG %s +// RUN: %clang_cc1 -triple x86_64-unknown-linux -fsanitize=cfi-vcall -emit-llvm -o - %s | FileCheck --check-prefix=CHECK --check-prefix=ITANIUM --check-prefix=DIAG --check-prefix=DIAG-ABORT %s +// RUN: %clang_cc1 -triple x86_64-unknown-linux -fsanitize=cfi-vcall -fsanitize-recover=cfi-vcall -emit-llvm -o - %s | FileCheck --check-prefix=CHECK --check-prefix=ITANIUM --check-prefix=DIAG --check-prefix=DIAG-RECOVER %s +// RUN: %clang_cc1 -triple x86_64-pc-windows-msvc -fsanitize=cfi-vcall -fsanitize-trap=cfi-vcall -emit-llvm -o - %s | FileCheck --check-prefix=CHECK --check-prefix=MS --check-prefix=NDIAG %s + +// MS: @[[VTA:[0-9]*]] {{.*}} comdat($"\01??_7A@@6B@") +// MS: @[[VTB:[0-9]*]] {{.*}} comdat($"\01??_7B@@6B0@@") +// MS: @[[VTAinB:[0-9]*]] {{.*}} comdat($"\01??_7B@@6BA@@@") +// MS: @[[VTAinC:[0-9]*]] {{.*}} comdat($"\01??_7C@@6B@") +// MS: @[[VTBinD:[0-9]*]] {{.*}} comdat($"\01??_7D@?A@@6BB@@@") +// MS: @[[VTAinBinD:[0-9]*]] {{.*}} comdat($"\01??_7D@?A@@6BA@@@") +// MS: @[[VTFA:[0-9]*]] {{.*}} comdat($"\01??_7FA@?1??foo@@YAXXZ@6B@") struct A { A(); @@ -7,6 +18,8 @@ struct A { struct B : virtual A { B(); + virtual void g(); + virtual void h(); }; struct C : virtual A { @@ -18,6 +31,7 @@ namespace { struct D : B, C { D(); virtual void f(); + virtual void h(); }; } @@ -30,37 +44,75 @@ D::D() {} void A::f() { } +void B::g() { +} + void D::f() { } -// CHECK: define void @_Z2afP1A +void D::h() { +} + +// DIAG: @[[SRC:.*]] = private unnamed_addr constant [{{.*}} x i8] c"{{.*}}cfi-vcall.cpp\00", align 1 +// DIAG: @[[TYPE:.*]] = private unnamed_addr constant { i16, i16, [4 x i8] } { i16 -1, i16 0, [4 x i8] c"'A'\00" } +// DIAG: @[[BADTYPESTATIC:.*]] = private unnamed_addr global { { [{{.*}} x i8]*, i32, i32 }, { i16, i16, [4 x i8] }*, i8 } { { [{{.*}} x i8]*, i32, i32 } { [{{.*}} x i8]* @[[SRC]], i32 [[@LINE+21]], i32 3 }, { i16, i16, [4 x i8] }* @[[TYPE]], i8 0 } + +// ITANIUM: define void @_Z2afP1A +// MS: define void @"\01?af@@YAXPEAUA@@@Z" void af(A *a) { - // CHECK: [[P:%[^ ]*]] = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"1A") - // CHECK-NEXT: br i1 [[P]], label %[[CONTBB:[^ ]*]], label %[[TRAPBB:[^ ]*]] + // ITANIUM: [[P:%[^ ]*]] = call i1 @llvm.bitset.test(i8* [[VT:%[^ ]*]], metadata !"1A") + // MS: [[P:%[^ ]*]] = call i1 @llvm.bitset.test(i8* [[VT:%[^ ]*]], metadata !"A@@") + // CHECK-NEXT: br i1 [[P]], label %[[CONTBB:[^ ,]*]], label %[[TRAPBB:[^ ,]*]] + // CHECK-NEXT: {{^$}} // CHECK: [[TRAPBB]] - // CHECK-NEXT: call void @llvm.trap() - // CHECK-NEXT: unreachable + // NDIAG-NEXT: call void @llvm.trap() + // NDIAG-NEXT: unreachable + // DIAG-NEXT: [[VTINT:%[^ ]*]] = ptrtoint i8* [[VT]] to i64 + // DIAG-ABORT-NEXT: call void @__ubsan_handle_cfi_bad_type_abort(i8* bitcast ({{.*}} @[[BADTYPESTATIC]] to i8*), i64 [[VTINT]]) + // DIAG-ABORT-NEXT: unreachable + // DIAG-RECOVER-NEXT: call void @__ubsan_handle_cfi_bad_type(i8* bitcast ({{.*}} @[[BADTYPESTATIC]] to i8*), i64 [[VTINT]]) + // DIAG-RECOVER-NEXT: br label %[[CONTBB]] // CHECK: [[CONTBB]] // CHECK: call void % a->f(); } -// CHECK: define internal void @_Z3df1PN12_GLOBAL__N_11DE +// ITANIUM: define internal void @_Z3df1PN12_GLOBAL__N_11DE +// MS: define internal void @"\01?df1@@YAXPEAUD@?A@@@Z" void df1(D *d) { - // CHECK: {{%[^ ]*}} = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"[{{.*}}cfi-vcall.cpp]N12_GLOBAL__N_11DE") + // ITANIUM: {{%[^ ]*}} = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"[{{.*}}cfi-vcall.cpp]N12_GLOBAL__N_11DE") + // MS: {{%[^ ]*}} = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"A@@") d->f(); } -// CHECK: define internal void @_Z3df2PN12_GLOBAL__N_11DE +// ITANIUM: define internal void @_Z3dg1PN12_GLOBAL__N_11DE +// MS: define internal void @"\01?dg1@@YAXPEAUD@?A@@@Z" +void dg1(D *d) { + // ITANIUM: {{%[^ ]*}} = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"1B") + // MS: {{%[^ ]*}} = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"B@@") + d->g(); +} + +// ITANIUM: define internal void @_Z3dh1PN12_GLOBAL__N_11DE +// MS: define internal void @"\01?dh1@@YAXPEAUD@?A@@@Z" +void dh1(D *d) { + // ITANIUM: {{%[^ ]*}} = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"[{{.*}}cfi-vcall.cpp]N12_GLOBAL__N_11DE") + // MS: {{%[^ ]*}} = call i1 @llvm.bitset.test(i8* {{%[^ ]*}}, metadata !"[{{.*}}cfi-vcall.cpp]D@?A@@") + d->h(); +} + +// ITANIUM: define internal void @_Z3df2PN12_GLOBAL__N_11DE +// MS: define internal void @"\01?df2@@YAXPEAUD@?A@@@Z" __attribute__((no_sanitize("cfi"))) void df2(D *d) { // CHECK-NOT: call i1 @llvm.bitset.test d->f(); } -// CHECK: define internal void @_Z3df3PN12_GLOBAL__N_11DE +// ITANIUM: define internal void @_Z3df3PN12_GLOBAL__N_11DE +// MS: define internal void @"\01?df3@@YAXPEAUD@?A@@@Z" __attribute__((no_sanitize("address"))) __attribute__((no_sanitize("cfi-vcall"))) void df3(D *d) { // CHECK-NOT: call i1 @llvm.bitset.test @@ -71,20 +123,43 @@ D d; void foo() { df1(&d); + dg1(&d); + dh1(&d); df2(&d); df3(&d); + + struct FA : A { + void f() {} + } fa; + af(&fa); } -// CHECK-DAG: !{!"1A", [3 x i8*]* @_ZTV1A, i64 16} -// CHECK-DAG: !{!"1A", [5 x i8*]* @_ZTCN12_GLOBAL__N_11DE0_1B, i64 32} -// CHECK-DAG: !{!"1B", [5 x i8*]* @_ZTCN12_GLOBAL__N_11DE0_1B, i64 32} -// CHECK-DAG: !{!"1A", [9 x i8*]* @_ZTCN12_GLOBAL__N_11DE8_1C, i64 64} -// CHECK-DAG: !{!"1C", [9 x i8*]* @_ZTCN12_GLOBAL__N_11DE8_1C, i64 32} -// CHECK-DAG: !{!"1A", [10 x i8*]* @_ZTVN12_GLOBAL__N_11DE, i64 32} -// CHECK-DAG: !{!"1B", [10 x i8*]* @_ZTVN12_GLOBAL__N_11DE, i64 32} -// CHECK-DAG: !{!"1C", [10 x i8*]* @_ZTVN12_GLOBAL__N_11DE, i64 72} -// CHECK-DAG: !{!"[{{.*}}cfi-vcall.cpp]N12_GLOBAL__N_11DE", [10 x i8*]* @_ZTVN12_GLOBAL__N_11DE, i64 32} -// CHECK-DAG: !{!"1A", [5 x i8*]* @_ZTV1B, i64 32} -// CHECK-DAG: !{!"1B", [5 x i8*]* @_ZTV1B, i64 32} -// CHECK-DAG: !{!"1A", [5 x i8*]* @_ZTV1C, i64 32} -// CHECK-DAG: !{!"1C", [5 x i8*]* @_ZTV1C, i64 32} +// Check for the expected number of elements (9 or 15 respectively). +// MS: !llvm.bitsets = !{[[X:[^,]*(,[^,]*){8}]]} +// ITANIUM: !llvm.bitsets = !{[[X:[^,]*(,[^,]*){14}]]} + +// ITANIUM-DAG: !{!"1A", [3 x i8*]* @_ZTV1A, i64 16} +// ITANIUM-DAG: !{!"1A", [7 x i8*]* @_ZTCN12_GLOBAL__N_11DE0_1B, i64 32} +// ITANIUM-DAG: !{!"1B", [7 x i8*]* @_ZTCN12_GLOBAL__N_11DE0_1B, i64 32} +// ITANIUM-DAG: !{!"1A", [9 x i8*]* @_ZTCN12_GLOBAL__N_11DE8_1C, i64 64} +// ITANIUM-DAG: !{!"1C", [9 x i8*]* @_ZTCN12_GLOBAL__N_11DE8_1C, i64 32} +// ITANIUM-DAG: !{!"1A", [12 x i8*]* @_ZTVN12_GLOBAL__N_11DE, i64 32} +// ITANIUM-DAG: !{!"1B", [12 x i8*]* @_ZTVN12_GLOBAL__N_11DE, i64 32} +// ITANIUM-DAG: !{!"1C", [12 x i8*]* @_ZTVN12_GLOBAL__N_11DE, i64 88} +// ITANIUM-DAG: !{!"[{{.*}}cfi-vcall.cpp]N12_GLOBAL__N_11DE", [12 x i8*]* @_ZTVN12_GLOBAL__N_11DE, i64 32} +// ITANIUM-DAG: !{!"1A", [7 x i8*]* @_ZTV1B, i64 32} +// ITANIUM-DAG: !{!"1B", [7 x i8*]* @_ZTV1B, i64 32} +// ITANIUM-DAG: !{!"1A", [5 x i8*]* @_ZTV1C, i64 32} +// ITANIUM-DAG: !{!"1C", [5 x i8*]* @_ZTV1C, i64 32} +// ITANIUM-DAG: !{!"1A", [3 x i8*]* @_ZTVZ3foovE2FA, i64 16} +// ITANIUM-DAG: !{!"[{{.*}}cfi-vcall.cpp]Z3foovE2FA", [3 x i8*]* @_ZTVZ3foovE2FA, i64 16} + +// MS-DAG: !{!"A@@", [2 x i8*]* @[[VTA]], i64 8} +// MS-DAG: !{!"B@@", [3 x i8*]* @[[VTB]], i64 8} +// MS-DAG: !{!"A@@", [2 x i8*]* @[[VTAinB]], i64 8} +// MS-DAG: !{!"A@@", [2 x i8*]* @[[VTAinC]], i64 8} +// MS-DAG: !{!"B@@", [3 x i8*]* @[[VTBinD]], i64 8} +// MS-DAG: !{!"[{{.*}}cfi-vcall.cpp]D@?A@@", [3 x i8*]* @[[VTBinD]], i64 8} +// MS-DAG: !{!"A@@", [2 x i8*]* @[[VTAinBinD]], i64 8} +// MS-DAG: !{!"A@@", [2 x i8*]* @[[VTFA]], i64 8} +// MS-DAG: !{!"[{{.*}}cfi-vcall.cpp]FA@?1??foo@@YAXXZ@", [2 x i8*]* @[[VTFA]], i64 8} diff --git a/test/CodeGenCXX/ctor-globalopt.cpp b/test/CodeGenCXX/ctor-globalopt.cpp index 672fc9067527..26ec523c553b 100644 --- a/test/CodeGenCXX/ctor-globalopt.cpp +++ b/test/CodeGenCXX/ctor-globalopt.cpp @@ -13,7 +13,7 @@ // CHECK-LABEL: define internal void @_GLOBAL__sub_I_ctor_globalopt.cpp() // CHECK: call void @ -// CHECK-NOT: call +// CHECK-NOT: call{{ }} // O1: @llvm.global_ctors = appending global [0 x { i32, void ()*, i8* }] zeroinitializer diff --git a/test/CodeGenCXX/cxx11-exception-spec.cpp b/test/CodeGenCXX/cxx11-exception-spec.cpp index 3fb5c15c2ab5..a3dff79fc494 100644 --- a/test/CodeGenCXX/cxx11-exception-spec.cpp +++ b/test/CodeGenCXX/cxx11-exception-spec.cpp @@ -13,7 +13,7 @@ template<typename T> struct S { // CHECK: define {{.*}} @_Z1fIsEvv() [[NONE:#[0-9]+]] { template<> void f<short>() { h(); } -// CHECK: define {{.*}} @_Z1fIA2_sEvv() [[NUW:#[0-9]+]] { +// CHECK: define {{.*}} @_Z1fIA2_sEvv() [[NUW:#[0-9]+]] personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { template<> void f<short[2]>() noexcept { h(); } // CHECK: define {{.*}} @_ZN1SIsE1fEv() @@ -24,7 +24,7 @@ template<> void S<short[2]>::f() noexcept { h(); } // CHECK: define {{.*}} @_Z1fIDsEvv() [[NONE]] comdat { template void f<char16_t>(); -// CHECK: define {{.*}} @_Z1fIA2_DsEvv() [[NUW]] comdat { +// CHECK: define {{.*}} @_Z1fIA2_DsEvv() [[NUW]] comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { template void f<char16_t[2]>(); // CHECK: define {{.*}} @_ZN1SIDsE1fEv() @@ -34,7 +34,7 @@ template void S<char16_t>::f(); template void S<char16_t[2]>::f(); void h() { - // CHECK: define {{.*}} @_Z1fIiEvv() [[NUW]] comdat { + // CHECK: define {{.*}} @_Z1fIiEvv() [[NUW]] comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { f<int>(); // CHECK: define {{.*}} @_Z1fIA2_iEvv() [[NONE]] comdat { f<int[2]>(); @@ -45,7 +45,7 @@ void h() { // CHECK-NOT: [[NUW]] S<int[2]>::f(); - // CHECK: define {{.*}} @_Z1fIfEvv() [[NUW]] comdat { + // CHECK: define {{.*}} @_Z1fIfEvv() [[NUW]] comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { void (*f1)() = &f<float>; // CHECK: define {{.*}} @_Z1fIdEvv() [[NONE]] comdat { void (*f2)() = &f<double>; @@ -56,7 +56,7 @@ void h() { // CHECK-NOT: [[NUW]] void (*f4)() = &S<double>::f; - // CHECK: define {{.*}} @_Z1fIA4_cEvv() [[NUW]] comdat { + // CHECK: define {{.*}} @_Z1fIA4_cEvv() [[NUW]] comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { (void)&f<char[4]>; // CHECK: define {{.*}} @_Z1fIcEvv() [[NONE]] comdat { (void)&f<char>; diff --git a/test/CodeGenCXX/destructors.cpp b/test/CodeGenCXX/destructors.cpp index 2918cf39775b..b47c6c6b1d43 100644 --- a/test/CodeGenCXX/destructors.cpp +++ b/test/CodeGenCXX/destructors.cpp @@ -191,10 +191,11 @@ namespace test3 { // CHECK4: ret void // CHECK4-LABEL: define internal void @_ZN5test312_GLOBAL__N_11DD0Ev(%"struct.test3::(anonymous namespace)::D"* %this) unnamed_addr + // CHECK4-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) // CHECK4: invoke void {{.*}} @_ZN5test312_GLOBAL__N_11CD2Ev // CHECK4: call void @_ZdlPv({{.*}}) [[NUW:#[0-9]+]] // CHECK4: ret void - // CHECK4: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK4: landingpad { i8*, i32 } // CHECK4-NEXT: cleanup // CHECK4: call void @_ZdlPv({{.*}}) [[NUW]] // CHECK4: resume { i8*, i32 } @@ -210,10 +211,11 @@ namespace test3 { // CHECK4: ret void // CHECK4-LABEL: define internal void @_ZN5test312_GLOBAL__N_11CD0Ev(%"struct.test3::(anonymous namespace)::C"* %this) unnamed_addr + // CHECK4-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) // CHECK4: invoke void @_ZN5test312_GLOBAL__N_11CD2Ev( // CHECK4: call void @_ZdlPv({{.*}}) [[NUW]] // CHECK4: ret void - // CHECK4: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK4: landingpad { i8*, i32 } // CHECK4-NEXT: cleanup // CHECK4: call void @_ZdlPv({{.*}}) [[NUW]] // CHECK4: resume { i8*, i32 } diff --git a/test/CodeGenCXX/dllexport.cpp b/test/CodeGenCXX/dllexport.cpp index 477e7dcf0b53..0eb6476bd0ec 100644 --- a/test/CodeGenCXX/dllexport.cpp +++ b/test/CodeGenCXX/dllexport.cpp @@ -532,6 +532,22 @@ struct __declspec(dllexport) InheritFromTemplate : SomeTemplate<int> {}; // M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_F?$SomeTemplate@H@@QAEXXZ" +namespace PR23801 { +template <typename> +struct S { + ~S() {} +}; +struct A { + A(int); + S<int> s; +}; +struct __declspec(dllexport) B { + B(A = 0) {} +}; +} +// +// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_FB@PR23801@@QAEXXZ" + struct __declspec(dllexport) T { // Copy assignment operator: // M32-DAG: define weak_odr dllexport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.T* @"\01??4T@@QAEAAU0@ABU0@@Z" diff --git a/test/CodeGenCXX/dynamic-cast.cpp b/test/CodeGenCXX/dynamic-cast.cpp index fe85e212b669..9467f3e80d8c 100644 --- a/test/CodeGenCXX/dynamic-cast.cpp +++ b/test/CodeGenCXX/dynamic-cast.cpp @@ -3,6 +3,7 @@ struct A { virtual void f(); }; struct B : A { }; // CHECK: {{define.*@_Z1fP1A}} +// CHECK-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) B fail; const B& f(A *a) { try { @@ -11,7 +12,7 @@ const B& f(A *a) { // CHECK: invoke void @__cxa_bad_cast() [[NR:#[0-9]+]] dynamic_cast<const B&>(*a); } catch (...) { - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: catch i8* null } return fail; diff --git a/test/CodeGenCXX/eh.cpp b/test/CodeGenCXX/eh.cpp index 77655f0b9f0f..b44e8144bb27 100644 --- a/test/CodeGenCXX/eh.cpp +++ b/test/CodeGenCXX/eh.cpp @@ -102,6 +102,7 @@ namespace test6 { // PR7127 namespace test7 { // CHECK-LABEL: define i32 @_ZN5test73fooEv() +// CHECK-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) int foo() { // CHECK: [[CAUGHTEXNVAR:%.*]] = alloca i8* // CHECK-NEXT: [[SELECTORVAR:%.*]] = alloca i32 @@ -115,7 +116,7 @@ namespace test7 { throw 1; } -// CHECK: [[CAUGHTVAL:%.*]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) +// CHECK: [[CAUGHTVAL:%.*]] = landingpad { i8*, i32 } // CHECK-NEXT: catch i8* bitcast (i8** @_ZTIi to i8*) // CHECK-NEXT: catch i8* null // CHECK-NEXT: [[CAUGHTEXN:%.*]] = extractvalue { i8*, i32 } [[CAUGHTVAL]], 0 @@ -137,7 +138,7 @@ namespace test7 { throw; } } -// CHECK: [[CAUGHTVAL:%.*]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) +// CHECK: [[CAUGHTVAL:%.*]] = landingpad { i8*, i32 } // CHECK-NEXT: catch i8* null // CHECK-NEXT: [[CAUGHTEXN:%.*]] = extractvalue { i8*, i32 } [[CAUGHTVAL]], 0 // CHECK-NEXT: store i8* [[CAUGHTEXN]], i8** [[CAUGHTEXNVAR]] @@ -186,11 +187,12 @@ namespace test9 { // CHECK-LABEL: define void @_ZN5test91AC2Ev(%"struct.test9::A"* %this) unnamed_addr + // CHECK-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) A::A() try { // CHECK: invoke void @_ZN5test96opaqueEv() opaque(); } catch (int x) { - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: catch i8* bitcast (i8** @_ZTIi to i8*) // CHECK: call i8* @__cxa_begin_catch diff --git a/test/CodeGenCXX/exceptions-seh.cpp b/test/CodeGenCXX/exceptions-seh.cpp index 3e77f12fb5dc..2cee4f77e5d4 100644 --- a/test/CodeGenCXX/exceptions-seh.cpp +++ b/test/CodeGenCXX/exceptions-seh.cpp @@ -22,6 +22,7 @@ extern "C" void use_cxx() { // Make sure we use __CxxFrameHandler3 for C++ EH. // CXXEH-LABEL: define void @use_cxx() +// CXXEH-SAME: personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) // CXXEH: call %struct.HasCleanup* @"\01??0HasCleanup@@QEAA@XZ"(%struct.HasCleanup* %{{.*}}) // CXXEH: invoke void @might_throw() // CXXEH: to label %[[cont:[^ ]*]] unwind label %[[lpad:[^ ]*]] @@ -31,7 +32,7 @@ extern "C" void use_cxx() { // CXXEH: ret void // // CXXEH: [[lpad]] -// CXXEH: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) +// CXXEH: landingpad { i8*, i32 } // CXXEH-NEXT: cleanup // CXXEH: call void @"\01??1HasCleanup@@QEAA@XZ"(%struct.HasCleanup* %{{.*}}) // CXXEH: br label %[[resume:[^ ]*]] @@ -59,6 +60,7 @@ extern "C" void use_seh() { // Make sure we use __C_specific_handler for SEH. // CHECK-LABEL: define void @use_seh() +// CHECK-SAME: personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) // CHECK: invoke void @might_throw() #[[NOINLINE:[0-9]+]] // CHECK: to label %[[cont:[^ ]*]] unwind label %[[lpad:[^ ]*]] // @@ -66,7 +68,7 @@ extern "C" void use_seh() { // CHECK: br label %[[ret:[^ ]*]] // // CHECK: [[lpad]] -// CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) +// CHECK: landingpad { i8*, i32 } // CHECK-NEXT: catch i8* // // CHECK: br label %[[ret]] @@ -86,15 +88,17 @@ void use_seh_in_lambda() { } // CXXEH-LABEL: define void @"\01?use_seh_in_lambda@@YAXXZ"() -// CXXEH: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) +// CXXEH-SAME: personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) +// CXXEH: landingpad { i8*, i32 } // NOCXX-LABEL: define void @"\01?use_seh_in_lambda@@YAXXZ"() // NOCXX-NOT: invoke // NOCXX: ret void // CHECK-LABEL: define internal void @"\01??R<lambda_0>@?use_seh_in_lambda@@YAXXZ@QEBAXXZ"(%class.anon* %this) +// CXXEH-SAME: personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) // CHECK: invoke void @might_throw() #[[NOINLINE]] -// CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) +// CHECK: landingpad { i8*, i32 } static int my_unique_global; @@ -114,10 +118,11 @@ void use_inline() { use_seh_in_inline_func(); } -// CHECK-LABEL: define linkonce_odr void @use_seh_in_inline_func() #{{[0-9]+}} comdat { +// CHECK-LABEL: define linkonce_odr void @use_seh_in_inline_func() #{{[0-9]+}} comdat +// CHECK-SAME: personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) // CHECK: invoke void @might_throw() // -// CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) +// CHECK: landingpad { i8*, i32 } // CHECK-NEXT: catch i8* bitcast (i32 (i8*, i8*)* @"\01?filt$0@0@use_seh_in_inline_func@@" to i8*) // // CHECK: invoke void @might_throw() @@ -126,7 +131,7 @@ void use_inline() { // CHECK: call void @"\01?fin$0@0@use_seh_in_inline_func@@"(i8 0, i8* %[[fp]]) // CHECK: ret void // -// CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) +// CHECK: landingpad { i8*, i32 } // CHECK-NEXT: cleanup // CHECK: %[[fp:[^ ]*]] = call i8* @llvm.frameaddress(i32 0) // CHECK: call void @"\01?fin$0@0@use_seh_in_inline_func@@"(i8 1, i8* %[[fp]]) diff --git a/test/CodeGenCXX/init-invariant.cpp b/test/CodeGenCXX/init-invariant.cpp index 45816b28fb65..8af4ae6fde46 100644 --- a/test/CodeGenCXX/init-invariant.cpp +++ b/test/CodeGenCXX/init-invariant.cpp @@ -41,13 +41,13 @@ void e() { static const A a = A(); } -// CHECK: call void @_ZN1AC1Ev({{.*}}* @a) +// CHECK: call void @_ZN1AC1Ev({{.*}}* nonnull @a) // CHECK: call {{.*}}@llvm.invariant.start(i64 4, i8* bitcast ({{.*}} @a to i8*)) -// CHECK: call void @_ZN1BC1Ev({{.*}}* @b) +// CHECK: call void @_ZN1BC1Ev({{.*}}* nonnull @b) // CHECK-NOT: call {{.*}}@llvm.invariant.start(i64 4, i8* bitcast ({{.*}} @b to i8*)) -// CHECK: call void @_ZN1CC1Ev({{.*}}* @c) +// CHECK: call void @_ZN1CC1Ev({{.*}}* nonnull @c) // CHECK-NOT: call {{.*}}@llvm.invariant.start(i64 4, i8* bitcast ({{.*}} @c to i8*)) // CHECK: call i32 @_Z1fv( @@ -55,6 +55,6 @@ void e() { // CHECK: call {{.*}}@llvm.invariant.start(i64 4, i8* bitcast ({{.*}} @d to i8*)) // CHECK-LABEL: define void @_Z1ev( -// CHECK: call void @_ZN1AC1Ev(%struct.A* @_ZZ1evE1a) +// CHECK: call void @_ZN1AC1Ev(%struct.A* nonnull @_ZZ1evE1a) // CHECK: call {{.*}}@llvm.invariant.start(i64 4, i8* bitcast ({{.*}} @_ZZ1evE1a to i8*)) // CHECK-NOT: llvm.invariant.end diff --git a/test/CodeGenCXX/mangle-long-double.cpp b/test/CodeGenCXX/mangle-long-double.cpp new file mode 100644 index 000000000000..e248c474a2e7 --- /dev/null +++ b/test/CodeGenCXX/mangle-long-double.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu %s -emit-llvm -o - | FileCheck %s --check-prefix=POWER64-LINUX +// RUN: %clang_cc1 -triple powerpc-unknown-linux-gnu %s -emit-llvm -o - | FileCheck %s --check-prefix=POWER-LINUX +// RUN: %clang_cc1 -triple powerpc64-apple-darwin9 %s -emit-llvm -o - | FileCheck %s --check-prefix=POWER64-DARWIN +// RUN: %clang_cc1 -triple powerpc-apple-darwin9 %s -emit-llvm -o - | FileCheck %s --check-prefix=POWER-DARWIN +// RUN: %clang_cc1 -triple s390x-unknown-linux-gnu %s -emit-llvm -o - | FileCheck %s --check-prefix=S390X-LINUX + +void f(long double) {} +// POWER64-LINUX: _Z1fg +// POWER-LINUX: _Z1fg +// POWER64-DARWIN: _Z1fe +// POWER-DARWIN: _Z1fe +// S390X-LINUX: _Z1fg diff --git a/test/CodeGenCXX/microsoft-abi-member-pointers.cpp b/test/CodeGenCXX/microsoft-abi-member-pointers.cpp index c12ceae131a6..8cb4a1f8bd24 100755 --- a/test/CodeGenCXX/microsoft-abi-member-pointers.cpp +++ b/test/CodeGenCXX/microsoft-abi-member-pointers.cpp @@ -119,7 +119,7 @@ void (UnspecSingle::*us_f_mp)() = &UnspecSingle::foo; // CHECK: @"\01?v_f_mp@Const@@3P8Virtual@@AEXXZQ2@" = // CHECK: global { i8*, i32, i32 } { i8* bitcast ({{.*}} @"\01?foo@Virtual@@QAEXXZ" to i8*), i32 0, i32 0 }, align 4 // CHECK: @"\01?u_f_mp@Const@@3P8Unspecified@@AEXXZQ2@" = -// CHECK: global { i8*, i32, i32, i32 } { i8* bitcast ({{.*}} @"\01?foo@Unspecified@@QAEXXZ" to i8*), i32 0, i32 12, i32 0 }, align 4 +// CHECK: global { i8*, i32, i32, i32 } { i8* bitcast ({{.*}} @"\01?foo@Unspecified@@QAEXXZ" to i8*), i32 0, i32 0, i32 0 }, align 4 // CHECK: @"\01?us_f_mp@Const@@3P8UnspecSingle@@AEXXZQ2@" = // CHECK: global { i8*, i32, i32, i32 } { i8* bitcast ({{.*}} @"\01?foo@UnspecSingle@@QAEXXZ" to i8*), i32 0, i32 0, i32 0 }, align 4 } @@ -191,11 +191,11 @@ void EmitNonVirtualMemberPointers() { // CHECK: { i8* bitcast (void (%{{.*}}*)* @"\01?foo@Virtual@@QAEXXZ" to i8*), i32 0, i32 0 }, // CHECK: { i8*, i32, i32 }* %{{.*}}, align 4 // CHECK: store { i8*, i32, i32, i32 } -// CHECK: { i8* bitcast (void (%{{.*}}*)* @"\01?foo@Unspecified@@QAEXXZ" to i8*), i32 0, i32 12, i32 0 }, +// CHECK: { i8* bitcast (void (%{{.*}}*)* @"\01?foo@Unspecified@@QAEXXZ" to i8*), i32 0, i32 0, i32 0 }, // CHECK: { i8*, i32, i32, i32 }* %{{.*}}, align 4 // CHECK: store { i8*, i32, i32, i32 } // CHECK: { i8* bitcast (void (%{{.*}}*)* @"\01?foo@UnspecWithVBPtr@@QAEXXZ" to i8*), -// CHECK: i32 0, i32 4, i32 0 }, +// CHECK: i32 0, i32 0, i32 0 }, // CHECK: { i8*, i32, i32, i32 }* %{{.*}}, align 4 // CHECK: ret void // CHECK: } @@ -678,6 +678,17 @@ static_assert(sizeof(int A::*) == 12, ""); // CHECK-LABEL: define void @"\01?test@pr20007_pragma2@@YAXXZ" } +namespace pr23823 { +struct Base { void Method(); }; +struct Child : Base {}; +void use(void (Child::*const &)()); +void f() { use(&Child::Method); } +#pragma pointers_to_members(full_generality, virtual_inheritance) +static_assert(sizeof(int Base::*) == 4, ""); +static_assert(sizeof(int Child::*) == 4, ""); +#pragma pointers_to_members(best_case) +} + namespace pr19987 { template <typename T> struct S { diff --git a/test/CodeGenCXX/microsoft-abi-thread-safe-statics.cpp b/test/CodeGenCXX/microsoft-abi-thread-safe-statics.cpp index 5f6849dde038..89a62c2cb390 100644 --- a/test/CodeGenCXX/microsoft-abi-thread-safe-statics.cpp +++ b/test/CodeGenCXX/microsoft-abi-thread-safe-statics.cpp @@ -17,6 +17,7 @@ struct S { // CHECK-DAG: @"\01?$TSS0@?1??h@@YAAAUS@@_N@Z" = linkonce_odr global i32 0 // CHECK-LABEL: define {{.*}} @"\01?f@@YAAAUS@@XZ"() +// CHECK-SAME: personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) extern inline S &f() { static thread_local S s; // CHECK: %[[guard:.*]] = load i32, i32* @"\01??__J?1??f@@YAAAUS@@XZ@51" @@ -38,7 +39,7 @@ extern inline S &f() { // CHECK-NEXT: ret %struct.S* @"\01?s@?1??f@@YAAAUS@@XZ@4U2@A" // CHECK: [[lpad:.*]]: -// CHECK-NEXT: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) +// CHECK-NEXT: landingpad { i8*, i32 } // CHECK-NEXT: cleanup // CHECK: %[[guard:.*]] = load i32, i32* @"\01??__J?1??f@@YAAAUS@@XZ@51" // CHECK-NEXT: %[[mask:.*]] = and i32 %[[guard]], -2 diff --git a/test/CodeGenCXX/microsoft-abi-virtual-member-pointers.cpp b/test/CodeGenCXX/microsoft-abi-virtual-member-pointers.cpp index f6f75835c658..af930c84720b 100644 --- a/test/CodeGenCXX/microsoft-abi-virtual-member-pointers.cpp +++ b/test/CodeGenCXX/microsoft-abi-virtual-member-pointers.cpp @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm -triple=i386-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK32 -// RUN: %clang_cc1 -fno-rtti -emit-llvm -triple=x86_64-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK64 +// RUN: %clang_cc1 -std=c++11 -fno-rtti -emit-llvm -triple=i386-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK32 +// RUN: %clang_cc1 -std=c++11 -fno-rtti -emit-llvm -triple=x86_64-pc-win32 %s -o - | FileCheck %s --check-prefix=CHECK64 struct S { int x, y, z; @@ -13,12 +13,15 @@ struct U { U(const U &); }; +struct B; + struct C { virtual void foo(); virtual int bar(int, double); virtual S baz(int); virtual S qux(U); virtual void thud(...); + virtual void (B::*plugh())(); }; namespace { @@ -47,6 +50,8 @@ void f() { void (C::*ptr6)(...); ptr6 = &C::thud; + auto ptr7 = &C::plugh; + // CHECK32-LABEL: define void @"\01?f@@YAXXZ"() // CHECK32: store i8* bitcast (void (%struct.C*, ...)* @"\01??_9C@@$BA@AE" to i8*), i8** %ptr @@ -167,4 +172,18 @@ void f() { // CHECK64: ret void // CHECK64: } +// CHECK32: define linkonce_odr x86_thiscallcc void @"\01??_9C@@$BBE@AE"(%struct.C* %this, ...) {{.*}} comdat align 2 { +// CHECK32: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, ...)*, void (%struct.C*, ...)** %{{.*}}, i64 5 +// CHECK32: [[CALLEE:%.*]] = load void (%struct.C*, ...)*, void (%struct.C*, ...)** [[VPTR]] +// CHECK32: musttail call x86_thiscallcc void (%struct.C*, ...) [[CALLEE]](%struct.C* %{{.*}}, ...) +// CHECK32: ret void +// CHECK32: } + +// CHECK64: define linkonce_odr void @"\01??_9C@@$BCI@AA"(%struct.C* %this, ...) {{.*}} comdat align 2 { +// CHECK64: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, ...)*, void (%struct.C*, ...)** %{{.*}}, i64 5 +// CHECK64: [[CALLEE:%.*]] = load void (%struct.C*, ...)*, void (%struct.C*, ...)** [[VPTR]] +// CHECK64: musttail call void (%struct.C*, ...) [[CALLEE]](%struct.C* %{{.*}}, ...) +// CHECK64: ret void +// CHECK64: } + // CHECK32: #[[ATTR]] = {{{.*}}"thunk"{{.*}}} diff --git a/test/CodeGenCXX/microsoft-abi-vmemptr-fastcall.cpp b/test/CodeGenCXX/microsoft-abi-vmemptr-fastcall.cpp index 6d42b8504abf..97ab1996c8bc 100644 --- a/test/CodeGenCXX/microsoft-abi-vmemptr-fastcall.cpp +++ b/test/CodeGenCXX/microsoft-abi-vmemptr-fastcall.cpp @@ -1,11 +1,15 @@ -// RUN: %clang_cc1 -fms-extensions -triple i686-pc-windows-msvc %s -emit-llvm-only -verify - -// We reject this because LLVM doesn't forward the second regparm through the -// thunk. +// RUN: %clang_cc1 -fms-extensions -triple i686-pc-windows-msvc %s -emit-llvm -o - | FileCheck %s struct A { - virtual void __fastcall f(int a, int b); // expected-error {{cannot compile this pointer to fastcall virtual member function yet}} + virtual void __fastcall f(int a, int b); }; void (__fastcall A::*doit())(int, int) { return &A::f; } + +// CHECK: define linkonce_odr x86_fastcallcc void @"\01??_9A@@$BA@AI"(%struct.A* inreg %this, ...) {{.*}} comdat align 2 { +// CHECK: [[VPTR:%.*]] = getelementptr inbounds void (%struct.A*, ...)*, void (%struct.A*, ...)** %{{.*}}, i64 0 +// CHECK: [[CALLEE:%.*]] = load void (%struct.A*, ...)*, void (%struct.A*, ...)** [[VPTR]] +// CHECK: musttail call x86_fastcallcc void (%struct.A*, ...) [[CALLEE]](%struct.A* inreg %{{.*}}, ...) +// CHECK: ret void +// CHECK: } diff --git a/test/CodeGenCXX/mingw-w64-seh-exceptions.cpp b/test/CodeGenCXX/mingw-w64-seh-exceptions.cpp index bacddb2936f4..9025f877c551 100644 --- a/test/CodeGenCXX/mingw-w64-seh-exceptions.cpp +++ b/test/CodeGenCXX/mingw-w64-seh-exceptions.cpp @@ -16,9 +16,11 @@ extern "C" void test() { } // X64: define void @test() +// X64-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_seh0 to i8*) // X64: invoke void @foo() -// X64: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_seh0 to i8*) +// X64: landingpad { i8*, i32 } // X86: define void @test() +// X86-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) // X86: invoke void @foo() -// X86: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) +// X86: landingpad { i8*, i32 } diff --git a/test/CodeGenCXX/nrvo.cpp b/test/CodeGenCXX/nrvo.cpp index f4ed7cd9f6be..8744d141dddc 100644 --- a/test/CodeGenCXX/nrvo.cpp +++ b/test/CodeGenCXX/nrvo.cpp @@ -44,6 +44,7 @@ X test1(bool B) { // CHECK-LABEL: define void @_Z5test2b // CHECK-EH-LABEL: define void @_Z5test2b +// CHECK-EH-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) X test2(bool B) { // No NRVO. @@ -82,7 +83,7 @@ X test2(bool B) { // -> %cleanup, %lpad1 // %lpad: landing pad for ctor of 'y', dtor of 'y' - // CHECK-EH: [[CAUGHTVAL:%.*]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK-EH: [[CAUGHTVAL:%.*]] = landingpad { i8*, i32 } // CHECK-EH-NEXT: cleanup // CHECK-EH-NEXT: extractvalue { i8*, i32 } [[CAUGHTVAL]], 0 // CHECK-EH-NEXT: extractvalue { i8*, i32 } [[CAUGHTVAL]], 1 @@ -116,7 +117,7 @@ X test2(bool B) { // CHECK-EH: resume { i8*, i32 } // %terminate.lpad: terminate landing pad. - // CHECK-EH: [[T0:%.*]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK-EH: [[T0:%.*]] = landingpad { i8*, i32 } // CHECK-EH-NEXT: catch i8* null // CHECK-EH-NEXT: [[T1:%.*]] = extractvalue { i8*, i32 } [[T0]], 0 // CHECK-EH-NEXT: call void @__clang_call_terminate(i8* [[T1]]) [[NR_NUW:#[0-9]+]] @@ -178,9 +179,9 @@ X test6() { // CHECK: [[A:%.*]] = alloca [[X:%.*]], align 8 // CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds %class.X, %class.X* [[A]], i32 0, i32 0 // CHECK-NEXT: call void @llvm.lifetime.start(i64 1, i8* [[PTR]]) - // CHECK-NEXT: call {{.*}} @_ZN1XC1Ev([[X]]* [[A]]) - // CHECK-NEXT: call {{.*}} @_ZN1XC1ERKS_([[X]]* {{%.*}}, [[X]]* dereferenceable({{[0-9]+}}) [[A]]) - // CHECK-NEXT: call {{.*}} @_ZN1XD1Ev([[X]]* [[A]]) + // CHECK-NEXT: call {{.*}} @_ZN1XC1Ev([[X]]* nonnull [[A]]) + // CHECK-NEXT: call {{.*}} @_ZN1XC1ERKS_([[X]]* {{%.*}}, [[X]]* nonnull dereferenceable({{[0-9]+}}) [[A]]) + // CHECK-NEXT: call {{.*}} @_ZN1XD1Ev([[X]]* nonnull [[A]]) // CHECK-NEXT: call void @llvm.lifetime.end(i64 1, i8* [[PTR]]) // CHECK-NEXT: ret void } diff --git a/test/CodeGenCXX/partial-destruction.cpp b/test/CodeGenCXX/partial-destruction.cpp index 01e289450d76..d135149592a1 100644 --- a/test/CodeGenCXX/partial-destruction.cpp +++ b/test/CodeGenCXX/partial-destruction.cpp @@ -12,6 +12,7 @@ namespace test0 { opaque(); } // CHECK-LABEL: define void @_ZN5test04testEv() + // CHECK-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) // CHECK: [[AS:%.*]] = alloca [10 x [[A:%.*]]], align // CHECK-NEXT: [[ENDVAR:%.*]] = alloca [[A]]* // CHECK-NEXT: [[EXN:%.*]] = alloca i8* @@ -50,7 +51,7 @@ namespace test0 { // CHECK: ret void // Partial destroy for initialization. - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: cleanup // CHECK: [[PARTIAL_END:%.*]] = load [[A]]*, [[A]]** [[ENDVAR]] // CHECK-NEXT: [[T0:%.*]] = icmp eq [[A]]* [[E_BEGIN]], [[PARTIAL_END]] @@ -62,7 +63,7 @@ namespace test0 { // CHECK-NEXT: br i1 [[T0]], // Primary EH destructor. - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: cleanup // CHECK: [[E0:%.*]] = getelementptr inbounds [10 x [[A]]], [10 x [[A]]]* [[AS]], i32 0, i32 0 // CHECK-NEXT: [[E_END:%.*]] = getelementptr inbounds [[A]], [[A]]* [[E0]], i64 10 @@ -72,7 +73,7 @@ namespace test0 { // FIXME: There's some really bad block ordering here which causes // the partial destroy for the primary normal destructor to fall // within the primary EH destructor. - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: cleanup // CHECK: [[T0:%.*]] = icmp eq [[A]]* [[ED_BEGIN]], [[ED_CUR]] // CHECK-NEXT: br i1 [[T0]] @@ -99,6 +100,7 @@ namespace test1 { B v = { 5, 6, 7, 8 }; } // CHECK-LABEL: define void @_ZN5test14testEv() + // CHECK-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) // CHECK: [[V:%.*]] = alloca [[B:%.*]], align 4 // CHECK-NEXT: alloca i8* // CHECK-NEXT: alloca i32 @@ -114,9 +116,9 @@ namespace test1 { // CHECK-NEXT: ret void // FIXME: again, the block ordering is pretty bad here - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: cleanup - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: cleanup // CHECK: invoke void @_ZN5test11AD1Ev([[A]]* [[Y]]) // CHECK: invoke void @_ZN5test11AD1Ev([[A]]* [[X]]) @@ -129,6 +131,7 @@ namespace test2 { A v[4][7]; // CHECK-LABEL: define void @_ZN5test24testEv() + // CHECK-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) // CHECK: [[V:%.*]] = alloca [4 x [7 x [[A:%.*]]]], align 1 // CHECK-NEXT: alloca i8* // CHECK-NEXT: alloca i32 @@ -144,7 +147,7 @@ namespace test2 { // CHECK-NEXT: br i1 [[DONE]], // Partial destruction landing pad. - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: cleanup // CHECK: [[EMPTY:%.*]] = icmp eq [[A]]* [[BEGIN]], [[CUR]] // CHECK-NEXT: br i1 [[EMPTY]], diff --git a/test/CodeGenCXX/pragma-loop-safety.cpp b/test/CodeGenCXX/pragma-loop-safety.cpp new file mode 100644 index 000000000000..d12e41274918 --- /dev/null +++ b/test/CodeGenCXX/pragma-loop-safety.cpp @@ -0,0 +1,49 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin -std=c++11 -emit-llvm -o - %s | FileCheck %s + +// Verify assume_safety vectorization is recognized. +void vectorize_test(int *List, int Length) { +// CHECK: define {{.*}} @_Z14vectorize_testPii +// CHECK: [[LOAD1_IV:.+]] = load i32, i32* [[IV1:[^,]+]], {{.*}}!llvm.mem.parallel_loop_access ![[LOOP1_ID:[0-9]+]] +// CHECK-NEXT: [[LOAD1_LEN:.+]] = load i32, i32* [[LEN1:.+]], {{.*}}!llvm.mem.parallel_loop_access ![[LOOP1_ID]] +// CHECK-NEXT: [[CMP1:.+]] = icmp slt i32[[LOAD1_IV]],[[LOAD1_LEN]] +// CHECK-NEXT: br i1[[CMP1]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]], !llvm.loop ![[LOOP1_HINTS:[0-9]+]] +#pragma clang loop vectorize(assume_safety) + for (int i = 0; i < Length; i++) { + // CHECK: [[LOOP1_BODY]] + // CHECK-NEXT: [[RHIV1:.+]] = load i32, i32* [[IV1]], {{.*}}!llvm.mem.parallel_loop_access ![[LOOP1_ID]] + // CHECK-NEXT: [[CALC1:.+]] = mul nsw i32[[RHIV1]], 2 + // CHECK-NEXT: [[SIV1:.+]] = load i32, i32* [[IV1]]{{.*}}!llvm.mem.parallel_loop_access ![[LOOP1_ID]] + // CHECK-NEXT: [[INDEX1:.+]] = sext i32[[SIV1]] to i64 + // CHECK-NEXT: [[ARRAY1:.+]] = load i32*, i32** [[LIST1:.*]], {{.*}}!llvm.mem.parallel_loop_access ![[LOOP1_ID]] + // CHECK-NEXT: [[PTR1:.+]] = getelementptr inbounds i32, i32*[[ARRAY1]], i64[[INDEX1]] + // CHECK-NEXT: store i32[[CALC1]], i32*[[PTR1]], {{.*}}!llvm.mem.parallel_loop_access ![[LOOP1_ID]] + List[i] = i * 2; + } + // CHECK: [[LOOP1_END]] +} + +// Verify assume_safety interleaving is recognized. +void interleave_test(int *List, int Length) { +// CHECK: define {{.*}} @_Z15interleave_testPii +// CHECK: [[LOAD2_IV:.+]] = load i32, i32* [[IV2:[^,]+]], {{.*}}!llvm.mem.parallel_loop_access ![[LOOP2_ID:[0-9]+]] +// CHECK-NEXT: [[LOAD2_LEN:.+]] = load i32, i32* [[LEN2:.+]], {{.*}}!llvm.mem.parallel_loop_access ![[LOOP2_ID]] +// CHECK-NEXT: [[CMP2:.+]] = icmp slt i32[[LOAD2_IV]],[[LOAD2_LEN]] +// CHECK-NEXT: br i1[[CMP2]], label %[[LOOP2_BODY:[^,]+]], label %[[LOOP2_END:[^,]+]], !llvm.loop ![[LOOP2_HINTS:[0-9]+]] +#pragma clang loop interleave(assume_safety) + for (int i = 0; i < Length; i++) { + // CHECK: [[LOOP2_BODY]] + // CHECK-NEXT: [[RHIV2:.+]] = load i32, i32* [[IV2]], {{.*}}!llvm.mem.parallel_loop_access ![[LOOP2_ID]] + // CHECK-NEXT: [[CALC2:.+]] = mul nsw i32[[RHIV2]], 2 + // CHECK-NEXT: [[SIV2:.+]] = load i32, i32* [[IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[LOOP2_ID]] + // CHECK-NEXT: [[INDEX2:.+]] = sext i32[[SIV2]] to i64 + // CHECK-NEXT: [[ARRAY2:.+]] = load i32*, i32** [[LIST2:.*]], {{.*}}!llvm.mem.parallel_loop_access ![[LOOP2_ID]] + // CHECK-NEXT: [[PTR2:.+]] = getelementptr inbounds i32, i32*[[ARRAY2]], i64[[INDEX2]] + // CHECK-NEXT: store i32[[CALC2]], i32*[[PTR2]], {{.*}}!llvm.mem.parallel_loop_access ![[LOOP2_ID]] + List[i] = i * 2; + } + // CHECK: [[LOOP2_END]] +} + +// CHECK: ![[LOOP1_HINTS]] = distinct !{![[LOOP1_HINTS]], ![[INTENABLE_1:.*]]} +// CHCCK: ![[INTENABLE_1]] = !{!"llvm.loop.vectorize.enable", i1 true} +// CHECK: ![[LOOP2_HINTS]] = distinct !{![[LOOP2_HINTS]], ![[INTENABLE_1:.*]]} diff --git a/test/CodeGenCXX/redefine_extname.cpp b/test/CodeGenCXX/redefine_extname.cpp new file mode 100644 index 000000000000..2b6b703a1b8f --- /dev/null +++ b/test/CodeGenCXX/redefine_extname.cpp @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -triple=i386-pc-solaris2.11 -w -emit-llvm %s -o - | FileCheck %s + +extern "C" { + struct statvfs64 { + int f; + }; +#pragma redefine_extname statvfs64 statvfs + int statvfs64(struct statvfs64 *); +} + +void foo() { + struct statvfs64 st; + statvfs64(&st); +// Check that even if there is a structure with redefined name before the +// pragma, subsequent function name redefined properly. PR5172, Comment 11. +// CHECK: call i32 @statvfs(%struct.statvfs64* %st) +} + diff --git a/test/CodeGenCXX/stack-reuse.cpp b/test/CodeGenCXX/stack-reuse.cpp index a975f30a048a..473a57cda27d 100644 --- a/test/CodeGenCXX/stack-reuse.cpp +++ b/test/CodeGenCXX/stack-reuse.cpp @@ -134,8 +134,8 @@ int large_combiner_test(S_large s) { // CHECK-LABEL: define i32 @large_combiner_test // CHECK: [[T1:%.*]] = alloca %struct.Combiner // CHECK: [[T2:%.*]] = alloca %struct.Combiner -// CHECK: [[T3:%.*]] = call %struct.Combiner* @_ZN8CombinerC1E7S_large(%struct.Combiner* [[T1]], [9 x i32] %s.coerce) -// CHECK: call void @_ZN8Combiner1fEv(%struct.Combiner* sret [[T2]], %struct.Combiner* [[T1]]) +// CHECK: [[T3:%.*]] = call %struct.Combiner* @_ZN8CombinerC1E7S_large(%struct.Combiner* nonnull [[T1]], [9 x i32] %s.coerce) +// CHECK: call void @_ZN8Combiner1fEv(%struct.Combiner* nonnull sret [[T2]], %struct.Combiner* nonnull [[T1]]) // CHECK: [[T4:%.*]] = getelementptr inbounds %struct.Combiner, %struct.Combiner* [[T2]], i32 0, i32 0, i32 0, i32 0 // CHECK: [[T5:%.*]] = load i32, i32* [[T4]] // CHECK: ret i32 [[T5]] diff --git a/test/CodeGenCXX/threadsafe-statics-exceptions.cpp b/test/CodeGenCXX/threadsafe-statics-exceptions.cpp index 70decc98a109..41325fa64fc5 100644 --- a/test/CodeGenCXX/threadsafe-statics-exceptions.cpp +++ b/test/CodeGenCXX/threadsafe-statics-exceptions.cpp @@ -8,6 +8,7 @@ struct X { struct Y { }; // CHECK-LABEL: define void @_Z1fv +// CHECK-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) void f() { // CHECK: call i32 @__cxa_guard_acquire(i64* @_ZGVZ1fvE1x) // CHECK: invoke void @_ZN1XC1Ev @@ -21,7 +22,7 @@ void f() { throw Y(); // Finally, the landing pad. - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK: cleanup // CHECK: call void @__cxa_guard_abort(i64* @_ZGVZ1fvE1x) // CHECK: resume { i8*, i32 } diff --git a/test/CodeGenCXX/typeid.cpp b/test/CodeGenCXX/typeid.cpp index 9d212905e614..364f058c5b70 100644 --- a/test/CodeGenCXX/typeid.cpp +++ b/test/CodeGenCXX/typeid.cpp @@ -31,13 +31,14 @@ const std::type_info &a_ti = typeid(a); const std::type_info &A10_c_ti = typeid(char const[10]); // CHECK-LABEL: define i8* @_ZN5Test11fEv +// CHECK-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) const char *f() { try { // CHECK: br i1 // CHECK: invoke void @__cxa_bad_typeid() [[NR:#[0-9]+]] return typeid(*static_cast<A *>(0)).name(); } catch (...) { - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: catch i8* null } diff --git a/test/CodeGenCXX/windows-itanium-exceptions.cpp b/test/CodeGenCXX/windows-itanium-exceptions.cpp index 3694d2c81371..b2c8707efc06 100644 --- a/test/CodeGenCXX/windows-itanium-exceptions.cpp +++ b/test/CodeGenCXX/windows-itanium-exceptions.cpp @@ -20,7 +20,8 @@ void attempt() { // CHECK: unreachable // CHECK: } -// CHECK: define {{.*}}void @_Z7attemptv() {{.*}} { +// CHECK: define {{.*}}void @_Z7attemptv() +// CHECK-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) // CHECK: %exn.slot = alloca i8* // CHECK: %ehselector.slot = alloca i32 // CHECK: invoke {{.*}}void @_Z6exceptv() @@ -28,7 +29,7 @@ void attempt() { // CHECK: invoke.cont: // CHECK: br label %try.cont // CHECK: lpad: -// CHECK: %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) +// CHECK: %0 = landingpad { i8*, i32 } // CHECK: catch i8* null // CHECK: %1 = extractvalue { i8*, i32 } %0, 0 // CHECK: store i8* %1, i8** %exn.slot diff --git a/test/CodeGenObjC/autorelease.m b/test/CodeGenObjC/autorelease.m index 6bb80fd2bd8f..ab65f8088d1f 100644 --- a/test/CodeGenObjC/autorelease.m +++ b/test/CodeGenObjC/autorelease.m @@ -46,7 +46,7 @@ int tryTo(int (*f)(void)) { // CHECK-NEXT: [[T2:%.*]] = invoke i32 [[T1]]() // CHECK: store i32 [[T2]], i32* [[RET]] // CHECK: invoke void @objc_autoreleasePoolPop(i8* [[T0]]) -// CHECK: landingpad { i8*, i32 } personality +// CHECK: landingpad { i8*, i32 } // CHECK-NEXT: catch i8* null // CHECK: call i8* @objc_begin_catch // CHECK-NEXT: store i32 0, i32* [[RET]] diff --git a/test/CodeGenObjC/blocks-2.m b/test/CodeGenObjC/blocks-2.m index 0c6bd562b539..b9562ad6d64e 100644 --- a/test/CodeGenObjC/blocks-2.m +++ b/test/CodeGenObjC/blocks-2.m @@ -30,7 +30,7 @@ void test1() { // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T1]], i32 8) // CHECK-NEXT: ret void - // CHECK: landingpad { i8*, i32 } personality + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: cleanup // CHECK: [[T1:%.*]] = bitcast [[N_T]]* [[N]] to i8* // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T1]], i32 8) diff --git a/test/CodeGenObjC/exceptions.m b/test/CodeGenObjC/exceptions.m index f27892dc7893..075b714f29e2 100644 --- a/test/CodeGenObjC/exceptions.m +++ b/test/CodeGenObjC/exceptions.m @@ -55,14 +55,14 @@ int f2() { @try { // CHECK: store i32 6, i32* [[X]] x++; - // CHECK-NEXT: call void asm sideeffect "", "*m,*m"(i32* [[X]] + // CHECK-NEXT: call void asm sideeffect "", "*m,*m"(i32* nonnull [[X]] // CHECK-NEXT: call void @foo() // CHECK-NEXT: call void @objc_exception_try_exit // CHECK-NEXT: [[T:%.*]] = load i32, i32* [[X]] foo(); } @catch (id) { // Landing pad. Note that we elide the re-enter. - // CHECK: call void asm sideeffect "", "=*m,=*m"(i32* [[X]] + // CHECK: call void asm sideeffect "", "=*m,=*m"(i32* nonnull [[X]] // CHECK-NEXT: call i8* @objc_exception_extract // CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[X]] // CHECK-NEXT: [[T2:%.*]] = add nsw i32 [[T1]], -1 @@ -93,7 +93,7 @@ void f3() { // CHECK-NEXT: br i1 @try { - // CHECK: call void @f3_helper(i32 0, i32* [[X]]) + // CHECK: call void @f3_helper(i32 0, i32* nonnull [[X]]) // CHECK: call void @objc_exception_try_exit( f3_helper(0, &x); } @finally { @@ -101,12 +101,12 @@ void f3() { // CHECK: call void @objc_exception_try_enter // CHECK: call i32 @_setjmp @try { - // CHECK: call void @f3_helper(i32 1, i32* [[X]]) + // CHECK: call void @f3_helper(i32 1, i32* nonnull [[X]]) // CHECK: call void @objc_exception_try_exit( f3_helper(1, &x); } @finally { // CHECK: [[DEST2:%.*]] = phi i32 [ 0, {{%.*}} ], [ 5, {{%.*}} ] - // CHECK: call void @f3_helper(i32 2, i32* [[X]]) + // CHECK: call void @f3_helper(i32 2, i32* nonnull [[X]]) f3_helper(2, &x); // This loop is large enough to dissuade the optimizer from just @@ -123,7 +123,7 @@ void f3() { // CHECK: [[DEST1]] } - // CHECK: call void @f3_helper(i32 4, i32* [[X]]) + // CHECK: call void @f3_helper(i32 4, i32* nonnull [[X]]) // CHECK-NEXT: call void @llvm.lifetime.end(i64 4, i8* [[XPTR]]) // CHECK-NEXT: ret void f3_helper(4, &x); @@ -135,7 +135,7 @@ void f4() { // CHECK-LABEL: define void @f4() // CHECK: [[EXNDATA:%.*]] = alloca [[EXNDATA_T:%.*]], align - // CHECK: call void @objc_exception_try_enter([[EXNDATA_T]]* [[EXNDATA]]) + // CHECK: call void @objc_exception_try_enter([[EXNDATA_T]]* nonnull [[EXNDATA]]) // CHECK: call i32 @_setjmp @try { // CHECK: call void @f4_help(i32 0) @@ -144,7 +144,7 @@ void f4() { // The finally cleanup has two threaded entrypoints after optimization: // finally.no-call-exit: Predecessor is when the catch throws. - // CHECK: call i8* @objc_exception_extract([[EXNDATA_T]]* [[EXNDATA]]) + // CHECK: call i8* @objc_exception_extract([[EXNDATA_T]]* nonnull [[EXNDATA]]) // CHECK-NEXT: call void @f4_help(i32 2) // CHECK-NEXT: br label // -> rethrow @@ -154,7 +154,7 @@ void f4() { // to rethrow and should be true only in the last case. // CHECK: phi i8* // CHECK-NEXT: phi i1 - // CHECK-NEXT: call void @objc_exception_try_exit([[EXNDATA_T]]* [[EXNDATA]]) + // CHECK-NEXT: call void @objc_exception_try_exit([[EXNDATA_T]]* nonnull [[EXNDATA]]) // CHECK-NEXT: call void @f4_help(i32 2) // CHECK-NEXT: br i1 // -> ret, rethrow @@ -163,8 +163,8 @@ void f4() { // CHECK: ret void // Catch mechanism: - // CHECK: call i8* @objc_exception_extract([[EXNDATA_T]]* [[EXNDATA]]) - // CHECK-NEXT: call void @objc_exception_try_enter([[EXNDATA_T]]* [[EXNDATA]]) + // CHECK: call i8* @objc_exception_extract([[EXNDATA_T]]* nonnull [[EXNDATA]]) + // CHECK-NEXT: call void @objc_exception_try_enter([[EXNDATA_T]]* nonnull [[EXNDATA]]) // CHECK: call i32 @_setjmp // -> next, finally.no-call-exit // CHECK: call i32 @objc_exception_match diff --git a/test/CodeGenObjC/gnu-exceptions.m b/test/CodeGenObjC/gnu-exceptions.m index 82eb6cb7bd5f..76e9e1ded3c4 100644 --- a/test/CodeGenObjC/gnu-exceptions.m +++ b/test/CodeGenObjC/gnu-exceptions.m @@ -6,7 +6,8 @@ void log(int i); @class C; -// CHECK: define void @test0() [[TF:#[0-9]+]] { +// CHECK: define void @test0() [[TF:#[0-9]+]] +// CHECK-SAME: personality i8* bitcast (i32 (...)* @__gnu_objc_personality_v0 to i8*) void test0() { @try { // CHECK: invoke void @opaque() @@ -15,7 +16,7 @@ void test0() { // CHECK: call void @log(i32 1) } @catch (C *c) { - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gnu_objc_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: catch i8* getelementptr inbounds ([2 x i8], [2 x i8]* @0, i64 0, i64 0) // CHECK: br i1 diff --git a/test/CodeGenObjC/objc-asm-attribute-test.m b/test/CodeGenObjC/objc-asm-attribute-test.m index 589b08ae0eef..7b3a64deb74c 100644 --- a/test/CodeGenObjC/objc-asm-attribute-test.m +++ b/test/CodeGenObjC/objc-asm-attribute-test.m @@ -13,10 +13,19 @@ __attribute__((objc_runtime_name("MySecretNamespace.Protocol2"))) + (void) ClsMethodP2; @end +__attribute__((objc_runtime_name("MySecretNamespace.Protocol3"))) +@protocol Protocol3 +@end + __attribute__((objc_runtime_name("MySecretNamespace.Message"))) @interface Message <Protocol, Protocol2> { id MyIVAR; } + +@property(retain) Message *msgProp; +@property(retain) Message<Protocol3> *msgProtoProp; +@property(retain) id<Protocol3> idProtoProp; + @end @implementation Message @@ -46,9 +55,14 @@ id Test16877359() { return [SLREarth alloc]; } -// CHECK: @"OBJC_IVAR_$_MySecretNamespace.Message.MyIVAR" = global i64 +// CHECK: @"OBJC_IVAR_$_MySecretNamespace.Message.MyIVAR" = global i64 0 // CHECK: @"OBJC_CLASS_$_MySecretNamespace.Message" = global %struct._class_t // CHECK: @"OBJC_METACLASS_$_MySecretNamespace.Message" = global %struct._class_t + +// CHECK: private global [42 x i8] c"T@\22MySecretNamespace.Message\22,&,V_msgProp\00" +// CHECK: private global [76 x i8] c"T@\22MySecretNamespace.Message<MySecretNamespace.Protocol3>\22,&,V_msgProtoProp\00" +// CHECK: private global [50 x i8] c"T@\22<MySecretNamespace.Protocol3>\22,&,V_idProtoProp\00" + // CHECK: @"OBJC_CLASS_$_foo" = external global %struct._class_t // CHECK: define internal i8* @"\01-[Message MyMethod]" // CHECK: [[IVAR:%.*]] = load i64, i64* @"OBJC_IVAR_$_MySecretNamespace.Message.MyIVAR" diff --git a/test/CodeGenObjC/synchronized.m b/test/CodeGenObjC/synchronized.m index 212d98a6bc81..0ce179ccc036 100644 --- a/test/CodeGenObjC/synchronized.m +++ b/test/CodeGenObjC/synchronized.m @@ -32,7 +32,7 @@ void foo(id a) { // CHECK: call i32 @_setjmp @synchronized(a) { // This is unreachable, but the optimizers can't know that. - // CHECK: call void asm sideeffect "", "=*m,=*m,=*m"(i8** [[A]], i8** [[SYNC]] + // CHECK: call void asm sideeffect "", "=*m,=*m,=*m"(i8** nonnull [[A]], i8** nonnull [[SYNC]] // CHECK: call i32 @objc_sync_exit // CHECK: call i8* @objc_exception_extract // CHECK: call void @objc_exception_throw diff --git a/test/CodeGenObjC/terminate.m b/test/CodeGenObjC/terminate.m index 4992b998b395..a756bfba417c 100644 --- a/test/CodeGenObjC/terminate.m +++ b/test/CodeGenObjC/terminate.m @@ -10,20 +10,22 @@ void test0(void) { test0_helper(); // CHECK-WITH-LABEL: define void @test0() + // CHECK-WITH-SAME: personality i8* bitcast (i32 (...)* @__gcc_personality_v0 to i8*) // CHECK-WITH: [[PTR:%.*]] = alloca i8*, // CHECK-WITH: call void @destroy(i8** [[PTR]]) // CHECK-WITH-NEXT: ret void // CHECK-WITH: invoke void @destroy(i8** [[PTR]]) - // CHECK-WITH: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gcc_personality_v0 to i8*) + // CHECK-WITH: landingpad { i8*, i32 } // CHECK-WITH-NEXT: catch i8* null // CHECK-WITH-NEXT: call void @objc_terminate() // CHECK-WITHOUT-LABEL: define void @test0() + // CHECK-WITHOUT-SAME: personality i8* bitcast (i32 (...)* @__gcc_personality_v0 to i8*) // CHECK-WITHOUT: [[PTR:%.*]] = alloca i8*, // CHECK-WITHOUT: call void @destroy(i8** [[PTR]]) // CHECK-WITHOUT-NEXT: ret void // CHECK-WITHOUT: invoke void @destroy(i8** [[PTR]]) - // CHECK-WITHOUT: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gcc_personality_v0 to i8*) + // CHECK-WITHOUT: landingpad { i8*, i32 } // CHECK-WITHOUT-NEXT: catch i8* null // CHECK-WITHOUT-NEXT: call void @abort() } diff --git a/test/CodeGenObjCXX/catch-id-type.mm b/test/CodeGenObjCXX/catch-id-type.mm index 0a2b940ff16e..aa861cb68060 100644 --- a/test/CodeGenObjCXX/catch-id-type.mm +++ b/test/CodeGenObjCXX/catch-id-type.mm @@ -30,7 +30,7 @@ id FUNC() { } catch( id error ) { - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: catch i8* bitcast ({ i8*, i8*, i32, i8* }* @_ZTIPU11objcproto1P4INTF to i8*) // CHECK-NEXT: catch i8* bitcast ({ i8*, i8*, i32, i8* }* @_ZTIP11objc_object to i8*) // CHECK-NEXT: catch i8* bitcast ({ i8*, i8*, i32, i8* }* @_ZTIP10objc_class to i8*) diff --git a/test/CodeGenObjCXX/debug-info-cyclic.mm b/test/CodeGenObjCXX/debug-info-cyclic.mm index 8983fe511204..37a8064baaf1 100644 --- a/test/CodeGenObjCXX/debug-info-cyclic.mm +++ b/test/CodeGenObjCXX/debug-info-cyclic.mm @@ -1,12 +1,13 @@ // RUN: %clang_cc1 -triple x86_64-apple-darwin -g -emit-llvm %s -o - | FileCheck %s struct B { -// CHECK: ![[B:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "B" +// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "B" // CHECK-SAME: line: [[@LINE-2]], // CHECK-SAME: size: 8, align: 8, // CHECK-NOT: offset: // CHECK-NOT: DIFlagFwdDecl // CHECK-SAME: elements: ![[BMEMBERS:[0-9]+]] +// CHECK-SAME: identifier: [[B:.*]]) // CHECK: ![[BMEMBERS]] = !{![[BB:[0-9]+]]} B(struct A *); // CHECK: ![[BB]] = !DISubprogram(name: "B", scope: ![[B]] diff --git a/test/CodeGenObjCXX/exceptions-legacy.mm b/test/CodeGenObjCXX/exceptions-legacy.mm index f6cd29647eea..dac259d91cb5 100644 --- a/test/CodeGenObjCXX/exceptions-legacy.mm +++ b/test/CodeGenObjCXX/exceptions-legacy.mm @@ -15,7 +15,7 @@ void test0(id obj) { // CHECK-LABEL: define void @_Z5test0P11objc_object( // Enter the @synchronized block. // CHECK: call i32 @objc_sync_enter(i8* [[OBJ:%.*]]) -// CHECK: call void @objc_exception_try_enter([[BUF_T:%.*]]* [[BUF:%.*]]) +// CHECK: call void @objc_exception_try_enter([[BUF_T:%.*]]* nonnull [[BUF:%.*]]) // CHECK-NEXT: [[T0:%.*]] = getelementptr [[BUF_T]], [[BUF_T]]* [[BUF]], i32 0, i32 0, i32 0 // CHECK-NEXT: [[T1:%.*]] = call i32 @_setjmp(i32* [[T0]]) // CHECK-NEXT: [[T2:%.*]] = icmp eq i32 [[T1]], 0 @@ -25,7 +25,7 @@ void test0(id obj) { // CHECK: invoke void @_Z3foov() // Leave the @synchronized. The reload of obj here is unnecessary. -// CHECK: call void @objc_exception_try_exit([[BUF_T]]* [[BUF]]) +// CHECK: call void @objc_exception_try_exit([[BUF_T]]* nonnull [[BUF]]) // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** // CHECK-NEXT: call i32 @objc_sync_exit(i8* [[T0]]) // CHECK-NEXT: ret void @@ -33,7 +33,7 @@ void test0(id obj) { // Real EH cleanup. // CHECK: [[T0:%.*]] = landingpad // CHECK-NEXT: cleanup -// CHECK-NEXT: call void @objc_exception_try_exit([[BUF_T]]* [[BUF]]) +// CHECK-NEXT: call void @objc_exception_try_exit([[BUF_T]]* nonnull [[BUF]]) // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** // CHECK-NEXT: call i32 @objc_sync_exit(i8* [[T0]]) // CHECK-NEXT: resume @@ -41,7 +41,7 @@ void test0(id obj) { // ObjC EH "cleanup". // CHECK: [[T0:%.*]] = load i8*, i8** // CHECK-NEXT: call i32 @objc_sync_exit(i8* [[T0]]) -// CHECK-NEXT: [[T0:%.*]] = call i8* @objc_exception_extract([[BUF_T]]* [[BUF]]) +// CHECK-NEXT: [[T0:%.*]] = call i8* @objc_exception_extract([[BUF_T]]* nonnull [[BUF]]) // CHECK-NEXT: call void @objc_exception_throw(i8* [[T0]]) // CHECK-NEXT: unreachable @@ -54,7 +54,7 @@ void test1(id obj, bool *failed) { } // CHECK-LABEL: define void @_Z5test1P11objc_objectPb( // Enter the @try block. -// CHECK: call void @objc_exception_try_enter([[BUF_T]]* [[BUF:%.*]]) +// CHECK: call void @objc_exception_try_enter([[BUF_T]]* nonnull [[BUF:%.*]]) // CHECK-NEXT: [[T0:%.*]] = getelementptr [[BUF_T]], [[BUF_T]]* [[BUF]], i32 0, i32 0, i32 0 // CHECK-NEXT: [[T1:%.*]] = call i32 @_setjmp(i32* [[T0]]) // CHECK-NEXT: [[T2:%.*]] = icmp eq i32 [[T1]], 0 @@ -64,14 +64,14 @@ void test1(id obj, bool *failed) { // CHECK: invoke void @_Z3foov() // Leave the @try. -// CHECK: call void @objc_exception_try_exit([[BUF_T]]* [[BUF]]) +// CHECK: call void @objc_exception_try_exit([[BUF_T]]* nonnull [[BUF]]) // CHECK-NEXT: br label // CHECK: ret void // Real EH cleanup. // CHECK: [[T0:%.*]] = landingpad // CHECK-NEXT: cleanup -// CHECK-NEXT: call void @objc_exception_try_exit([[BUF_T]]* [[BUF]]) +// CHECK-NEXT: call void @objc_exception_try_exit([[BUF_T]]* nonnull [[BUF]]) // CHECK-NEXT: resume // Catch handler. Reload of 'failed' address is unnecessary. diff --git a/test/CodeGenObjCXX/exceptions.mm b/test/CodeGenObjCXX/exceptions.mm index a62a82b08cbd..ef25f359e8bd 100644 --- a/test/CodeGenObjCXX/exceptions.mm +++ b/test/CodeGenObjCXX/exceptions.mm @@ -6,12 +6,13 @@ void opaque(); namespace test0 { // CHECK-LABEL: define void @_ZN5test03fooEv + // CHECK-SAME: personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) void foo() { try { // CHECK: invoke void @_Z6opaquev opaque(); } catch (OCType *T) { - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) + // CHECK: landingpad { i8*, i32 } // CHECK-NEXT: catch %struct._objc_typeinfo* @"OBJC_EHTYPE_$_OCType" } } diff --git a/test/CoverageMapping/control-flow-macro.c b/test/CoverageMapping/control-flow-macro.c new file mode 100644 index 000000000000..149cb5572cb0 --- /dev/null +++ b/test/CoverageMapping/control-flow-macro.c @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only %s | FileCheck %s + +#define ifc if + +// CHECK: main +// CHECK-NEXT: File 0, {{[0-9]+}}:40 -> [[END:[0-9]+]]:2 = #0 +int main(int argc, const char *argv[]) { + // CHECK: Expansion,File 0, [[@LINE+1]]:3 -> [[@LINE+1]]:6 = #0 + ifc(1) return 0; + // Expansion,File 0, [[@LINE+2]]:3 -> [[@LINE+2]]:6 = (#0 - #1) + // File 0, [[@LINE+1]]:6 -> [[END]]:2 = (#0 - #1) + ifc(1) return 0; + return 0; +} diff --git a/test/Driver/aarch64-cpus.c b/test/Driver/aarch64-cpus.c index 43e3ccd45937..4d4e1bcb693c 100644 --- a/test/Driver/aarch64-cpus.c +++ b/test/Driver/aarch64-cpus.c @@ -109,5 +109,24 @@ // RUN: %clang -target aarch64 -mbig-endian -march=armv8.1-a -### -c %s 2>&1 | FileCheck -check-prefix=GENERICV81A-BE %s // RUN: %clang -target aarch64_be -mbig-endian -march=armv8.1a -### -c %s 2>&1 | FileCheck -check-prefix=GENERICV81A-BE %s // RUN: %clang -target aarch64_be -mbig-endian -march=armv8.1-a -### -c %s 2>&1 | FileCheck -check-prefix=GENERICV81A-BE %s +// ================== Check whether -march accepts mixed-case values. +// RUN: %clang -target aarch64_be -march=ARMV8.1A -### -c %s 2>&1 | FileCheck -check-prefix=GENERICV81A-BE %s +// RUN: %clang -target aarch64_be -march=ARMV8.1-A -### -c %s 2>&1 | FileCheck -check-prefix=GENERICV81A-BE %s +// RUN: %clang -target aarch64 -mbig-endian -march=Armv8.1A -### -c %s 2>&1 | FileCheck -check-prefix=GENERICV81A-BE %s +// RUN: %clang -target aarch64 -mbig-endian -march=Armv8.1-A -### -c %s 2>&1 | FileCheck -check-prefix=GENERICV81A-BE %s +// RUN: %clang -target aarch64_be -mbig-endian -march=ARMv8.1a -### -c %s 2>&1 | FileCheck -check-prefix=GENERICV81A-BE %s +// RUN: %clang -target aarch64_be -mbig-endian -march=ARMV8.1-a -### -c %s 2>&1 | FileCheck -check-prefix=GENERICV81A-BE %s // GENERICV81A-BE: "-cc1"{{.*}} "-triple" "aarch64_be{{.*}}" "-target-cpu" "generic" "-target-feature" "+neon" "-target-feature" "+v8.1a" +// ================== Check whether -mcpu accepts mixed-case values. +// RUN: %clang -target aarch64 -mcpu=Cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=CASE-INSENSITIVE-CA53 %s +// CASE-INSENSITIVE-CA53: "-cc1"{{.*}} "-triple" "aarch64{{.*}}" "-target-cpu" "cortex-a53" + +// RUN: %clang -target arm64 -mcpu=cortex-A53 -### -c %s 2>&1 | FileCheck -check-prefix=CASE-INSENSITIVE-ARM64-CA53 %s +// CASE-INSENSITIVE-ARM64-CA53: "-cc1"{{.*}} "-triple" "arm64{{.*}}" "-target-cpu" "cortex-a53" + +// RUN: %clang -target aarch64 -mcpu=CORTEX-A57 -### -c %s 2>&1 | FileCheck -check-prefix=CASE-INSENSITIVE-CA57 %s +// CASE-INSENSITIVE-CA57: "-cc1"{{.*}} "-triple" "aarch64{{.*}}" "-target-cpu" "cortex-a57" + +// RUN: %clang -target arm64 -mcpu=Cortex-A57 -### -c %s 2>&1 | FileCheck -check-prefix=CASE-INSENSITIVE-ARM64-CA57 %s +// CASE-INSENSITIVE-ARM64-CA57: "-cc1"{{.*}} "-triple" "arm64{{.*}}" "-target-cpu" "cortex-a57" diff --git a/test/Driver/arm-cortex-cpus.c b/test/Driver/arm-cortex-cpus.c index b9db9622dd83..ef3056deb5f8 100644 --- a/test/Driver/arm-cortex-cpus.c +++ b/test/Driver/arm-cortex-cpus.c @@ -402,3 +402,12 @@ // RUN: %clang -target arm-linux-gnueabi -mcpu=CorteX-a15 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CASE-INSENSITIVE-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=CorteX-A17 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CASE-INSENSITIVE-CPUV7A %s // CHECK-CASE-INSENSITIVE-CPUV7A: "-cc1"{{.*}} "-triple" "armv7-{{.*}} + +// ================== Check whether -march accepts mixed-case values. +// RUN: %clang -target arm -march=Armv5 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CASE-INSENSITIVE-V5 %s +// RUN: %clang -target arm -march=ARMV5 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CASE-INSENSITIVE-V5 %s +// CHECK-CASE-INSENSITIVE-V5: "-cc1"{{.*}} "-triple" "armv5-{{.*}} "-target-cpu" "arm10tdmi" + +// RUN: %clang -target arm -march=Armv6t2 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CASE-INSENSITIVE-V6T2-THUMB %s +// RUN: %clang -target arm -march=ARMV6T2 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CASE-INSENSITIVE-V6T2-THUMB %s +// CHECK-CASE-INSENSITIVE-V6T2-THUMB: "-cc1"{{.*}} "-triple" "thumbv6t2-{{.*}} "-target-cpu" "arm1156t2-s" diff --git a/test/Driver/asan.c b/test/Driver/asan.c index f199e904e758..4db103d26462 100644 --- a/test/Driver/asan.c +++ b/test/Driver/asan.c @@ -1,8 +1,13 @@ -// RUN: %clang -target i386-unknown-unknown -fsanitize=address %s -S -emit-llvm -o - | FileCheck %s -// RUN: %clang -O1 -target i386-unknown-unknown -fsanitize=address %s -S -emit-llvm -o - | FileCheck %s -// RUN: %clang -O2 -target i386-unknown-unknown -fsanitize=address %s -S -emit-llvm -o - | FileCheck %s -// RUN: %clang -O3 -target i386-unknown-unknown -fsanitize=address %s -S -emit-llvm -o - | FileCheck %s -// Verify that -fsanitize=address invokes asan instrumentation. +// RUN: %clang -target i386-unknown-linux -fsanitize=address %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-ASAN +// RUN: %clang -O1 -target i386-unknown-linux -fsanitize=address %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-ASAN +// RUN: %clang -O2 -target i386-unknown-linux -fsanitize=address %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-ASAN +// RUN: %clang -O3 -target i386-unknown-linux -fsanitize=address %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-ASAN +// RUN: %clang -target i386-unknown-linux -fsanitize=kernel-address %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-KASAN +// RUN: %clang -O1 -target i386-unknown-linux -fsanitize=kernel-address %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-KASAN +// RUN: %clang -O2 -target i386-unknown-linux -fsanitize=kernel-address %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-KASAN +// RUN: %clang -O3 -target i386-unknown-linux -fsanitize=kernel-address %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-KASAN +// Verify that -fsanitize={address,kernel-address} invoke ASan and KASan instrumentation. int foo(int *a) { return *a; } -// CHECK: __asan_init +// CHECK-ASAN: __asan_init +// CHECK-KASAN: __asan_load4_noabort diff --git a/test/Driver/cl-options.c b/test/Driver/cl-options.c index 244e6869d0d5..a1145f106db0 100644 --- a/test/Driver/cl-options.c +++ b/test/Driver/cl-options.c @@ -204,10 +204,11 @@ // NOSTRICT: "-relaxed-aliasing" // For some warning ids, we can map from MSVC warning to Clang warning. -// RUN: %clang_cl -wd4005 -wd4996 -### -- %s 2>&1 | FileCheck -check-prefix=Wno %s +// RUN: %clang_cl -wd4005 -wd4996 -wd4910 -### -- %s 2>&1 | FileCheck -check-prefix=Wno %s // Wno: "-cc1" // Wno: "-Wno-macro-redefined" // Wno: "-Wno-deprecated-declarations" +// Wno: "-Wno-dllexport-explicit-instantiation-decl" // Ignored options. Check that we don't get "unused during compilation" errors. // RUN: %clang_cl /c \ diff --git a/test/Driver/cl-outputs.c b/test/Driver/cl-outputs.c index b92c82687a9b..3d986db198a3 100644 --- a/test/Driver/cl-outputs.c +++ b/test/Driver/cl-outputs.c @@ -266,9 +266,3 @@ // RUN: %clang_cl /P /Fifoo.x /obar.x -### -- %s 2>&1 | FileCheck -check-prefix=FioRACE2 %s // FioRACE2: "-E" // FioRACE2: "-o" "foo.x" - -// RUN: %clang_cl /c /GL -### -- %s 2>&1 | FileCheck -check-prefix=LTO-DEFAULT %s -// LTO-DEFAULT: "-emit-llvm-bc"{{.*}}"-o" "cl-outputs.obj" - -// RUN: %clang_cl /c /GL /Fofoo -### -- %s 2>&1 | FileCheck -check-prefix=LTO-FO %s -// LTO-FO: "-emit-llvm-bc"{{.*}}"-o" "foo.obj" diff --git a/test/Driver/fsanitize.c b/test/Driver/fsanitize.c index fff59a3480ea..bac12dc7fb5f 100644 --- a/test/Driver/fsanitize.c +++ b/test/Driver/fsanitize.c @@ -1,7 +1,11 @@ +// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -fsanitize-trap=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP +// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -fsanitize-trap=undefined -fno-sanitize-trap=signed-integer-overflow %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP2 +// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -fsanitize-undefined-trap-on-error %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP // RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined-trap -fsanitize-undefined-trap-on-error %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP // RUN: %clang -target x86_64-linux-gnu -fsanitize-undefined-trap-on-error -fsanitize=undefined-trap %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP -// CHECK-UNDEFINED-TRAP: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|object-size|float-cast-overflow|array-bounds|enum|bool|returns-nonnull-attribute|nonnull-attribute),?){17}"}} -// CHECK-UNDEFINED-TRAP: "-fsanitize-undefined-trap-on-error" +// CHECK-UNDEFINED-TRAP: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|object-size|float-cast-overflow|array-bounds|enum|bool|returns-nonnull-attribute|nonnull-attribute|function),?){18}"}} +// CHECK-UNDEFINED-TRAP: "-fsanitize-trap=alignment,array-bounds,bool,enum,float-cast-overflow,float-divide-by-zero,function,integer-divide-by-zero,nonnull-attribute,null,object-size,return,returns-nonnull-attribute,shift-base,shift-exponent,signed-integer-overflow,unreachable,vla-bound" +// CHECK-UNDEFINED-TRAP2: "-fsanitize-trap=alignment,array-bounds,bool,enum,float-cast-overflow,float-divide-by-zero,function,integer-divide-by-zero,nonnull-attribute,null,object-size,return,returns-nonnull-attribute,shift-base,shift-exponent,unreachable,vla-bound" // RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED // CHECK-UNDEFINED: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|function|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|vptr|object-size|float-cast-overflow|array-bounds|enum|bool|returns-nonnull-attribute|nonnull-attribute),?){19}"}} @@ -9,6 +13,9 @@ // RUN: %clang -target x86_64-apple-darwin10 -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-DARWIN // CHECK-UNDEFINED-DARWIN: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|vptr|object-size|float-cast-overflow|array-bounds|enum|bool|returns-nonnull-attribute|nonnull-attribute),?){18}"}} +// RUN: %clang -target i386-unknown-openbsd -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-OPENBSD +// CHECK-UNDEFINED-OPENBSD: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|object-size|float-cast-overflow|array-bounds|enum|bool|returns-nonnull-attribute|nonnull-attribute),?){17}"}} + // RUN: %clang -target x86_64-linux-gnu -fsanitize=integer %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-INTEGER // CHECK-INTEGER: "-fsanitize={{((signed-integer-overflow|unsigned-integer-overflow|integer-divide-by-zero|shift-base|shift-exponent),?){5}"}} @@ -27,11 +34,9 @@ // RUN: %clang -target x86_64-linux-gnu -fsanitize=shift -fno-sanitize=shift-base %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FSANITIZE-SHIFT-PARTIAL // CHECK-FSANITIZE-SHIFT-PARTIAL: "-fsanitize=shift-exponent" -// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -fsanitize-undefined-trap-on-error %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP-ON-ERROR-UNDEF -// CHECK-UNDEFINED-TRAP-ON-ERROR-UNDEF: '-fsanitize=undefined' not allowed with '-fsanitize-undefined-trap-on-error' - -// RUN: %clang -target x86_64-linux-gnu -fsanitize=vptr -fsanitize-undefined-trap-on-error %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP-ON-ERROR-VPTR -// CHECK-UNDEFINED-TRAP-ON-ERROR-VPTR: '-fsanitize=vptr' not allowed with '-fsanitize-undefined-trap-on-error' +// RUN: %clang -target x86_64-linux-gnu -fsanitize=vptr -fsanitize-trap=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-VPTR-TRAP-UNDEF +// RUN: %clang -target x86_64-linux-gnu -fsanitize=vptr -fsanitize-undefined-trap-on-error %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-VPTR-TRAP-UNDEF +// CHECK-VPTR-TRAP-UNDEF: error: invalid argument '-fsanitize=vptr' not allowed with '-fsanitize-trap=undefined' // RUN: %clang -target x86_64-linux-gnu -fsanitize=vptr -fno-rtti %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-VPTR-NO-RTTI // CHECK-VPTR-NO-RTTI: '-fsanitize=vptr' not allowed with '-fno-rtti' @@ -57,6 +62,18 @@ // RUN: %clang -target x86_64-linux-gnu -fsanitize=leak,memory -pie -fno-rtti %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANL-SANM // CHECK-SANL-SANM: '-fsanitize=leak' not allowed with '-fsanitize=memory' +// RUN: %clang -target x86_64-linux-gnu -fsanitize=kernel-address,thread -fno-rtti %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANKA-SANT +// CHECK-SANKA-SANT: '-fsanitize=kernel-address' not allowed with '-fsanitize=thread' + +// RUN: %clang -target x86_64-linux-gnu -fsanitize=kernel-address,memory -pie -fno-rtti %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANKA-SANM +// CHECK-SANKA-SANM: '-fsanitize=kernel-address' not allowed with '-fsanitize=memory' + +// RUN: %clang -target x86_64-linux-gnu -fsanitize=kernel-address,address -fno-rtti %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANKA-SANA +// CHECK-SANKA-SANA: '-fsanitize=kernel-address' not allowed with '-fsanitize=address' + +// RUN: %clang -target x86_64-linux-gnu -fsanitize=kernel-address,leak -pie -fno-rtti %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANKA-SANL +// CHECK-SANKA-SANL: '-fsanitize=kernel-address' not allowed with '-fsanitize=leak' + // RUN: %clang -target x86_64-linux-gnu -fsanitize-memory-track-origins -pie %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ONLY-TRACK-ORIGINS // CHECK-ONLY-TRACK-ORIGINS: warning: argument unused during compilation: '-fsanitize-memory-track-origins' @@ -188,17 +205,29 @@ // RUN: %clang -target x86_64-apple-darwin10 -fsanitize=function -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FSAN-UBSAN-DARWIN // CHECK-FSAN-UBSAN-DARWIN: unsupported option '-fsanitize=function' for target 'x86_64-apple-darwin10' -// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI -// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi-derived-cast -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-DCAST -// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi-unrelated-cast -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-UCAST -// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi-nvcall -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-NVCALL -// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi-vcall -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-VCALL +// RUN: %clang -target armv7-apple-ios7 -miphoneos-version-min=7.0 -fsanitize=address %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN-IOS +// CHECK-ASAN-IOS: unsupported option '-fsanitize=address' for target 'arm-apple-ios7' + +// RUN: %clang -target i386-pc-openbsd -fsanitize=address %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN-OPENBSD +// CHECK-ASAN-OPENBSD: unsupported option '-fsanitize=address' for target 'i386-pc-openbsd' + +// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi -flto -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI +// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi-derived-cast -flto -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-DCAST +// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi-unrelated-cast -flto -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-UCAST +// RUN: %clang -target x86_64-linux-gnu -flto -fsanitize=cfi-nvcall -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-NVCALL +// RUN: %clang -target x86_64-linux-gnu -flto -fsanitize=cfi-vcall -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-VCALL // CHECK-CFI: -emit-llvm-bc{{.*}}-fsanitize=cfi-derived-cast,cfi-unrelated-cast,cfi-nvcall,cfi-vcall // CHECK-CFI-DCAST: -emit-llvm-bc{{.*}}-fsanitize=cfi-derived-cast // CHECK-CFI-UCAST: -emit-llvm-bc{{.*}}-fsanitize=cfi-unrelated-cast // CHECK-CFI-NVCALL: -emit-llvm-bc{{.*}}-fsanitize=cfi-nvcall // CHECK-CFI-VCALL: -emit-llvm-bc{{.*}}-fsanitize=cfi-vcall +// RUN: %clang -target x86_64-linux-gnu -flto -fsanitize=cfi-derived-cast -fno-lto -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-NOLTO +// CHECK-CFI-NOLTO: '-fsanitize=cfi-derived-cast' only allowed with '-flto' + +// RUN: %clang -target x86_64-linux-gnu -fsanitize-trap=address -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN-TRAP +// CHECK-ASAN-TRAP: error: unsupported argument 'address' to option '-fsanitize-trap' + // RUN: %clang_cl -fsanitize=address -c -MDd -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-DEBUGRTL // RUN: %clang_cl -fsanitize=address -c -MTd -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-DEBUGRTL // RUN: %clang_cl -fsanitize=address -c -LDd -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-DEBUGRTL @@ -216,3 +245,15 @@ // RUN: %clang_cl -fsanitize=address -c -MDd -MD -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-RELEASERTL // RUN: %clang_cl -fsanitize=address -c -LDd -LD -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-RELEASERTL // CHECK-ASAN-RELEASERTL-NOT: error: invalid argument + +// RUN: %clang -fno-sanitize=safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=NOSP +// NOSP-NOT: "-fsanitize=safe-stack" + +// RUN: %clang -target x86_64-linux-gnu -fsanitize=safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=SP +// RUN: %clang -target x86_64-linux-gnu -fsanitize=address,safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=SP-ASAN +// RUN: %clang -target x86_64-linux-gnu -fstack-protector -fsanitize=safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=SP +// RUN: %clang -target x86_64-linux-gnu -fsanitize=safe-stack -fstack-protector-all -### %s 2>&1 | FileCheck %s -check-prefix=SP +// SP-NOT: stack-protector +// SP: "-fsanitize=safe-stack" +// SP-ASAN-NOT: stack-protector +// SP-ASAN: "-fsanitize=address,safe-stack" diff --git a/test/Driver/mips-as.c b/test/Driver/mips-as.c index 755ae83576f1..0da1a9e11c05 100644 --- a/test/Driver/mips-as.c +++ b/test/Driver/mips-as.c @@ -281,3 +281,79 @@ // RUN: | FileCheck -check-prefix=NOODDSPREG --implicit-check-not=-modd-spreg %s // NOODDSPREG: as{{(.exe)?}}" // NOODDSPREG: -mno-odd-spreg +// +// RUN: %clang -target mips-linux-gnu -### -no-integrated-as -mdouble-float -msingle-float -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=SINGLEFLOAT --implicit-check-not=-mdouble-float %s +// SINGLEFLOAT: as{{(.exe)?}}" +// SINGLEFLOAT: -msingle-float +// +// RUN: %clang -target mips-linux-gnu -### -no-integrated-as -msingle-float -mdouble-float -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=DOUBLEFLOAT --implicit-check-not=-msingle-float %s +// DOUBLEFLOAT: as{{(.exe)?}}" +// DOUBLEFLOAT: -mdouble-float +// +// RUN: %clang -target mips-linux-gnu -### -no-integrated-as -msoft-float -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=SOFTFLOAT-IMPLICIT-FPXX --implicit-check-not=-mfpxx %s +// SOFTFLOAT-IMPLICIT-FPXX: as{{(.exe)?}}" +// SOFTFLOAT-IMPLICIT-FPXX: -msoft-float +// +// RUN: %clang -target mips-linux-gnu -### -no-integrated-as -msoft-float -mfpxx -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=SOFTFLOAT-EXPLICIT-FPXX %s +// SOFTFLOAT-EXPLICIT-FPXX: as{{(.exe)?}}" +// SOFTFLOAT-EXPLICIT-FPXX: -mfpxx +// SOFTFLOAT-EXPLICIT-FPXX: -msoft-float +// +// RUN: %clang -target mips-mti-linux-gnu -### -no-integrated-as -msoft-float -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=MTI-SOFTFLOAT-IMPLICIT-FPXX --implicit-check-not=-mfpxx %s +// MTI-SOFTFLOAT-IMPLICIT-FPXX: as{{(.exe)?}}" +// MTI-SOFTFLOAT-IMPLICIT-FPXX: -msoft-float +// +// RUN: %clang -target mips-mti-linux-gnu -### -no-integrated-as -msoft-float -mfpxx -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=MTI-SOFTFLOAT-EXPLICIT-FPXX %s +// MTI-SOFTFLOAT-EXPLICIT-FPXX: as{{(.exe)?}}" +// MTI-SOFTFLOAT-EXPLICIT-FPXX: -mfpxx +// MTI-SOFTFLOAT-EXPLICIT-FPXX: -msoft-float +// +// RUN: %clang -target mips-img-linux-gnu -### -no-integrated-as -msoft-float -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=IMG-SOFTFLOAT-IMPLICIT-FPXX --implicit-check-not=-mfpxx %s +// IMG-SOFTFLOAT-IMPLICIT-FPXX: as{{(.exe)?}}" +// IMG-SOFTFLOAT-IMPLICIT-FPXX: -msoft-float +// +// RUN: %clang -target mips-img-linux-gnu -### -no-integrated-as -msoft-float -mfpxx -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=IMG-SOFTFLOAT-EXPLICIT-FPXX %s +// IMG-SOFTFLOAT-EXPLICIT-FPXX: as{{(.exe)?}}" +// IMG-SOFTFLOAT-EXPLICIT-FPXX: -mfpxx +// IMG-SOFTFLOAT-EXPLICIT-FPXX: -msoft-float +// +// RUN: %clang -target mips-linux-gnu -### -no-integrated-as -msingle-float -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=SINGLEFLOAT-IMPLICIT-FPXX --implicit-check-not=-mfpxx %s +// SINGLEFLOAT-IMPLICIT-FPXX: as{{(.exe)?}}" +// SINGLEFLOAT-IMPLICIT-FPXX: -msingle-float +// +// RUN: %clang -target mips-linux-gnu -### -no-integrated-as -msingle-float -mfpxx -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=SINGLEFLOAT-EXPLICIT-FPXX %s +// SINGLEFLOAT-EXPLICIT-FPXX: as{{(.exe)?}}" +// SINGLEFLOAT-EXPLICIT-FPXX: -mfpxx +// SINGLEFLOAT-EXPLICIT-FPXX: -msingle-float +// +// RUN: %clang -target mips-mti-linux-gnu -### -no-integrated-as -msingle-float -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=MTI-SINGLEFLOAT-IMPLICIT-FPXX --implicit-check-not=-mfpxx %s +// MTI-SINGLEFLOAT-IMPLICIT-FPXX: as{{(.exe)?}}" +// MTI-SINGLEFLOAT-IMPLICIT-FPXX: -msingle-float +// +// RUN: %clang -target mips-mti-linux-gnu -### -no-integrated-as -msingle-float -mfpxx -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=MTI-SINGLEFLOAT-EXPLICIT-FPXX %s +// MTI-SINGLEFLOAT-EXPLICIT-FPXX: as{{(.exe)?}}" +// MTI-SINGLEFLOAT-EXPLICIT-FPXX: -mfpxx +// MTI-SINGLEFLOAT-EXPLICIT-FPXX: -msingle-float +// +// RUN: %clang -target mips-img-linux-gnu -### -no-integrated-as -msingle-float -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=IMG-SINGLEFLOAT-IMPLICIT-FPXX --implicit-check-not=-mfpxx %s +// IMG-SINGLEFLOAT-IMPLICIT-FPXX: as{{(.exe)?}}" +// IMG-SINGLEFLOAT-IMPLICIT-FPXX: -msingle-float +// +// RUN: %clang -target mips-img-linux-gnu -### -no-integrated-as -msingle-float -mfpxx -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=IMG-SINGLEFLOAT-EXPLICIT-FPXX %s +// IMG-SINGLEFLOAT-EXPLICIT-FPXX: as{{(.exe)?}}" +// IMG-SINGLEFLOAT-EXPLICIT-FPXX: -mfpxx +// IMG-SINGLEFLOAT-EXPLICIT-FPXX: -msingle-float diff --git a/test/Driver/mips-features.c b/test/Driver/mips-features.c index 5094f2b09b73..461d778182be 100644 --- a/test/Driver/mips-features.c +++ b/test/Driver/mips-features.c @@ -157,3 +157,75 @@ // RUN: -G 16 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-MIPS-G %s // CHECK-MIPS-G: "-mllvm" "-mips-ssection-threshold=16" +// +// -msoft-float (unknown vendor) +// RUN: %clang -target mips-linux-gnu -### -c %s -msoft-float 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-SOFTFLOAT %s +// CHECK-SOFTFLOAT: "-target-feature" "+soft-float" +// CHECK-SOFTFLOAT-NOT: "-target-feature" "+fpxx" +// +// -msoft-float -mfpxx (unknown vendor) +// RUN: %clang -target mips-linux-gnu -### -c %s -msoft-float -mfpxx 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-SOFTFLOAT-FPXX %s +// CHECK-SOFTFLOAT-FPXX: "-target-feature" "+soft-float" +// CHECK-SOFTFLOAT-FPXX: "-target-feature" "+fpxx" +// +// -msoft-float (MTI) +// RUN: %clang -target mips-mti-linux-gnu -### -c %s -msoft-float 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-MTI-SOFTFLOAT %s +// CHECK-MTI-SOFTFLOAT: "-target-feature" "+soft-float" +// CHECK-MTI-SOFTFLOAT-NOT: "-target-feature" "+fpxx" +// +// -msoft-float -mfpxx (MTI) +// RUN: %clang -target mips-mti-linux-gnu -### -c %s -msoft-float -mfpxx 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-MTI-SOFTFLOAT-FPXX %s +// CHECK-MTI-SOFTFLOAT-FPXX: "-target-feature" "+soft-float" +// CHECK-MTI-SOFTFLOAT-FPXX: "-target-feature" "+fpxx" +// +// -msoft-float (IMG) +// RUN: %clang -target mips-img-linux-gnu -### -c %s -msoft-float 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-IMG-SOFTFLOAT %s +// CHECK-IMG-SOFTFLOAT: "-target-feature" "+soft-float" +// CHECK-IMG-SOFTFLOAT-NOT: "-target-feature" "+fpxx" +// +// -msoft-float -mfpxx (IMG) +// RUN: %clang -target mips-img-linux-gnu -### -c %s -msoft-float -mfpxx 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-IMG-SOFTFLOAT-FPXX %s +// CHECK-IMG-SOFTFLOAT-FPXX: "-target-feature" "+soft-float" +// CHECK-IMG-SOFTFLOAT-FPXX: "-target-feature" "+fpxx" +// +// -msingle-float (unknown vendor) +// RUN: %clang -target mips-linux-gnu -### -c %s -msingle-float 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-SINGLEFLOAT %s +// CHECK-SINGLEFLOAT: "-target-feature" "+single-float" +// CHECK-SINGLEFLOAT-NOT: "-target-feature" "+fpxx" +// +// -msingle-float -mfpxx (unknown vendor) +// RUN: %clang -target mips-linux-gnu -### -c %s -msingle-float -mfpxx 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-SINGLEFLOAT-FPXX %s +// CHECK-SINGLEFLOAT-FPXX: "-target-feature" "+single-float" +// CHECK-SINGLEFLOAT-FPXX: "-target-feature" "+fpxx" +// +// -msingle-float (MTI) +// RUN: %clang -target mips-mti-linux-gnu -### -c %s -msingle-float 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-MTI-SINGLEFLOAT %s +// CHECK-MTI-SINGLEFLOAT: "-target-feature" "+single-float" +// CHECK-MTI-SINGLEFLOAT-NOT: "-target-feature" "+fpxx" +// +// -msingle-float -mfpxx (MTI) +// RUN: %clang -target mips-mti-linux-gnu -### -c %s -msingle-float -mfpxx 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-MTI-SINGLEFLOAT-FPXX %s +// CHECK-MTI-SINGLEFLOAT-FPXX: "-target-feature" "+single-float" +// CHECK-MTI-SINGLEFLOAT-FPXX: "-target-feature" "+fpxx" +// +// -msingle-float (IMG) +// RUN: %clang -target mips-img-linux-gnu -### -c %s -msingle-float 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-IMG-SINGLEFLOAT %s +// CHECK-IMG-SINGLEFLOAT: "-target-feature" "+single-float" +// CHECK-IMG-SINGLEFLOAT-NOT: "-target-feature" "+fpxx" +// +// -msingle-float -mfpxx (IMG) +// RUN: %clang -target mips-img-linux-gnu -### -c %s -msingle-float -mfpxx 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-IMG-SINGLEFLOAT-FPXX %s +// CHECK-IMG-SINGLEFLOAT-FPXX: "-target-feature" "+single-float" +// CHECK-IMG-SINGLEFLOAT-FPXX: "-target-feature" "+fpxx" diff --git a/test/Driver/mips-integrated-as.s b/test/Driver/mips-integrated-as.s index 2c298e75528b..0e128770678f 100644 --- a/test/Driver/mips-integrated-as.s +++ b/test/Driver/mips-integrated-as.s @@ -209,3 +209,87 @@ // RUN: FileCheck -check-prefix=ABICALLS-OFF %s // ABICALLS-OFF: -cc1as // ABICALLS-OFF: "-target-feature" "+noabicalls" + +// RUN: %clang -target mips-linux-gnu -### -fintegrated-as -msoft-float -c %s 2>&1 | \ +// RUN: FileCheck -check-prefix=SOFTFLOAT-IMPLICIT-FPXX --implicit-check-not=-mfpxx %s +// SOFTFLOAT-IMPLICIT-FPXX: -cc1as +// SOFTFLOAT-IMPLICIT-FPXX: "-target-feature" "+soft-float" +// SOFTFLOAT-IMPLICIT-FPXX-NOT: "-target-feature" "+fpxx" +// SOFTFLOAT-IMPLICIT-FPXX-NOT: "-target-feature" "+nooddspreg" + +// RUN: %clang -target mips-linux-gnu -### -fintegrated-as -msoft-float -mfpxx -c %s 2>&1 | \ +// RUN: FileCheck -check-prefix=SOFTFLOAT-EXPLICIT-FPXX %s +// SOFTFLOAT-EXPLICIT-FPXX: -cc1as +// SOFTFLOAT-EXPLICIT-FPXX: "-target-feature" "+soft-float" +// SOFTFLOAT-EXPLICIT-FPXX: "-target-feature" "+fpxx" +// SOFTFLOAT-EXPLICIT-FPXX: "-target-feature" "+nooddspreg" + +// RUN: %clang -target mips-mti-linux-gnu -### -fintegrated-as -msoft-float -c %s 2>&1 | \ +// RUN: FileCheck -check-prefix=MTI-SOFTFLOAT-IMPLICIT-FPXX --implicit-check-not=-mfpxx %s +// MTI-SOFTFLOAT-IMPLICIT-FPXX: -cc1as +// MTI-SOFTFLOAT-IMPLICIT-FPXX: "-target-feature" "+soft-float" +// MTI-SOFTFLOAT-IMPLICIT-FPXX-NOT: "-target-feature" "+fpxx" +// MTI-SOFTFLOAT-IMPLICIT-FPXX-NOT: "-target-feature" "+nooddspreg" + +// RUN: %clang -target mips-mti-linux-gnu -### -fintegrated-as -msoft-float -mfpxx -c %s 2>&1 | \ +// RUN: FileCheck -check-prefix=MTI-SOFTFLOAT-EXPLICIT-FPXX %s +// MTI-SOFTFLOAT-EXPLICIT-FPXX: -cc1as +// MTI-SOFTFLOAT-EXPLICIT-FPXX: "-target-feature" "+soft-float" +// MTI-SOFTFLOAT-EXPLICIT-FPXX: "-target-feature" "+fpxx" +// MTI-SOFTFLOAT-EXPLICIT-FPXX: "-target-feature" "+nooddspreg" + +// RUN: %clang -target mips-img-linux-gnu -### -fintegrated-as -msoft-float -c %s 2>&1 | \ +// RUN: FileCheck -check-prefix=IMG-SOFTFLOAT-IMPLICIT-FPXX --implicit-check-not=-mfpxx %s +// IMG-SOFTFLOAT-IMPLICIT-FPXX: -cc1as +// IMG-SOFTFLOAT-IMPLICIT-FPXX: "-target-feature" "+soft-float" +// IMG-SOFTFLOAT-IMPLICIT-FPXX-NOT: "-target-feature" "+fpxx" +// IMG-SOFTFLOAT-IMPLICIT-FPXX-NOT: "-target-feature" "+nooddspreg" + +// RUN: %clang -target mips-img-linux-gnu -### -fintegrated-as -msoft-float -mfpxx -c %s 2>&1 | \ +// RUN: FileCheck -check-prefix=IMG-SOFTFLOAT-EXPLICIT-FPXX %s +// IMG-SOFTFLOAT-EXPLICIT-FPXX: -cc1as +// IMG-SOFTFLOAT-EXPLICIT-FPXX: "-target-feature" "+soft-float" +// IMG-SOFTFLOAT-EXPLICIT-FPXX: "-target-feature" "+fpxx" +// IMG-SOFTFLOAT-EXPLICIT-FPXX: "-target-feature" "+nooddspreg" + +// RUN: %clang -target mips-linux-gnu -### -fintegrated-as -msingle-float -c %s 2>&1 | \ +// RUN: FileCheck -check-prefix=SINGLEFLOAT-IMPLICIT-FPXX --implicit-check-not=-mfpxx %s +// SINGLEFLOAT-IMPLICIT-FPXX: -cc1as +// SINGLEFLOAT-IMPLICIT-FPXX: "-target-feature" "+single-float" +// SINGLEFLOAT-IMPLICIT-FPXX-NOT: "-target-feature" "+fpxx" +// SINGLEFLOAT-IMPLICIT-FPXX-NOT: "-target-feature" "+nooddspreg" + +// RUN: %clang -target mips-linux-gnu -### -fintegrated-as -msingle-float -mfpxx -c %s 2>&1 | \ +// RUN: FileCheck -check-prefix=SINGLEFLOAT-EXPLICIT-FPXX %s +// SINGLEFLOAT-EXPLICIT-FPXX: -cc1as +// SINGLEFLOAT-EXPLICIT-FPXX: "-target-feature" "+single-float" +// SINGLEFLOAT-EXPLICIT-FPXX: "-target-feature" "+fpxx" +// SINGLEFLOAT-EXPLICIT-FPXX: "-target-feature" "+nooddspreg" + +// RUN: %clang -target mips-mti-linux-gnu -### -fintegrated-as -msingle-float -c %s 2>&1 | \ +// RUN: FileCheck -check-prefix=MTI-SINGLEFLOAT-IMPLICIT-FPXX --implicit-check-not=-mfpxx %s +// MTI-SINGLEFLOAT-IMPLICIT-FPXX: -cc1as +// MTI-SINGLEFLOAT-IMPLICIT-FPXX: "-target-feature" "+single-float" +// MTI-SINGLEFLOAT-IMPLICIT-FPXX-NOT: "-target-feature" "+fpxx" +// MTI-SINGLEFLOAT-IMPLICIT-FPXX-NOT: "-target-feature" "+nooddspreg" + +// RUN: %clang -target mips-mti-linux-gnu -### -fintegrated-as -msingle-float -mfpxx -c %s 2>&1 | \ +// RUN: FileCheck -check-prefix=MTI-SINGLEFLOAT-EXPLICIT-FPXX %s +// MTI-SINGLEFLOAT-EXPLICIT-FPXX: -cc1as +// MTI-SINGLEFLOAT-EXPLICIT-FPXX: "-target-feature" "+single-float" +// MTI-SINGLEFLOAT-EXPLICIT-FPXX: "-target-feature" "+fpxx" +// MTI-SINGLEFLOAT-EXPLICIT-FPXX: "-target-feature" "+nooddspreg" + +// RUN: %clang -target mips-img-linux-gnu -### -fintegrated-as -msingle-float -c %s 2>&1 | \ +// RUN: FileCheck -check-prefix=IMG-SINGLEFLOAT-IMPLICIT-FPXX --implicit-check-not=-mfpxx %s +// IMG-SINGLEFLOAT-IMPLICIT-FPXX: -cc1as +// IMG-SINGLEFLOAT-IMPLICIT-FPXX: "-target-feature" "+single-float" +// IMG-SINGLEFLOAT-IMPLICIT-FPXX-NOT: "-target-feature" "+fpxx" +// IMG-SINGLEFLOAT-IMPLICIT-FPXX-NOT: "-target-feature" "+nooddspreg" + +// RUN: %clang -target mips-img-linux-gnu -### -fintegrated-as -msingle-float -mfpxx -c %s 2>&1 | \ +// RUN: FileCheck -check-prefix=IMG-SINGLEFLOAT-EXPLICIT-FPXX %s +// IMG-SINGLEFLOAT-EXPLICIT-FPXX: -cc1as +// IMG-SINGLEFLOAT-EXPLICIT-FPXX: "-target-feature" "+single-float" +// IMG-SINGLEFLOAT-EXPLICIT-FPXX: "-target-feature" "+fpxx" +// IMG-SINGLEFLOAT-EXPLICIT-FPXX: "-target-feature" "+nooddspreg" diff --git a/test/Driver/modules.mm b/test/Driver/modules.mm index 63db69956e45..d1536c73a1f3 100644 --- a/test/Driver/modules.mm +++ b/test/Driver/modules.mm @@ -6,3 +6,10 @@ // RUN: %clang -fmodules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MODULES %s // RUN: %clang -fmodules -fno-cxx-modules -fcxx-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MODULES %s // CHECK-HAS-MODULES: -fmodules + +// RUN: %clang -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MAPS %s +// RUN: %clang -fimplicit-module-maps -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MAPS %s +// RUN: %clang -fmodules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MAPS %s +// RUN: %clang -fmodules -fno-implicit-module-maps -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MAPS %s +// CHECK-HAS-MAPS: -fimplicit-module-maps +// CHECK-NO-MAPS-NOT: -fimplicit-module-maps diff --git a/test/Driver/mrecip.c b/test/Driver/mrecip.c new file mode 100644 index 000000000000..4e99b1532612 --- /dev/null +++ b/test/Driver/mrecip.c @@ -0,0 +1,70 @@ +//// +//// Verify that valid options for the -mrecip flag are passed through and invalid options cause an error. +//// + +//// If there are no options, convert to 'all'. + +// RUN: %clang -### -S %s -mrecip 2>&1 | FileCheck --check-prefix=RECIP0 %s +// RECIP0: "-mrecip=all" + +//// Check options that cover all types. + +// RUN: %clang -### -S %s -mrecip=all 2>&1 | FileCheck --check-prefix=RECIP1 %s +// RECIP1: "-mrecip=all" + +// RUN: %clang -### -S %s -mrecip=default 2>&1 | FileCheck --check-prefix=RECIP2 %s +// RECIP2: "-mrecip=default" + +// RUN: %clang -### -S %s -mrecip=none 2>&1 | FileCheck --check-prefix=RECIP3 %s +// RECIP3: "-mrecip=none" + +//// Check options that do not specify float or double. + +// RUN: %clang -### -S %s -mrecip=vec-sqrt 2>&1 | FileCheck --check-prefix=RECIP4 %s +// RECIP4: "-mrecip=vec-sqrt" + +// RUN: %clang -### -S %s -mrecip=!div,vec-div 2>&1 | FileCheck --check-prefix=RECIP5 %s +// RECIP5: "-mrecip=!div,vec-div" + +//// Check individual option types. + +// RUN: %clang -### -S %s -mrecip=vec-sqrtd 2>&1 | FileCheck --check-prefix=RECIP6 %s +// RECIP6: "-mrecip=vec-sqrtd" + +// RUN: %clang -### -S %s -mrecip=!divf 2>&1 | FileCheck --check-prefix=RECIP7 %s +// RECIP7: "-mrecip=!divf" + +// RUN: %clang -### -S %s -mrecip=divf,sqrtd,vec-divd,vec-sqrtf 2>&1 | FileCheck --check-prefix=RECIP8 %s +// RECIP8: "-mrecip=divf,sqrtd,vec-divd,vec-sqrtf" + +//// Check optional refinement step specifiers. + +// RUN: %clang -### -S %s -mrecip=all:1 2>&1 | FileCheck --check-prefix=RECIP9 %s +// RECIP9: "-mrecip=all:1" + +// RUN: %clang -### -S %s -mrecip=sqrtf:3 2>&1 | FileCheck --check-prefix=RECIP10 %s +// RECIP10: "-mrecip=sqrtf:3" + +// RUN: %clang -### -S %s -mrecip=div:5 2>&1 | FileCheck --check-prefix=RECIP11 %s +// RECIP11: "-mrecip=div:5" + +// RUN: %clang -### -S %s -mrecip=divd:1,!sqrtf:2,vec-divf:9,vec-sqrtd:0 2>&1 | FileCheck --check-prefix=RECIP12 %s +// RECIP12: "-mrecip=divd:1,!sqrtf:2,vec-divf:9,vec-sqrtd:0" + +//// Check invalid parameters. + +// RUN: %clang -### -S %s -mrecip=bogus 2>&1 | FileCheck --check-prefix=RECIP13 %s +// RECIP13: error: unknown argument + +// RUN: %clang -### -S %s -mrecip=divd:1,divd 2>&1 | FileCheck --check-prefix=RECIP14 %s +// RECIP14: error: invalid value + +// RUN: %clang -### -S %s -mrecip=sqrt,sqrtf 2>&1 | FileCheck --check-prefix=RECIP15 %s +// RECIP15: error: invalid value + +// RUN: %clang -### -S %s -mrecip=+default:10 2>&1 | FileCheck --check-prefix=RECIP16 %s +// RECIP16: error: invalid value + +// RUN: %clang -### -S %s -mrecip=!vec-divd: 2>&1 | FileCheck --check-prefix=RECIP17 %s +// RECIP17: error: invalid value + diff --git a/test/Driver/r600-mcpu.cl b/test/Driver/r600-mcpu.cl index 94a77346e877..4fbec0c83bf9 100644 --- a/test/Driver/r600-mcpu.cl +++ b/test/Driver/r600-mcpu.cl @@ -1,4 +1,4 @@ -// Check that -mcpu works for all supported GPUs +t// Check that -mcpu works for all supported GPUs // RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=r600 %s -o - 2>&1 | FileCheck --check-prefix=R600-CHECK %s // RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=rv630 %s -o - 2>&1 | FileCheck --check-prefix=R600-CHECK %s @@ -35,6 +35,9 @@ // RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=kaveri %s -o - 2>&1 | FileCheck --check-prefix=KAVERI-CHECK %s // RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=hawaii %s -o - 2>&1 | FileCheck --check-prefix=HAWAII-CHECK %s // RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=mullins %s -o - 2>&1 | FileCheck --check-prefix=MULLINS-CHECK %s +// RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=tonga %s -o - 2>&1 | FileCheck --check-prefix=TONGA-CHECK %s +// RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=iceland %s -o - 2>&1 | FileCheck --check-prefix=ICELAND-CHECK %s +// RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=carrizo %s -o - 2>&1 | FileCheck --check-prefix=CARRIZO-CHECK %s // R600-CHECK: "-target-cpu" "r600" // RS880-CHECK: "-target-cpu" "rs880" @@ -60,3 +63,6 @@ // KAVERI-CHECK: "-target-cpu" "kaveri" // HAWAII-CHECK: "-target-cpu" "hawaii" // MULLINS-CHECK: "-target-cpu" "mullins" +// TONGA-CHECK: "-target-cpu" "tonga" +// ICELAND-CHECK: "-target-cpu" "iceland" +// CARRIZO-CHECK: "-target-cpu" "carrizo" diff --git a/test/Driver/rtti-options.cpp b/test/Driver/rtti-options.cpp index 46072ca6ea74..50354e5f019c 100644 --- a/test/Driver/rtti-options.cpp +++ b/test/Driver/rtti-options.cpp @@ -15,17 +15,12 @@ // -fsanitize=vptr // Make sure we only error/warn once, when trying to enable vptr and // undefined and have -fno-rtti -// RUN: %clang -### -c -fsanitize=undefined -fsanitize=vptr -fno-rtti %s 2>&1 | FileCheck -check-prefix=CHECK-SAN-ERROR -check-prefix=CHECK-OK %s - -// RUN: %clang -### -c -target x86_64-scei-ps4 -fsanitize=vptr %s 2>&1 | FileCheck -check-prefix=CHECK-SAN-WARN %s -// RUN: %clang -### -c -target x86_64-scei-ps4 -fsanitize=vptr -frtti %s 2>&1 | FileCheck -check-prefix=CHECK-OK %s -// RUN: %clang -### -c -target x86_64-scei-ps4 -fsanitize=vptr -fno-rtti %s 2>&1 | FileCheck -check-prefix=CHECK-SAN-ERROR %s -// RUN: %clang -### -c -target x86_64-scei-ps4 -fsanitize=undefined -frtti %s 2>&1 | FileCheck -check-prefix=CHECK-OK %s -// RUN: %clang -### -c -target x86_64-unknown-unknown -fsanitize=vptr %s 2>&1 | FileCheck -check-prefix=CHECK-OK %s -// RUN: %clang -### -c -target x86_64-unknown-unknown -fsanitize=vptr -frtti %s 2>&1 | FileCheck -check-prefix=CHECK-OK %s -// RUN: %clang -### -c -target x86_64-unknown-unknown -fsanitize=vptr -fno-rtti %s 2>&1 | FileCheck -check-prefix=CHECK-SAN-ERROR %s -// RUN: %clang -### -c -target x86_64-unknown-unknown -fsanitize=undefined %s 2>&1 | FileCheck -check-prefix=CHECK-OK %s -// RUN: %clang -### -c -target x86_64-unknown-unknown -fsanitize=undefined -frtti %s 2>&1 | FileCheck -check-prefix=CHECK-OK %s +// RUN: %clang -### -c -target x86_64-unknown-linux -fsanitize=undefined -fsanitize=vptr -fno-rtti %s 2>&1 | FileCheck -check-prefix=CHECK-SAN-ERROR -check-prefix=CHECK-OK %s +// RUN: %clang -### -c -target x86_64-unknown-linux -fsanitize=vptr %s 2>&1 | FileCheck -check-prefix=CHECK-OK %s +// RUN: %clang -### -c -target x86_64-unknown-linux -fsanitize=vptr -frtti %s 2>&1 | FileCheck -check-prefix=CHECK-OK %s +// RUN: %clang -### -c -target x86_64-unknown-linux -fsanitize=vptr -fno-rtti %s 2>&1 | FileCheck -check-prefix=CHECK-SAN-ERROR %s +// RUN: %clang -### -c -target x86_64-unknown-linux -fsanitize=undefined %s 2>&1 | FileCheck -check-prefix=CHECK-OK %s +// RUN: %clang -### -c -target x86_64-unknown-linux -fsanitize=undefined -frtti %s 2>&1 | FileCheck -check-prefix=CHECK-OK %s // Exceptions + no/default rtti // RUN: %clang -### -c -target x86_64-scei-ps4 -fcxx-exceptions -fno-rtti %s 2>&1 | FileCheck -check-prefix=CHECK-EXC-ERROR-CXX %s @@ -51,7 +46,6 @@ // RUN: %clang -### -c -target x86_64-unknown-unknown %s 2>&1 | FileCheck -check-prefix=CHECK-RTTI %s // CHECK-UNUSED: warning: argument unused during compilation: '-fcxx-exceptions' -// CHECK-SAN-WARN: implicitly disabling vptr sanitizer because rtti wasn't enabled // CHECK-SAN-ERROR: invalid argument '-fsanitize=vptr' not allowed with '-fno-rtti' // CHECK-EXC-WARN: implicitly enabling rtti for exception handling // CHECK-EXC-ERROR: invalid argument '-fno-rtti' not allowed with '-fexceptions' diff --git a/test/Driver/shave-toolchain.c b/test/Driver/shave-toolchain.c new file mode 100644 index 000000000000..a02d04971def --- /dev/null +++ b/test/Driver/shave-toolchain.c @@ -0,0 +1,22 @@ +// Ensure that '-target shave' picks a different compiler. +// Also check that '-I' is turned into '-i:' for the assembler. + +// Note that since we don't know where movi tools are installed, +// the driver may or may not find a full path to them. +// That is, the 0th argument will be "/path/to/my/moviCompile" +// or just "moviCompile" depending on whether moviCompile is found. +// As such, we test only for a trailing quote in its rendering. +// The same goes for "moviAsm". + +// RUN: %clang -target shave -c -### %s -Icommon 2>&1 \ +// RUN: | FileCheck %s -check-prefix=movicompile +// movicompile: moviCompile" "-DMYRIAD2" +// movicompile: moviAsm" "-no6thSlotCompression" "-cv:myriad2" "-noSPrefixing" "-a" "-i:common" "-elf" + +// RUN: %clang -target shave -c -### %s -DEFINE_ME -UNDEFINE_ME 2>&1 \ +// RUN: | FileCheck %s -check-prefix=defines +// defines: "-D" "EFINE_ME" "-U" "NDEFINE_ME" + +// RUN: %clang -target shave -c -### %s -Icommon -iquote quotepath -isystem syspath 2>&1 \ +// RUN: | FileCheck %s -check-prefix=includes +// includes: "-iquote" "quotepath" "-isystem" "syspath" diff --git a/test/Driver/sparc-float.c b/test/Driver/sparc-float.c index e84c487c73c9..6fa47f00cc7a 100644 --- a/test/Driver/sparc-float.c +++ b/test/Driver/sparc-float.c @@ -5,38 +5,36 @@ // RUN: %clang -c %s -### -o %t.o 2>&1 \ // RUN: -target sparc-linux-gnu \ // RUN: | FileCheck --check-prefix=CHECK-DEF %s -// CHECK-DEF: "-target-feature" "+soft-float" -// CHECK-DEF: "-msoft-float" +// CHECK-DEF-NOT: "-target-feature" "+soft-float" +// CHECK-DEF-NOT: "-msoft-float" // // -mhard-float // RUN: %clang -c %s -### -o %t.o 2>&1 \ // RUN: -target sparc-linux-gnu -mhard-float \ // RUN: | FileCheck --check-prefix=CHECK-HARD %s -// CHECK-HARD: "-mhard-float" +// CHECK-HARD-NOT: "-msoft-float" // // -msoft-float // RUN: %clang -c %s -### -o %t.o 2>&1 \ // RUN: -target sparc-linux-gnu -msoft-float \ // RUN: | FileCheck --check-prefix=CHECK-SOFT %s -// CHECK-SOFT: "-target-feature" "+soft-float" -// CHECK-SOFT: "-msoft-float" +// CHECK-SOFT: error: unsupported option '-msoft-float' // // Default sparc64 // RUN: %clang -c %s -### -o %t.o 2>&1 \ // RUN: -target sparc64-linux-gnu \ // RUN: | FileCheck --check-prefix=CHECK-DEF-SPARC64 %s -// CHECK-DEF-SPARC64: "-target-feature" "+soft-float" -// CHECK-DEF-SPARC64: "-msoft-float" +// CHECK-DEF-SPARC64-NOT: "-target-feature" "+soft-float" +// CHECK-DEF-SPARC64-NOT: "-msoft-float" // // -mhard-float // RUN: %clang -c %s -### -o %t.o 2>&1 \ // RUN: -target sparc64-linux-gnu -mhard-float \ // RUN: | FileCheck --check-prefix=CHECK-HARD-SPARC64 %s -// CHECK-HARD-SPARC64: "-mhard-float" +// CHECK-HARD-SPARC64-NOT: "-msoft-float" // // -msoft-float // RUN: %clang -c %s -### -o %t.o 2>&1 \ // RUN: -target sparc64-linux-gnu -msoft-float \ // RUN: | FileCheck --check-prefix=CHECK-SOFT-SPARC64 %s -// CHECK-SOFT-SPARC64: "-target-feature" "+soft-float" -// CHECK-SOFT-SPARC64: "-msoft-float" +// CHECK-SOFT-SPARC64: error: unsupported option '-msoft-float' diff --git a/test/FixIt/fixit-large-file.cpp b/test/FixIt/fixit-large-file.cpp new file mode 100644 index 000000000000..a1dab53489c7 --- /dev/null +++ b/test/FixIt/fixit-large-file.cpp @@ -0,0 +1,318 @@ +// Don't modify the source in place, since it might be readonly. +// RUN: cp %s %t.cpp +// RUN: not %clang_cc1 -fixit %t.cpp 2>&1 | FileCheck %s + +struct A { int x; }; +int foo(A *p) { + return p.x; +} + +// CHECK: error: member reference type 'A *' is a pointer; did you mean to use '->'? +// CHECK: note: FIX-IT applied suggested code changes +// CHECK-NOT: error: + +// The following comment block makes the file at least 16K, which causes clang +// to mmap it. This caused an issue with clang on Windows, where you cannot +// write a file which is currently mapped. +// +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx diff --git a/test/FixIt/fixit-nullability-declspec.cpp b/test/FixIt/fixit-nullability-declspec.cpp new file mode 100644 index 000000000000..2ac20b9d9b4c --- /dev/null +++ b/test/FixIt/fixit-nullability-declspec.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fblocks -Werror=nullability-declspec -x c++ -verify %s + +// RUN: cp %s %t +// RUN: not %clang_cc1 -fixit -fblocks -Werror=nullability-declspec -x c++ %t +// RUN: %clang_cc1 -fblocks -Werror=nullability-declspec -x c++ %t + +__nullable int *ip1; // expected-error{{nullability specifier '__nullable' cannot be applied to non-pointer type 'int'; did you mean to apply the specifier to the pointer?}} +__nullable int (*fp1)(int); // expected-error{{nullability specifier '__nullable' cannot be applied to non-pointer type 'int'; did you mean to apply the specifier to the function pointer?}} +__nonnull int (^bp1)(int); // expected-error{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'int'; did you mean to apply the specifier to the block pointer?}} diff --git a/test/Format/style-on-command-line.cpp b/test/Format/style-on-command-line.cpp index 2e757cc92a55..3f4f77ad0c31 100644 --- a/test/Format/style-on-command-line.cpp +++ b/test/Format/style-on-command-line.cpp @@ -29,3 +29,7 @@ void f() { int*i; int j; } + +// On Windows, the 'rm' commands fail when the previous process is still alive. +// This happens enough to make the test useless. +// REQUIRES: shell diff --git a/test/Frontend/rewrite-includes-modules.c b/test/Frontend/rewrite-includes-modules.c index 58d7809909da..613609dfce24 100644 --- a/test/Frontend/rewrite-includes-modules.c +++ b/test/Frontend/rewrite-includes-modules.c @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x objective-c %s -F %S/../Modules/Inputs -E -frewrite-includes -o - | FileCheck %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x objective-c %s -F %S/../Modules/Inputs -E -frewrite-includes -o - | FileCheck %s int bar(); #include <Module/Module.h> diff --git a/test/Frontend/verify-ignore-unexpected.c b/test/Frontend/verify-ignore-unexpected.c new file mode 100644 index 000000000000..bc3e0d16e686 --- /dev/null +++ b/test/Frontend/verify-ignore-unexpected.c @@ -0,0 +1,81 @@ +// RUN: not %clang_cc1 -DTEST_SWITCH -verify-ignore-unexpected=remark,aoeu,note -verify %s 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-BAD-SWITCH %s +#ifdef TEST_SWITCH +// expected-no-diagnostics +#endif +// CHECK-BAD-SWITCH: error: 'error' diagnostics seen but not expected: +// CHECK-BAD-SWITCH-NEXT: (frontend): invalid value 'aoeu' in '-verify-ignore-unexpected=' + +// RUN: %clang_cc1 -DTEST1 -verify %s +// RUN: %clang_cc1 -DTEST1 -verify -verify-ignore-unexpected %s +#ifdef TEST1 +#warning MyWarning1 + // expected-warning@-1 {{MyWarning1}} +int x; // expected-note {{previous definition is here}} +float x; // expected-error {{redefinition of 'x'}} +#endif + +// RUN: not %clang_cc1 -DTEST2 -verify %s 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-UNEXP %s +// RUN: not %clang_cc1 -DTEST2 -verify -verify-ignore-unexpected= %s 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-UNEXP %s +// RUN: not %clang_cc1 -DTEST2 -verify -verify-ignore-unexpected=note %s 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-NOTE %s +// RUN: not %clang_cc1 -DTEST2 -verify -verify-ignore-unexpected=warning %s 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-WARN %s +// RUN: not %clang_cc1 -DTEST2 -verify -verify-ignore-unexpected=error %s 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-ERR %s +#ifdef TEST2 +#warning MyWarning2 +int x; +float x; +#endif +// CHECK-UNEXP: no expected directives found +// CHECK-UNEXP-NEXT: 'error' diagnostics seen but not expected +// CHECK-UNEXP-NEXT: Line {{[0-9]+}}: redefinition of 'x' +// CHECK-UNEXP-NEXT: 'warning' diagnostics seen but not expected +// CHECK-UNEXP-NEXT: Line {{[0-9]+}}: MyWarning2 +// CHECK-UNEXP-NEXT: 'note' diagnostics seen but not expected +// CHECK-UNEXP-NEXT: Line {{[0-9]+}}: previous definition is here +// CHECK-UNEXP-NEXT: 4 errors generated. + +// CHECK-NOTE: no expected directives found +// CHECK-NOTE-NEXT: 'error' diagnostics seen but not expected +// CHECK-NOTE-NEXT: Line {{[0-9]+}}: redefinition of 'x' +// CHECK-NOTE-NEXT: 'warning' diagnostics seen but not expected +// CHECK-NOTE-NEXT: Line {{[0-9]+}}: MyWarning2 +// CHECK-NOTE-NEXT: 3 errors generated. + +// CHECK-WARN: no expected directives found +// CHECK-WARN-NEXT: 'error' diagnostics seen but not expected +// CHECK-WARN-NEXT: Line {{[0-9]+}}: redefinition of 'x' +// CHECK-WARN-NEXT: 'note' diagnostics seen but not expected +// CHECK-WARN-NEXT: Line {{[0-9]+}}: previous definition is here +// CHECK-WARN-NEXT: 3 errors generated. + +// CHECK-ERR: no expected directives found +// CHECK-ERR-NEXT: 'warning' diagnostics seen but not expected +// CHECK-ERR-NEXT: Line {{[0-9]+}}: MyWarning2 +// CHECK-ERR-NEXT: 'note' diagnostics seen but not expected +// CHECK-ERR-NEXT: Line {{[0-9]+}}: previous definition is here +// CHECK-ERR-NEXT: 3 errors generated. + +// RUN: not %clang_cc1 -DTEST3 -verify -verify-ignore-unexpected %s 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-EXP %s +#ifdef TEST3 +// expected-error {{test3}} +#endif +// CHECK-EXP: 'error' diagnostics expected but not seen +// CHECK-EXP-NEXT: Line {{[0-9]+}}: test3 + +// RUN: not %clang_cc1 -DTEST4 -verify -verify-ignore-unexpected %s 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-NOEXP %s +// RUN: not %clang_cc1 -DTEST4 -verify -verify-ignore-unexpected=warning,error,note %s 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-NOEXP %s +#ifdef TEST4 +#warning MyWarning4 +int x; +float x; +#endif +// CHECK-NOEXP: error: no expected directives found +// CHECK-NOEXP-NEXT: 1 error generated diff --git a/test/Headers/pmmintrin.c b/test/Headers/pmmintrin.c new file mode 100644 index 000000000000..5b7a3a4ef6b9 --- /dev/null +++ b/test/Headers/pmmintrin.c @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -fsyntax-only -ffreestanding %s -verify +// RUN: %clang_cc1 -fsyntax-only -ffreestanding -x c++ %s -verify +// expected-no-diagnostics + +#if defined(i386) || defined(__x86_64__) +#include <pmmintrin.h> + +int __attribute__((__target__(("sse3")))) foo(int a) { + _mm_mwait(0, 0); + return 4; +} +#endif diff --git a/test/Headers/x86intrin-2.c b/test/Headers/x86intrin-2.c new file mode 100644 index 000000000000..f98fdbd13a8a --- /dev/null +++ b/test/Headers/x86intrin-2.c @@ -0,0 +1,137 @@ +// RUN: %clang_cc1 -fsyntax-only -ffreestanding %s -verify +// RUN: %clang_cc1 -fsyntax-only -ffreestanding -fno-lax-vector-conversions %s -verify +// RUN: %clang_cc1 -fsyntax-only -ffreestanding -x c++ %s -verify +// expected-no-diagnostics + +#if defined(i386) || defined(__x86_64__) + +// Include the metaheader that includes all x86 intrinsic headers. +#include <x86intrin.h> + +void __attribute__((__target__("mmx"))) mm_empty_wrap(void) { + _mm_empty(); +} + +__m128 __attribute__((__target__("sse"))) mm_add_ss_wrap(__m128 a, __m128 b) { + return _mm_add_ss(a, b); +} + +__m128d __attribute__((__target__("sse2"))) mm_sqrt_sd_wrap(__m128d a, __m128d b) { + return _mm_sqrt_sd(a, b); +} + +void __attribute__((__target__("sse3"))) mm_mwait_wrap(int a) { + _mm_mwait(0, 0); +} + +__m64 __attribute__((__target__("ssse3"))) mm_abs_pi8_wrap(__m64 a) { + return _mm_abs_pi8(a); +} + +__m128i __attribute__((__target__("sse4.1"))) mm_minpos_epu16_wrap(__m128i v) { + return _mm_minpos_epu16(v); +} + +unsigned int __attribute__((__target__("sse4.2"))) mm_crc32_u8_wrap(unsigned int c, unsigned char d) { + return _mm_crc32_u8(c, d); +} + +__m128i __attribute__((__target__("aes"))) mm_aesenc_si128_wrap(__m128i v, __m128i r) { + return _mm_aesenc_si128(v, r); +} + +__m256d __attribute__((__target__("avx"))) mm256_add_pd_wrap(__m256d a, __m256d b) { + return _mm256_add_pd(a, b); +} + +__m256i __attribute__((__target__("avx2"))) mm256_abs_epi8_wrap(__m256i a) { + return _mm256_abs_epi8(a); +} + +unsigned short __attribute__((__target__("bmi"))) tzcnt_u16_wrap(unsigned short x) { + return __tzcnt_u16(x); +} + +unsigned int __attribute__((__target__("bmi2"))) bzhi_u32_wrap(unsigned int x, unsigned int y) { + return _bzhi_u32(x, y); +} + +unsigned short __attribute__((__target__("lzcnt"))) lzcnt16_wrap(unsigned short x) { + return __lzcnt16(x); +} + +__m256d __attribute__((__target__("fma"))) mm256_fmsubadd_pd_wrap(__m256d a, __m256d b, __m256d c) { + return _mm256_fmsubadd_pd(a, b, c); +} + +__m512i __attribute__((__target__("avx512f"))) mm512_setzero_si512_wrap(void) { + return _mm512_setzero_si512(); +} + +__mmask8 __attribute__((__target__("avx512vl"))) mm_cmpeq_epi32_mask_wrap(__m128i a, __m128i b) { + return _mm_cmpeq_epi32_mask(a, b); +} + +__v64qi __attribute__((__target__("avx512bw"))) mm512_setzero_qi_wrap(void) { + return _mm512_setzero_qi(); +} + +__m512i __attribute__((__target__("avx512dq"))) mm512_mullo_epi64_wrap(__m512i a, __m512i b) { + return _mm512_mullo_epi64(a, b); +} + +__mmask16 __attribute__((__target__("avx512vl,avx512bw"))) mm_cmpeq_epi8_mask_wrap(__m128i a, __m128i b) { + return _mm_cmpeq_epi8_mask(a, b); +} + +__m256i __attribute__((__target__("avx512vl,avx512dq"))) mm256_mullo_epi64_wrap(__m256i a, __m256i b) { + return _mm256_mullo_epi64(a, b); +} + +int __attribute__((__target__("rdrnd"))) rdrand16_step_wrap(unsigned short *p) { + return _rdrand16_step(p); +} + +#if defined(__x86_64__) +unsigned int __attribute__((__target__("fsgsbase"))) readfsbase_u32_wrap(void) { + return _readfsbase_u32(); +} +#endif + +unsigned int __attribute__((__target__("rtm"))) xbegin_wrap(void) { + return _xbegin(); +} + +__m128i __attribute__((__target__("sha"))) mm_sha1nexte_epu32_wrap(__m128i x, __m128i y) { + return _mm_sha1nexte_epu32(x, y); +} + +int __attribute__((__target__("rdseed"))) rdseed16_step_wrap(unsigned short *p) { + return _rdseed16_step(p); +} + +__m128i __attribute__((__target__("sse4a"))) mm_extract_si64_wrap(__m128i x, __m128i y) { + return _mm_extract_si64(x, y); +} + +__m128 __attribute__((__target__("fma4"))) mm_macc_ps_wrap(__m128 a, __m128 b, __m128 c) { + return _mm_macc_ps(a, b, c); +} + +__m256 __attribute__((__target__("xop"))) mm256_frcz_ps_wrap(__m256 a) { + return _mm256_frcz_ps(a); +} + +unsigned int __attribute__((__target__("tbm"))) blcfill_u32_wrap(unsigned int a) { + return __blcfill_u32(a); +} + +__m128 __attribute__((__target__("f16c"))) mm_cvtph_ps_wrap(__m128i a) { + return _mm_cvtph_ps(a); +} + +int __attribute__((__target__("rtm"))) xtest_wrap(void) { + return _xtest(); +} + +#endif diff --git a/test/Headers/x86intrin.c b/test/Headers/x86intrin.c index 6a1608b756a0..7c15c4816b33 100644 --- a/test/Headers/x86intrin.c +++ b/test/Headers/x86intrin.c @@ -5,126 +5,7 @@ #if defined(i386) || defined(__x86_64__) -// Pretend to enable all features. -#ifndef __3dNOW__ -#define __3dNOW__ -#endif -#ifndef __BMI__ -#define __BMI__ -#endif -#ifndef __BMI2__ -#define __BMI2__ -#endif -#ifndef __LZCNT__ -#define __LZCNT__ -#endif -#ifndef __POPCNT__ -#define __POPCNT__ -#endif -#ifndef __RDSEED__ -#define __RDSEED__ -#endif -#ifndef __PRFCHW__ -#define __PRFCHW__ -#endif -#ifndef __SSE4A__ -#define __SSE4A__ -#endif -#ifndef __FMA4__ -#define __FMA4__ -#endif -#ifndef __XOP__ -#define __XOP__ -#endif -#ifndef __F16C__ -#define __F16C__ -#endif -#ifndef __MMX__ -#define __MMX__ -#endif -#ifndef __SSE__ -#define __SSE__ -#endif -#ifndef __SSE2__ -#define __SSE2__ -#endif -#ifndef __SSE3__ -#define __SSE3__ -#endif -#ifndef __SSSE3__ -#define __SSSE3__ -#endif -#ifndef __SSE4_1__ -#define __SSE4_1__ -#endif -#ifndef __SSE4_2__ -#define __SSE4_2__ -#endif -#ifndef __AES__ -#define __AES__ -#endif -#ifndef __AVX__ -#define __AVX__ -#endif -#ifndef __AVX2__ -#define __AVX2__ -#endif -#ifndef __BMI__ -#define __BMI__ -#endif -#ifndef __BMI2__ -#define __BMI2__ -#endif -#ifndef __LZCNT__ -#define __LZCNT__ -#endif -#ifndef __FMA__ -#define __FMA__ -#endif -#ifndef __RDRND__ -#define __RDRND__ -#endif -#ifndef __SHA__ -#define __SHA__ -#endif -#ifndef __ADX__ -#define __ADX__ -#endif -#ifndef __TBM__ -#define __TBM__ -#endif -#ifndef __RTM__ -#define __RTM__ -#endif -#ifndef __PCLMUL__ -#define __PCLMUL__ -#endif -#ifndef __FSGSBASE__ -#define __FSGSBASE__ -#endif -#ifndef __AVX512F__ -#define __AVX512F__ -#endif -#ifndef __AVX512VL__ -#define __AVX512VL__ -#endif -#ifndef __AVX512BW__ -#define __AVX512BW__ -#endif -#ifndef __AVX512ER__ -#define __AVX512ER__ -#endif -#ifndef __AVX512PF__ -#define __AVX512PF__ -#endif -#ifndef __AVX512DQ__ -#define __AVX512DQ__ -#endif -#ifndef __AVX512CD__ -#define __AVX512CD__ -#endif - -// Now include the metaheader that includes all x86 intrinsic headers. +// Include the metaheader that includes all x86 intrinsic headers. #include <x86intrin.h> #endif diff --git a/test/Headers/xmmintrin.c b/test/Headers/xmmintrin.c index 76fff0db77fd..5bf5d4a56683 100644 --- a/test/Headers/xmmintrin.c +++ b/test/Headers/xmmintrin.c @@ -2,7 +2,7 @@ // // RUN: rm -rf %t // RUN: %clang_cc1 %s -ffreestanding -triple x86_64-apple-macosx10.9.0 -emit-llvm -o - \ -// RUN: -fmodules -fmodules-cache-path=%t -isystem %S/Inputs/include \ +// RUN: -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -isystem %S/Inputs/include \ // RUN: | FileCheck %s #include <xmmintrin.h> diff --git a/test/Index/comment-objc-decls.m b/test/Index/comment-objc-decls.m index ae3b0bbf415d..d53757cbc3cc 100644 --- a/test/Index/comment-objc-decls.m +++ b/test/Index/comment-objc-decls.m @@ -20,19 +20,19 @@ * \param[in] range output value is unsigned int * \result return index */ -- (unsigned int)MethodMyProto:(id)anObject inRange:(unsigned int)range; +- (unsigned int)MethodMyProto:(nullable id)anObject inRange:(unsigned int)range; /** * \brief PropertyMyProto - This is protocol's property. */ -@property (copy) id PropertyMyProto; +@property (copy, nonnull) id PropertyMyProto; /** * \brief ClassMethodMyProto */ + ClassMethodMyProto; @end // CHECK: <Declaration>@protocol MyProto\n@end</Declaration> -// CHECK: <Declaration>- (unsigned int)MethodMyProto:(id)anObject inRange:(unsigned int)range;</Declaration> -// CHECK: <Declaration>@optional\n@property(readwrite, copy, atomic) id PropertyMyProto;</Declaration> +// CHECK: <Declaration>- (unsigned int)MethodMyProto:(nullable id)anObject inRange:(unsigned int)range;</Declaration> +// CHECK: <Declaration>@optional\n@property(readwrite, copy, atomic, nonnull) id PropertyMyProto;</Declaration> // CHECK: <Declaration>+ (id)ClassMethodMyProto;</Declaration> /** diff --git a/test/Index/complete-method-decls.m b/test/Index/complete-method-decls.m index eceaa833fc3e..0e3780ba3d5f 100644 --- a/test/Index/complete-method-decls.m +++ b/test/Index/complete-method-decls.m @@ -82,6 +82,14 @@ typedef A *MyObjectRef; @end @implementation I1 +-(void)foo {} +@end + +@interface I2 +-(nonnull I2 *)produceI2:(nullable I2 *)i2; +@end + +@implementation I2 - @end @@ -153,6 +161,8 @@ typedef A *MyObjectRef; // CHECK-CCF: NotImplemented:{TypedText byref} (40) // CHECK-CCF: NotImplemented:{TypedText in} (40) // CHECK-CCF: NotImplemented:{TypedText inout} (40) +// CHECK-CCF: NotImplemented:{TypedText nonnull} (40) +// CHECK-CCF: NotImplemented:{TypedText nullable} (40) // CHECK-CCF: NotImplemented:{TypedText oneway} (40) // CHECK-CCF: NotImplemented:{TypedText out} (40) // CHECK-CCF: NotImplemented:{TypedText unsigned} (50) @@ -201,3 +211,6 @@ typedef A *MyObjectRef; // FIXME: It should be "MyObject <P1> *"" // CHECK-CLASSTY: ObjCInstanceMethodDecl:{LeftParen (}{Text A<P1> *}{RightParen )}{TypedText meth2} // CHECK-CLASSTY: ObjCInstanceMethodDecl:{LeftParen (}{Text MyObjectRef}{RightParen )}{TypedText meth3} + +// RUN: c-index-test -code-completion-at=%s:93:2 %s | FileCheck -check-prefix=CHECK-NULLABILITY %s +// CHECK-NULLABILITY: ObjCInstanceMethodDecl:{LeftParen (}{Text nonnull }{Text I2 *}{RightParen )}{TypedText produceI2}{TypedText :}{LeftParen (}{Text nullable }{Text I2 *}{RightParen )}{Text i2} (40) diff --git a/test/Index/complete-objc-message.m b/test/Index/complete-objc-message.m index 5a7200570bec..a62b49194e83 100644 --- a/test/Index/complete-objc-message.m +++ b/test/Index/complete-objc-message.m @@ -189,6 +189,14 @@ void test_DO(DO *d, A* a) { [d method:a aout:&a]; } +@interface Nullability +- (nonnull A *)method:(nullable A *)param; +@end + +void test_Nullability(Nullability *n, A* a) { + [n method: a]; +} + // RUN: c-index-test -code-completion-at=%s:23:19 %s | FileCheck -check-prefix=CHECK-CC1 %s // CHECK-CC1: {TypedText categoryClassMethod} (35) // CHECK-CC1: {TypedText classMethod1:}{Placeholder (id)}{HorizontalSpace }{TypedText withKeyword:}{Placeholder (int)} (35) @@ -335,3 +343,6 @@ void test_DO(DO *d, A* a) { // RUN: c-index-test -code-completion-at=%s:189:6 %s | FileCheck -check-prefix=CHECK-DISTRIB-OBJECTS %s // CHECK-DISTRIB-OBJECTS: ObjCInstanceMethodDecl:{ResultType void}{TypedText method:}{Placeholder (in bycopy A *)}{HorizontalSpace }{TypedText result:}{Placeholder (out byref A **)} (35) + +// RUN: c-index-test -code-completion-at=%s:197:6 %s | FileCheck -check-prefix=CHECK-NULLABLE %s +// CHECK-NULLABLE: ObjCInstanceMethodDecl:{ResultType A * __nonnull}{TypedText method:}{Placeholder (nullable A *)} diff --git a/test/Index/complete-property-flags.m b/test/Index/complete-property-flags.m index 13ec1e725f20..9e3fc1aff319 100644 --- a/test/Index/complete-property-flags.m +++ b/test/Index/complete-property-flags.m @@ -13,6 +13,10 @@ // CHECK-CC1-NEXT: {TypedText copy} // CHECK-CC1-NEXT: {TypedText getter}{Text =}{Placeholder method} // CHECK-CC1-NEXT: {TypedText nonatomic} +// CHECK-CC1: {TypedText nonnull} +// CHECK-CC1-NEXT: {TypedText null_resettable} +// CHECK-CC1-NEXT: {TypedText null_unspecified} +// CHECK-CC1-NEXT: {TypedText nullable} // CHECK-CC1-NEXT: {TypedText readonly} // CHECK-CC1-NEXT: {TypedText readwrite} // CHECK-CC1-NEXT: {TypedText retain} @@ -27,6 +31,10 @@ // CHECK-CC1-ARC-NEXT: {TypedText copy} // CHECK-CC1-ARC-NEXT: {TypedText getter}{Text =}{Placeholder method} // CHECK-CC1-ARC-NEXT: {TypedText nonatomic} +// CHECK-CC1-ARC-NEXT: {TypedText nonnull} +// CHECK-CC1-ARC-NEXT: {TypedText null_resettable} +// CHECK-CC1-ARC-NEXT: {TypedText null_unspecified} +// CHECK-CC1-ARC-NEXT: {TypedText nullable} // CHECK-CC1-ARC-NEXT: {TypedText readonly} // CHECK-CC1-ARC-NEXT: {TypedText readwrite} // CHECK-CC1-ARC-NEXT: {TypedText retain} @@ -38,6 +46,10 @@ // RUN: c-index-test -code-completion-at=%s:8:18 %s | FileCheck -check-prefix=CHECK-CC2 %s // CHECK-CC2: {TypedText getter}{Text =}{Placeholder method} // CHECK-CC2-NEXT: {TypedText nonatomic} +// CHECK-CC2-NEXT: {TypedText nonnull} +// CHECK-CC2-NEXT: {TypedText null_resettable} +// CHECK-CC2-NEXT: {TypedText null_unspecified} +// CHECK-CC2-NEXT: {TypedText nullable} // CHECK-CC2-NEXT: {TypedText readonly} // CHECK-CC2-NEXT: {TypedText readwrite} // CHECK-CC2-NEXT: {TypedText setter}{Text =}{Placeholder method} diff --git a/test/Index/complete-stmt.c b/test/Index/complete-stmt.c index 3d31ca2f908a..8bbfe2db56d8 100644 --- a/test/Index/complete-stmt.c +++ b/test/Index/complete-stmt.c @@ -16,6 +16,8 @@ void f(int x) { // CHECK-IF-ELSE-SIMPLE: NotImplemented:{TypedText else}{HorizontalSpace }{Text if}{HorizontalSpace }{LeftParen (}{Placeholder expression}{RightParen )} (40) // RUN: c-index-test -code-completion-at=%s:6:1 %s | FileCheck -check-prefix=CHECK-STMT %s +// CHECK-STMT: NotImplemented:{TypedText __nonnull} (50) +// CHECK-STMT: NotImplemented:{TypedText __nullable} (50) // CHECK-STMT: NotImplemented:{TypedText char} (50) // CHECK-STMT: NotImplemented:{TypedText const} (50) // CHECK-STMT: NotImplemented:{TypedText double} (50) diff --git a/test/Index/pch-depending-on-deleted-module.c b/test/Index/pch-depending-on-deleted-module.c index 4e85ff0f96b9..a0fbaf559fca 100644 --- a/test/Index/pch-depending-on-deleted-module.c +++ b/test/Index/pch-depending-on-deleted-module.c @@ -3,11 +3,11 @@ // RUN: rm -rf %t // RUN: mkdir %t -// RUN: %clang_cc1 -x c-header -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -emit-pch -I %S/Inputs/Headers -o %t/use_LibA.pch %s -// RUN: %clang_cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -I %S/Inputs/Headers -verify-pch %t/use_LibA.pch +// RUN: %clang_cc1 -x c-header -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -emit-pch -I %S/Inputs/Headers -o %t/use_LibA.pch %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -I %S/Inputs/Headers -verify-pch %t/use_LibA.pch // RUN: rm -f %t/modules-cache/LibA.pcm -// RUN: not %clang_cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -I %S/Inputs/Headers -verify-pch %t/use_LibA.pch 2>&1 | FileCheck -check-prefix=VERIFY %s -// RUN: not c-index-test -test-load-source all -x c -fmodules -Xclang -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -I %S/Inputs/Headers -include-pch %t/use_LibA.pch %s 2>&1 | FileCheck -check-prefix=INDEX %s +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -I %S/Inputs/Headers -verify-pch %t/use_LibA.pch 2>&1 | FileCheck -check-prefix=VERIFY %s +// RUN: not c-index-test -test-load-source all -x c -fmodules -fimplicit-module-maps -Xclang -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -I %S/Inputs/Headers -include-pch %t/use_LibA.pch %s 2>&1 | FileCheck -check-prefix=INDEX %s // VERIFY: fatal error: malformed or corrupted AST file: 'Unable to load module // INDEX: {{^}}Failure: AST deserialization error occurred{{$}} diff --git a/test/Lexer/has_feature_address_sanitizer.cpp b/test/Lexer/has_feature_address_sanitizer.cpp index 5c981161f9fc..406a2ab179a8 100644 --- a/test/Lexer/has_feature_address_sanitizer.cpp +++ b/test/Lexer/has_feature_address_sanitizer.cpp @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -E -fsanitize=address %s -o - | FileCheck --check-prefix=CHECK-ASAN %s +// RUN: %clang_cc1 -E -fsanitize=kernel-address %s -o - | FileCheck --check-prefix=CHECK-ASAN %s // RUN: %clang_cc1 -E %s -o - | FileCheck --check-prefix=CHECK-NO-ASAN %s #if __has_feature(address_sanitizer) diff --git a/test/Modules/Inputs/merge-class-definition-visibility/a.h b/test/Modules/Inputs/merge-class-definition-visibility/a.h new file mode 100644 index 000000000000..4c5cd949f234 --- /dev/null +++ b/test/Modules/Inputs/merge-class-definition-visibility/a.h @@ -0,0 +1 @@ +struct A {}; diff --git a/test/Modules/Inputs/merge-class-definition-visibility/b.h b/test/Modules/Inputs/merge-class-definition-visibility/b.h new file mode 100644 index 000000000000..2b8f5f868ed9 --- /dev/null +++ b/test/Modules/Inputs/merge-class-definition-visibility/b.h @@ -0,0 +1,2 @@ +// Include definition of A into the same module as c.h +#include "a.h" diff --git a/test/Modules/Inputs/merge-class-definition-visibility/c.h b/test/Modules/Inputs/merge-class-definition-visibility/c.h new file mode 100644 index 000000000000..27f503c2c607 --- /dev/null +++ b/test/Modules/Inputs/merge-class-definition-visibility/c.h @@ -0,0 +1 @@ +struct A; diff --git a/test/Modules/Inputs/merge-class-definition-visibility/d.h b/test/Modules/Inputs/merge-class-definition-visibility/d.h new file mode 100644 index 000000000000..2243de1baf9a --- /dev/null +++ b/test/Modules/Inputs/merge-class-definition-visibility/d.h @@ -0,0 +1 @@ +#include "a.h" diff --git a/test/Modules/Inputs/merge-class-definition-visibility/modmap b/test/Modules/Inputs/merge-class-definition-visibility/modmap new file mode 100644 index 000000000000..7d988fbba003 --- /dev/null +++ b/test/Modules/Inputs/merge-class-definition-visibility/modmap @@ -0,0 +1,7 @@ +module Def1 { + module B { header "b.h" } + module C { header "c.h" } +} +module Def2 { + header "d.h" +} diff --git a/test/Modules/Inputs/submodules-merge-defs/defs.h b/test/Modules/Inputs/submodules-merge-defs/defs.h index 68b57a4a62fe..247b05c47082 100644 --- a/test/Modules/Inputs/submodules-merge-defs/defs.h +++ b/test/Modules/Inputs/submodules-merge-defs/defs.h @@ -31,7 +31,7 @@ template<typename T> struct F { template<typename T> int F<T>::f() { return 0; } template<typename T> template<typename U> int F<T>::g() { return 0; } template<typename T> int F<T>::n = 0; -template<> template<typename U> int F<char>::g() { return 0; } +//template<> template<typename U> int F<char>::g() { return 0; } // FIXME: Re-enable this once we support merging member specializations. template<> struct F<void> { int h(); }; inline int F<void>::h() { return 0; } template<typename T> struct F<T *> { int i(); }; @@ -46,3 +46,31 @@ namespace G { template<typename T = int, int N = 3, template<typename> class K = F> int H(int a = 1); template<typename T = int, int N = 3, template<typename> class K = F> using I = decltype(H<T, N, K>()); +template<typename T = int, int N = 3, template<typename> class K = F> struct J {}; + +namespace NS { + struct A {}; + template<typename T> struct B : A {}; + template<typename T> struct B<T*> : B<char> {}; + template<> struct B<int> : B<int*> {}; + inline void f() {} +} + +namespace StaticInline { + struct X {}; + static inline void f(X); + static inline void g(X x) { f(x); } +} + +namespace FriendDefArg { + template<typename = int> struct A; + template<int = 0> struct B; + template<template<typename> class = A> struct C; + template<typename = int, int = 0, template<typename> class = A> struct D {}; + template<typename U> struct Y { + template<typename> friend struct A; + template<int> friend struct B; + template<template<typename> class> friend struct C; + template<typename, int, template<typename> class> friend struct D; + }; +} diff --git a/test/Modules/Inputs/submodules-merge-defs/indirect.h b/test/Modules/Inputs/submodules-merge-defs/indirect.h new file mode 100644 index 000000000000..28baa019b22f --- /dev/null +++ b/test/Modules/Inputs/submodules-merge-defs/indirect.h @@ -0,0 +1 @@ +#include "merged-defs.h" diff --git a/test/Modules/Inputs/submodules-merge-defs/module.modulemap b/test/Modules/Inputs/submodules-merge-defs/module.modulemap index 82abdb088f19..3b5493e2b8bb 100644 --- a/test/Modules/Inputs/submodules-merge-defs/module.modulemap +++ b/test/Modules/Inputs/submodules-merge-defs/module.modulemap @@ -2,6 +2,7 @@ module "stuff" { textual header "defs.h" module "empty" { header "empty.h" } module "use" { header "use-defs.h" } + module "use-2" { requires use_defs_twice header "use-defs-2.h" } } module "redef" { @@ -14,3 +15,8 @@ module "merged-defs" { header "merged-defs.h" use "stuff" } + +module "indirect" { + header "indirect.h" + use "merged-defs" +} diff --git a/test/Modules/Inputs/submodules-merge-defs/use-defs-2.h b/test/Modules/Inputs/submodules-merge-defs/use-defs-2.h new file mode 100644 index 000000000000..a78f08ab0d5d --- /dev/null +++ b/test/Modules/Inputs/submodules-merge-defs/use-defs-2.h @@ -0,0 +1,2 @@ +// use-defs-2.h +#include "defs.h" diff --git a/test/Modules/Inputs/submodules-merge-defs/use-defs.h b/test/Modules/Inputs/submodules-merge-defs/use-defs.h index 31c69c6a447d..2e883760b7a7 100644 --- a/test/Modules/Inputs/submodules-merge-defs/use-defs.h +++ b/test/Modules/Inputs/submodules-merge-defs/use-defs.h @@ -1 +1,2 @@ +// use-defs.h #include "defs.h" diff --git a/test/Modules/Inputs/template-default-args/a.h b/test/Modules/Inputs/template-default-args/a.h index 1ef1ea5907b5..be760fe6f1d5 100644 --- a/test/Modules/Inputs/template-default-args/a.h +++ b/test/Modules/Inputs/template-default-args/a.h @@ -2,3 +2,6 @@ template<typename T = int> struct A {}; template<typename T> struct B {}; template<typename T> struct C; template<typename T> struct D; +template<typename T> struct E; +template<typename T = int> struct G; +template<typename T = int> struct H; diff --git a/test/Modules/Inputs/template-default-args/c.h b/test/Modules/Inputs/template-default-args/c.h new file mode 100644 index 000000000000..2946013b6131 --- /dev/null +++ b/test/Modules/Inputs/template-default-args/c.h @@ -0,0 +1,2 @@ +template<typename T = int> struct F; +template<typename T, typename U> struct I; diff --git a/test/Modules/Inputs/template-default-args/module.modulemap b/test/Modules/Inputs/template-default-args/module.modulemap index 6182e6b3eee1..d54dfc345abf 100644 --- a/test/Modules/Inputs/template-default-args/module.modulemap +++ b/test/Modules/Inputs/template-default-args/module.modulemap @@ -1 +1,5 @@ -module X { module A { header "a.h" } module B { header "b.h" } } +module X { + module A { header "a.h" } + module B { header "b.h" } + module C { header "c.h" } +} diff --git a/test/Modules/Rmodule-build.m b/test/Modules/Rmodule-build.m index e8f293535178..5c27ec6dfd97 100644 --- a/test/Modules/Rmodule-build.m +++ b/test/Modules/Rmodule-build.m @@ -7,7 +7,7 @@ // RUN: echo 'module B { header "B.h" }' >> %t/module.modulemap // RUN: echo 'module C { header "C.h" }' >> %t/module.modulemap -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fsyntax-only %s -verify \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fsyntax-only %s -verify \ // RUN: -I %t -Rmodule-build @import A; // expected-remark{{building module 'A' as}} expected-remark {{finished building module 'A'}} @@ -16,19 +16,19 @@ @import B; // no diagnostic // RUN: echo ' ' >> %t/C.h -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fsyntax-only %s -I %t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fsyntax-only %s -I %t \ // RUN: -Rmodule-build 2>&1 | FileCheck %s // RUN: echo ' ' >> %t/C.h -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fsyntax-only %s -I %t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fsyntax-only %s -I %t \ // RUN: -Reverything 2>&1 | FileCheck %s // RUN: echo ' ' >> %t/B.h -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fsyntax-only %s -I %t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fsyntax-only %s -I %t \ // RUN: 2>&1 | FileCheck -allow-empty -check-prefix=NO-REMARKS %s // RUN: echo ' ' >> %t/B.h -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fsyntax-only %s -I %t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fsyntax-only %s -I %t \ // RUN: -Rmodule-build -Rno-everything 2>&1 | \ // RUN: FileCheck -allow-empty -check-prefix=NO-REMARKS %s diff --git a/test/Modules/Werror-Wsystem-headers.m b/test/Modules/Werror-Wsystem-headers.m index 4391aa027977..164c5b2ab672 100644 --- a/test/Modules/Werror-Wsystem-headers.m +++ b/test/Modules/Werror-Wsystem-headers.m @@ -3,17 +3,17 @@ // RUN: mkdir %t-saved // Initial module build -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -isystem %S/Inputs/System/usr/include -fsyntax-only %s -verify // RUN: cp %t/cstd.pcm %t-saved/cstd.pcm // Even with -Werror don't rebuild a system module -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -isystem %S/Inputs/System/usr/include -fsyntax-only %s -verify -Werror // RUN: diff %t/cstd.pcm %t-saved/cstd.pcm // Unless -Wsystem-headers is on -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -isystem %S/Inputs/System/usr/include -fsyntax-only %s -verify \ // RUN: -Werror=unused -Wsystem-headers // RUN: not diff %t/cstd.pcm %t-saved/cstd.pcm diff --git a/test/Modules/Werror.m b/test/Modules/Werror.m index 6444ea513b81..4c3f3ea74464 100644 --- a/test/Modules/Werror.m +++ b/test/Modules/Werror.m @@ -3,37 +3,37 @@ // RUN: mkdir -p %t-saved // Initial module build (-Werror=header-guard) -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -F %S/Inputs -fsyntax-only %s -verify -Wno-incomplete-umbrella \ // RUN: -Werror=header-guard // RUN: cp %t/Module.pcm %t-saved/Module.pcm // Building with looser -Werror options does not rebuild -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -F %S/Inputs -fsyntax-only %s -verify -Wno-incomplete-umbrella // RUN: diff %t/Module.pcm %t-saved/Module.pcm // Make the build more restricted (-Werror) -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -F %S/Inputs -fsyntax-only %s -verify -Wno-incomplete-umbrella \ // RUN: -Werror -Wno-incomplete-umbrella // RUN: not diff %t/Module.pcm %t-saved/Module.pcm // RUN: cp %t/Module.pcm %t-saved/Module.pcm // Ensure -Werror=header-guard is less strict than -Werror -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -F %S/Inputs -fsyntax-only %s -verify -Wno-incomplete-umbrella \ // RUN: -Werror=header-guard -Wno-incomplete-umbrella // RUN: diff %t/Module.pcm %t-saved/Module.pcm // But -Werror=unused is not, because some of its diags are DefaultIgnore -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -F %S/Inputs -fsyntax-only %s -verify -Wno-incomplete-umbrella \ // RUN: -Werror=unused // RUN: not diff %t/Module.pcm %t-saved/Module.pcm // RUN: cp %t/Module.pcm %t-saved/Module.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -F %S/Inputs -fsyntax-only %s -verify -Wno-incomplete-umbrella \ // RUN: -Werror -Wno-incomplete-umbrella @@ -42,30 +42,30 @@ // RUN-DISABLED: diff %t/Module.pcm %t-saved/Module.pcm // -Wno-everything, -Werror -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -F %S/Inputs -fsyntax-only %s -verify -Wno-incomplete-umbrella \ // RUN: -Wno-everything -Wall -Werror // RUN: cp %t/Module.pcm %t-saved/Module.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -F %S/Inputs -fsyntax-only %s -verify -Wno-incomplete-umbrella \ // RUN: -Wall -Werror // RUN: not diff %t/Module.pcm %t-saved/Module.pcm // -pedantic, -Werror is not compatible with -Wall -Werror -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -F %S/Inputs -fsyntax-only %s -verify -Wno-incomplete-umbrella \ // RUN: -Werror -pedantic // RUN: not diff %t/Module.pcm %t-saved/Module.pcm // RUN: cp %t/Module.pcm %t-saved/Module.pcm // -pedantic-errors is less strict that -pedantic, -Werror -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -F %S/Inputs -fsyntax-only %s -verify -Wno-incomplete-umbrella \ // RUN: -pedantic-errors // RUN: diff %t/Module.pcm %t-saved/Module.pcm // -Wsystem-headers does not affect non-system modules -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -F %S/Inputs -fsyntax-only %s -verify -Wno-incomplete-umbrella \ // RUN: -pedantic-errors -Wsystem-headers // RUN: diff %t/Module.pcm %t-saved/Module.pcm diff --git a/test/Modules/add-remove-private.m b/test/Modules/add-remove-private.m index 49e81e11141d..dc73a096c807 100644 --- a/test/Modules/add-remove-private.m +++ b/test/Modules/add-remove-private.m @@ -4,20 +4,20 @@ // RUN: cp -r %S/Inputs/AddRemovePrivate.framework %t/AddRemovePrivate.framework // Build with module.private.modulemap -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t.mcp -fdisable-module-hash -F %t %s -verify -DP +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -fdisable-module-hash -F %t %s -verify -DP // RUN: cp %t.mcp/AddRemovePrivate.pcm %t/with.pcm // Build without module.private.modulemap // RUN: rm %t/AddRemovePrivate.framework/Modules/module.private.modulemap -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t.mcp -fdisable-module-hash -F %t %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -fdisable-module-hash -F %t %s -verify // RUN: not diff %t.mcp/AddRemovePrivate.pcm %t/with.pcm // RUN: cp %t.mcp/AddRemovePrivate.pcm %t/without.pcm -// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t.mcp -fdisable-module-hash -F %t %s -DP 2>&1 | FileCheck %s +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -fdisable-module-hash -F %t %s -DP 2>&1 | FileCheck %s // CHECK: no submodule named 'Private' // Build with module.private.modulemap (again) // RUN: cp %S/Inputs/AddRemovePrivate.framework/Modules/module.private.modulemap %t/AddRemovePrivate.framework/Modules/module.private.modulemap -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t.mcp -fdisable-module-hash -F %t %s -verify -DP +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -fdisable-module-hash -F %t %s -verify -DP // RUN: not diff %t.mcp/AddRemovePrivate.pcm %t/without.pcm // expected-no-diagnostics diff --git a/test/Modules/anon-namespace.cpp b/test/Modules/anon-namespace.cpp index 6c085ebc8858..dc25c91ac0c4 100644 --- a/test/Modules/anon-namespace.cpp +++ b/test/Modules/anon-namespace.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/anon-namespace -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/anon-namespace -verify %s // expected-no-diagnostics #include "b1.h" #include "c.h" diff --git a/test/Modules/attr-unavailable.m b/test/Modules/attr-unavailable.m index 0188a84d9816..b7954ca4cef2 100644 --- a/test/Modules/attr-unavailable.m +++ b/test/Modules/attr-unavailable.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/attr-unavailable %s -fsyntax-only -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/attr-unavailable %s -fsyntax-only -verify @import two; void f(id x) { diff --git a/test/Modules/auto-module-import.m b/test/Modules/auto-module-import.m index bf9937778631..de2c355a4247 100644 --- a/test/Modules/auto-module-import.m +++ b/test/Modules/auto-module-import.m @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -F %S/Inputs %s -verify -DERRORS -// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -F %S/Inputs %s -verify +// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify -DERRORS +// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify // // Test both with and without the declarations that refer to unimported // entities. For error recovery, those cases implicitly trigger an import. diff --git a/test/Modules/autolink.m b/test/Modules/autolink.m index e6507703be96..28b9e40678f6 100644 --- a/test/Modules/autolink.m +++ b/test/Modules/autolink.m @@ -1,7 +1,7 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -emit-pch -fmodules-cache-path=%t -fmodules -o %t.pch -I %S/Inputs -x objective-c-header %S/Inputs/autolink-sub3.pch -// RUN: %clang_cc1 -emit-llvm -o - -fmodules-cache-path=%t -fmodules -F %S/Inputs -I %S/Inputs -include-pch %t.pch %s | FileCheck %s -// RUN: %clang_cc1 -emit-llvm -fno-autolink -o - -fmodules-cache-path=%t -fmodules -F %S/Inputs -I %S/Inputs -include-pch %t.pch %s | FileCheck --check-prefix=CHECK-AUTOLINK-DISABLED %s +// RUN: %clang_cc1 -emit-pch -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -o %t.pch -I %S/Inputs -x objective-c-header %S/Inputs/autolink-sub3.pch +// RUN: %clang_cc1 -emit-llvm -o - -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -I %S/Inputs -include-pch %t.pch %s | FileCheck %s +// RUN: %clang_cc1 -emit-llvm -fno-autolink -o - -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -I %S/Inputs -include-pch %t.pch %s | FileCheck --check-prefix=CHECK-AUTOLINK-DISABLED %s @import autolink.sub2; diff --git a/test/Modules/build-fail-notes.m b/test/Modules/build-fail-notes.m index e27341154d79..47bdbc7fca6c 100644 --- a/test/Modules/build-fail-notes.m +++ b/test/Modules/build-fail-notes.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: not %clang_cc1 -fmodules-cache-path=%t -fmodules -F %S/Inputs -DgetModuleVersion="epic fail" %s 2>&1 | FileCheck %s +// RUN: not %clang_cc1 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -DgetModuleVersion="epic fail" %s 2>&1 | FileCheck %s @import DependsOnModule; @@ -11,14 +11,14 @@ // CHECK: fatal error: could not build module 'DependsOnModule' // CHECK-NOT: error: -// RUN: not %clang_cc1 -fmodules-cache-path=%t -fmodules -F %S/Inputs %s -fdiagnostics-show-note-include-stack 2>&1 | FileCheck -check-prefix=CHECK-REDEF %s +// RUN: not %clang_cc1 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -fdiagnostics-show-note-include-stack 2>&1 | FileCheck -check-prefix=CHECK-REDEF %s extern int Module; // CHECK-REDEF: In module 'DependsOnModule' imported from // CHECK-REDEF: In module 'Module' imported from // CHECK-REDEF: Module.h:15:12: note: previous definition is here -// RUN: not %clang_cc1 -Wincomplete-umbrella -fmodules-cache-path=%t -fmodules -F %S/Inputs -DgetModuleVersion="epic fail" -serialize-diagnostic-file %t/tmp.diag %s 2>&1 +// RUN: not %clang_cc1 -Wincomplete-umbrella -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -DgetModuleVersion="epic fail" -serialize-diagnostic-file %t/tmp.diag %s 2>&1 // RUN: c-index-test -read-diagnostics %t/tmp.diag 2>&1 | FileCheck -check-prefix=CHECK-SDIAG %s // CHECK-SDIAG: Module.h:9:13: error: expected ';' after top level declarator diff --git a/test/Modules/builtins.m b/test/Modules/builtins.m index 40b4f9c74395..c095f4f01645 100644 --- a/test/Modules/builtins.m +++ b/test/Modules/builtins.m @@ -12,5 +12,5 @@ int bar() { // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -I %S/Inputs %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs %s -verify // expected-no-diagnostics diff --git a/test/Modules/compiler_builtins.m b/test/Modules/compiler_builtins.m index f120bcfd9824..bffbcc6ddee5 100644 --- a/test/Modules/compiler_builtins.m +++ b/test/Modules/compiler_builtins.m @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang -fsyntax-only -fmodules -fmodules-cache-path=%t -D__need_wint_t %s -I%S/Inputs/System/usr/include -Xclang -verify -// RUN: %clang -fsyntax-only -std=c99 -fmodules -fmodules-cache-path=%t -D__need_wint_t %s -I%S/Inputs/System/usr/include -Xclang -verify +// RUN: %clang_cc1 -fsyntax-only -fmodules -fimplicit-module-maps -fmodules-cache-path=%t %s -I%S/Inputs/System/usr/include -verify +// RUN: %clang_cc1 -fsyntax-only -std=c99 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t %s -I%S/Inputs/System/usr/include -verify // expected-no-diagnostics #ifdef __SSE__ diff --git a/test/Modules/compiler_builtins_arm.m b/test/Modules/compiler_builtins_arm.m index 5da6a12fb3a6..ccfceaa93f88 100644 --- a/test/Modules/compiler_builtins_arm.m +++ b/test/Modules/compiler_builtins_arm.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fsyntax-only -triple thumbv7-none-linux-gnueabihf -target-abi aapcs -target-cpu cortex-a8 -mfloat-abi hard -std=c99 -fmodules -fmodules-cache-path=%t -D__need_wint_t %s -verify +// RUN: %clang_cc1 -fsyntax-only -triple thumbv7-none-linux-gnueabihf -target-abi aapcs -target-cpu cortex-a8 -mfloat-abi hard -std=c99 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -D__need_wint_t %s -verify // expected-no-diagnostics @import _Builtin_intrinsics.arm.neon; diff --git a/test/Modules/config_macros.m b/test/Modules/config_macros.m index b147317bf60d..5c54ba97a17b 100644 --- a/test/Modules/config_macros.m +++ b/test/Modules/config_macros.m @@ -23,6 +23,6 @@ char *test_bar() { @import config; // expected-warning{{definition of configuration macro 'WANT_BAR' has no effect on the import of 'config'; pass '-DWANT_BAR=...' on the command line to configure the module}} // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -DWANT_FOO=1 -emit-module -fmodule-name=config %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs -DWANT_FOO=1 %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -DWANT_FOO=1 -emit-module -fmodule-name=config %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -DWANT_FOO=1 %s -verify diff --git a/test/Modules/conflicts.m b/test/Modules/conflicts.m index 2388e6f1d1cf..d619721f72b3 100644 --- a/test/Modules/conflicts.m +++ b/test/Modules/conflicts.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -I %S/Inputs/Conflicts %s -verify +// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/Conflicts %s -verify @import Conflicts; diff --git a/test/Modules/crashes.m b/test/Modules/crashes.m index edefd379e8a5..c785bd19f229 100644 --- a/test/Modules/crashes.m +++ b/test/Modules/crashes.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t.mcp -// RUN: %clang_cc1 -fmodules-cache-path=%t.mcp -fmodules -F %S/Inputs -fobjc-arc %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t.mcp -fmodules -fimplicit-module-maps -F %S/Inputs -fobjc-arc %s -verify @import Module; diff --git a/test/Modules/cstd.m b/test/Modules/cstd.m index 200779a0f3d7..7df727d2efcb 100644 --- a/test/Modules/cstd.m +++ b/test/Modules/cstd.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fsyntax-only -isystem %S/Inputs/System/usr/include -ffreestanding -fmodules -fmodules-cache-path=%t -D__need_wint_t -Werror=implicit-function-declaration %s +// RUN: %clang_cc1 -fsyntax-only -isystem %S/Inputs/System/usr/include -ffreestanding -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -D__need_wint_t -Werror=implicit-function-declaration %s @import uses_other_constants; const double other_value = DBL_MAX; diff --git a/test/Modules/cxx-decls.cpp b/test/Modules/cxx-decls.cpp index 4064040c1257..2e606078c055 100644 --- a/test/Modules/cxx-decls.cpp +++ b/test/Modules/cxx-decls.cpp @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 -// RUN: %clang_cc1 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -ast-dump -ast-dump-filter merge -std=c++11 | FileCheck %s +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -ast-dump -ast-dump-filter merge -std=c++11 | FileCheck %s // expected-no-diagnostics diff --git a/test/Modules/cxx-dtor.cpp b/test/Modules/cxx-dtor.cpp index ead67ec334e7..63427ee0afda 100644 --- a/test/Modules/cxx-dtor.cpp +++ b/test/Modules/cxx-dtor.cpp @@ -1,3 +1,3 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x c++ -std=c++11 -fmodules-cache-path=%t -I %S/Inputs/cxx-dtor -emit-llvm-only %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x c++ -std=c++11 -fmodules-cache-path=%t -I %S/Inputs/cxx-dtor -emit-llvm-only %s #include "b.h" diff --git a/test/Modules/cxx-inline-namespace.cpp b/test/Modules/cxx-inline-namespace.cpp index f67d43b6843a..36b58ee611c7 100644 --- a/test/Modules/cxx-inline-namespace.cpp +++ b/test/Modules/cxx-inline-namespace.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 @import cxx_inline_namespace; @import cxx_inline_namespace_b; diff --git a/test/Modules/cxx-irgen.cpp b/test/Modules/cxx-irgen.cpp index 13902bf92622..37de23fd2548 100644 --- a/test/Modules/cxx-irgen.cpp +++ b/test/Modules/cxx-irgen.cpp @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c++ -std=c++11 -fmodules-cache-path=%t -I %S/Inputs -triple %itanium_abi_triple -disable-llvm-optzns -emit-llvm -o - %s | FileCheck %s -// RUN: %clang_cc1 -fmodules -x objective-c++ -std=c++11 -fmodules-cache-path=%t -I %S/Inputs -triple %itanium_abi_triple -disable-llvm-optzns -emit-llvm -g -o - %s | FileCheck %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -std=c++11 -fmodules-cache-path=%t -I %S/Inputs -triple %itanium_abi_triple -disable-llvm-optzns -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -std=c++11 -fmodules-cache-path=%t -I %S/Inputs -triple %itanium_abi_triple -disable-llvm-optzns -emit-llvm -g -o - %s | FileCheck %s // FIXME: When we have a syntax for modules in C++, use that. @import cxx_irgen_top; diff --git a/test/Modules/cxx-linkage-cache.cpp b/test/Modules/cxx-linkage-cache.cpp index 296cc8034f5a..3ce55b4f6b8c 100644 --- a/test/Modules/cxx-linkage-cache.cpp +++ b/test/Modules/cxx-linkage-cache.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 @import cxx_linkage_cache; diff --git a/test/Modules/cxx-lookup.cpp b/test/Modules/cxx-lookup.cpp index bd019c7f4ae4..f3e272009fce 100644 --- a/test/Modules/cxx-lookup.cpp +++ b/test/Modules/cxx-lookup.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t %s -I%S/Inputs/cxx-lookup -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t %s -I%S/Inputs/cxx-lookup -verify // expected-no-diagnostics namespace llvm {} #include "c2.h" diff --git a/test/Modules/cxx-many-overloads.cpp b/test/Modules/cxx-many-overloads.cpp index 205a79cdf9e1..445245f37f51 100644 --- a/test/Modules/cxx-many-overloads.cpp +++ b/test/Modules/cxx-many-overloads.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify // expected-no-diagnostics @import cxx_many_overloads; diff --git a/test/Modules/cxx-templates.cpp b/test/Modules/cxx-templates.cpp index 00fc38b52209..d0f5a145a18a 100644 --- a/test/Modules/cxx-templates.cpp +++ b/test/Modules/cxx-templates.cpp @@ -1,9 +1,9 @@ // RUN: rm -rf %t -// RUN: not %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump-lookups | FileCheck %s --check-prefix=CHECK-GLOBAL -// RUN: not %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump-lookups -ast-dump-filter N | FileCheck %s --check-prefix=CHECK-NAMESPACE-N -// RUN: not %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump -ast-dump-filter SomeTemplate | FileCheck %s --check-prefix=CHECK-DUMP -// RUN: %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 -// RUN: %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 -DEARLY_IMPORT +// RUN: not %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump-lookups | FileCheck %s --check-prefix=CHECK-GLOBAL +// RUN: not %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump-lookups -ast-dump-filter N | FileCheck %s --check-prefix=CHECK-NAMESPACE-N +// RUN: not %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump -ast-dump-filter SomeTemplate | FileCheck %s --check-prefix=CHECK-DUMP +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 -DEARLY_IMPORT #ifdef EARLY_IMPORT #include "cxx-templates-textual.h" diff --git a/test/Modules/cycles.c b/test/Modules/cycles.c index 47728d814c29..81495b57064c 100644 --- a/test/Modules/cycles.c +++ b/test/Modules/cycles.c @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: not %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -F %S/Inputs %s 2>&1 | FileCheck %s +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -F %S/Inputs %s 2>&1 | FileCheck %s // FIXME: When we have a syntax for modules in C, use that. @import MutuallyRecursive1; diff --git a/test/Modules/declare-use-compatible.cpp b/test/Modules/declare-use-compatible.cpp index 4c3d79bd71c9..a2e7f01c6c1d 100644 --- a/test/Modules/declare-use-compatible.cpp +++ b/test/Modules/declare-use-compatible.cpp @@ -1,33 +1,33 @@ // Used module not built with -decluse. // RUN: rm -rf %t -// RUN: %clang_cc1 -x c++ -fmodules -fmodule-name=XB -emit-module \ +// RUN: %clang_cc1 -x c++ -fmodules -fimplicit-module-maps -fmodule-name=XB -emit-module \ // RUN: -I %S/Inputs/declare-use %S/Inputs/declare-use/module.map -o %t/b.pcm -// RUN: %clang_cc1 -x c++ -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -x c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -fmodules-decluse \ // RUN: -fmodule-file=%t/b.pcm -fmodule-name=XE -I %S/Inputs/declare-use %s // // Main module not built with -decluse. // RUN: rm -rf %t -// RUN: %clang_cc1 -x c++ -fmodules -fmodule-name=XB -emit-module \ +// RUN: %clang_cc1 -x c++ -fmodules -fimplicit-module-maps -fmodule-name=XB -emit-module \ // RUN: -fmodules-decluse \ // RUN: -I %S/Inputs/declare-use %S/Inputs/declare-use/module.map -o %t/b.pcm -// RUN: %clang_cc1 -x c++ -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -x c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -fmodule-file=%t/b.pcm -fmodule-name=XE -I %S/Inputs/declare-use %s // // Used module not built with -decluse. // RUN: rm -rf %t -// RUN: %clang_cc1 -x c++ -fmodules -fmodule-name=XB -emit-module \ +// RUN: %clang_cc1 -x c++ -fmodules -fimplicit-module-maps -fmodule-name=XB -emit-module \ // RUN: -I %S/Inputs/declare-use %S/Inputs/declare-use/module.map -o %t/b.pcm -// RUN: %clang_cc1 -x c++ -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -x c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -fmodules-strict-decluse \ // RUN: -fmodule-file=%t/b.pcm -fmodule-name=XE -I %S/Inputs/declare-use %s // // Main module not built with -decluse. // RUN: rm -rf %t -// RUN: %clang_cc1 -x c++ -fmodules -fmodule-name=XB -emit-module \ +// RUN: %clang_cc1 -x c++ -fmodules -fimplicit-module-maps -fmodule-name=XB -emit-module \ // RUN: -fmodules-strict-decluse \ // RUN: -I %S/Inputs/declare-use %S/Inputs/declare-use/module.map -o %t/b.pcm -// RUN: %clang_cc1 -x c++ -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -x c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -fmodule-file=%t/b.pcm -fmodule-name=XE -I %S/Inputs/declare-use %s #include "b.h" diff --git a/test/Modules/declare-use1.cpp b/test/Modules/declare-use1.cpp index adba59556f8d..492f97a5ebe9 100644 --- a/test/Modules/declare-use1.cpp +++ b/test/Modules/declare-use1.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodule-maps -fmodules-cache-path=%t -fmodules-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify +// RUN: %clang_cc1 -fimplicit-module-maps -fmodules-cache-path=%t -fmodules-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify #include "g.h" #include "e.h" diff --git a/test/Modules/declare-use2.cpp b/test/Modules/declare-use2.cpp index 45352891685d..12689e9d9683 100644 --- a/test/Modules/declare-use2.cpp +++ b/test/Modules/declare-use2.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodule-maps -fmodules-cache-path=%t -fmodules-decluse -fmodule-name=XH -I %S/Inputs/declare-use %s -verify +// RUN: %clang_cc1 -fimplicit-module-maps -fmodules-cache-path=%t -fmodules-decluse -fmodule-name=XH -I %S/Inputs/declare-use %s -verify #include "h.h" #include "e.h" diff --git a/test/Modules/declare-use3.cpp b/test/Modules/declare-use3.cpp index 8b0bbfa756c3..baa6c77bad13 100644 --- a/test/Modules/declare-use3.cpp +++ b/test/Modules/declare-use3.cpp @@ -1,4 +1,4 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -include "g.h" -include "e.h" -include "f.h" -include "i.h" -fmodule-maps -fmodules-cache-path=%t -fmodules-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify +// RUN: %clang_cc1 -include "g.h" -include "e.h" -include "f.h" -include "i.h" -fimplicit-module-maps -fmodules-cache-path=%t -fmodules-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify // expected-error {{module XG does not depend on a module exporting 'f.h'}} const int g2 = g1 + e + f + aux_i; diff --git a/test/Modules/declare-use4.cpp b/test/Modules/declare-use4.cpp index 1d346469f1ef..621422f0109b 100644 --- a/test/Modules/declare-use4.cpp +++ b/test/Modules/declare-use4.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodule-maps -fmodules-cache-path=%t -fmodules-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify +// RUN: %clang_cc1 -fimplicit-module-maps -fmodules-cache-path=%t -fmodules-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify #define ALLOWED_INC "b.h" diff --git a/test/Modules/declare-use5.cpp b/test/Modules/declare-use5.cpp index b34be0f1104b..db52f69c0175 100644 --- a/test/Modules/declare-use5.cpp +++ b/test/Modules/declare-use5.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodule-maps -fmodules-cache-path=%t -fmodules-decluse -fmodule-name=XN -I %S/Inputs/declare-use %s -verify +// RUN: %clang_cc1 -fimplicit-module-maps -fmodules-cache-path=%t -fmodules-decluse -fmodule-name=XN -I %S/Inputs/declare-use %s -verify #include "sub.h" diff --git a/test/Modules/decldef.m b/test/Modules/decldef.m index efd2d7c42c83..420c6774ecba 100644 --- a/test/Modules/decldef.m +++ b/test/Modules/decldef.m @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_EARLY -// RUN: %clang_cc1 -fmodules -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_EARLY +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify // expected-note@Inputs/def.h:5 {{previous}} diff --git a/test/Modules/decldef.mm b/test/Modules/decldef.mm index 2e2bd8a75e20..ab271fc2ba95 100644 --- a/test/Modules/decldef.mm +++ b/test/Modules/decldef.mm @@ -1,8 +1,8 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_1 -DUSE_2 -DUSE_3 -DUSE_4 -// RUN: %clang_cc1 -fmodules -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_2 -DUSE_3 -DUSE_4 -// RUN: %clang_cc1 -fmodules -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_3 -DUSE_4 -// RUN: %clang_cc1 -fmodules -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_4 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_1 -DUSE_2 -DUSE_3 -DUSE_4 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_2 -DUSE_3 -DUSE_4 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_3 -DUSE_4 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_4 // expected-note@Inputs/def.h:5 0-1{{previous}} // expected-note@Inputs/def.h:16 0-1{{previous}} diff --git a/test/Modules/deferred-lookup.cpp b/test/Modules/deferred-lookup.cpp index aaac389da0dc..ac9464a26fb4 100644 --- a/test/Modules/deferred-lookup.cpp +++ b/test/Modules/deferred-lookup.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/deferred-lookup -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/deferred-lookup -verify %s // expected-no-diagnostics namespace N { int f(int); } diff --git a/test/Modules/dependency-dump-dependent-module.m b/test/Modules/dependency-dump-dependent-module.m index 3b04435dd594..df7f5326bb6c 100644 --- a/test/Modules/dependency-dump-dependent-module.m +++ b/test/Modules/dependency-dump-dependent-module.m @@ -2,7 +2,7 @@ // files for both. // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t/cache -module-dependency-dir %t/vfs -F %S/Inputs -I %S/Inputs -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -module-dependency-dir %t/vfs -F %S/Inputs -I %S/Inputs -verify %s // expected-no-diagnostics // RUN: FileCheck %s -check-prefix=VFS < %t/vfs/vfs.yaml diff --git a/test/Modules/dependency-dump.m b/test/Modules/dependency-dump.m index 630af4950c18..f3a487544b8e 100644 --- a/test/Modules/dependency-dump.m +++ b/test/Modules/dependency-dump.m @@ -2,7 +2,7 @@ // for the same. // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t/cache -module-dependency-dir %t/vfs -F %S/Inputs -I %S/Inputs -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -module-dependency-dir %t/vfs -F %S/Inputs -I %S/Inputs -verify %s // expected-no-diagnostics // RUN: FileCheck %s -check-prefix=VFS -input-file %t/vfs/vfs.yaml diff --git a/test/Modules/dependency-gen-inferred-map.m b/test/Modules/dependency-gen-inferred-map.m index 11cc87288115..cebfeea4f40b 100644 --- a/test/Modules/dependency-gen-inferred-map.m +++ b/test/Modules/dependency-gen-inferred-map.m @@ -1,7 +1,7 @@ // Test that the virtual file "__inferred_module.map" doesn't show up as dependency. // RUN: rm -rf %t-mcp -// RUN: %clang_cc1 -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -dependency-file %t.d -MT %s.o -F %S/Inputs -fsyntax-only -fmodules -fmodules-cache-path=%t-mcp %s +// RUN: %clang_cc1 -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -dependency-file %t.d -MT %s.o -F %S/Inputs -fsyntax-only -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-mcp %s // RUN: FileCheck %s < %t.d // CHECK-NOT: __inferred_module diff --git a/test/Modules/dependency-gen-pch.m b/test/Modules/dependency-gen-pch.m index 65e22d485dd2..697b42947afa 100644 --- a/test/Modules/dependency-gen-pch.m +++ b/test/Modules/dependency-gen-pch.m @@ -1,7 +1,7 @@ // RUN: rm -rf %t-mcp // RUN: mkdir -p %t-mcp -// RUN: %clang_cc1 -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -module-file-deps -dependency-file %t.d -MT %s.o -I %S/Inputs -fmodules -fdisable-module-hash -fmodules-cache-path=%t-mcp -emit-pch -o %t.pch %s +// RUN: %clang_cc1 -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -module-file-deps -dependency-file %t.d -MT %s.o -I %S/Inputs -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t-mcp -emit-pch -o %t.pch %s // RUN: FileCheck %s < %t.d // CHECK: dependency-gen-pch.m.o // CHECK-NEXT: dependency-gen-pch.m diff --git a/test/Modules/dependency-gen.m b/test/Modules/dependency-gen.m index d3d66bfaab21..60a7192ed5a1 100644 --- a/test/Modules/dependency-gen.m +++ b/test/Modules/dependency-gen.m @@ -1,7 +1,7 @@ // RUN: rm -rf %t-mcp // RUN: mkdir -p %t-mcp -// RUN: %clang_cc1 -x objective-c -isystem %S/Inputs/System/usr/include -dependency-file %t.d.1 -MT %s.o -I %S/Inputs -fsyntax-only -fmodules -fmodules-cache-path=%t-mcp %s +// RUN: %clang_cc1 -x objective-c -isystem %S/Inputs/System/usr/include -dependency-file %t.d.1 -MT %s.o -I %S/Inputs -fsyntax-only -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-mcp %s // RUN: FileCheck %s < %t.d.1 // CHECK: dependency-gen.m // CHECK: Inputs{{.}}diamond_top.h @@ -10,7 +10,7 @@ // CHECK-NOT: stdint.h -// RUN: %clang_cc1 -x objective-c -isystem %S/Inputs/System/usr/include -dependency-file %t.d.2 -MT %s.o -I %S/Inputs -sys-header-deps -fsyntax-only -fmodules -fmodules-cache-path=%t-mcp %s +// RUN: %clang_cc1 -x objective-c -isystem %S/Inputs/System/usr/include -dependency-file %t.d.2 -MT %s.o -I %S/Inputs -sys-header-deps -fsyntax-only -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-mcp %s // RUN: FileCheck %s -check-prefix=CHECK-SYS < %t.d.2 // CHECK-SYS: dependency-gen.m // CHECK-SYS: Inputs{{.}}diamond_top.h diff --git a/test/Modules/dependency-gen.modulemap b/test/Modules/dependency-gen.modulemap index 6aa2e007ebb8..a71bfe993826 100644 --- a/test/Modules/dependency-gen.modulemap +++ b/test/Modules/dependency-gen.modulemap @@ -1,7 +1,7 @@ // RUN: cd %S // RUN: rm -f %t.cpm %t-base.pcm %t-base.d %t.d -// RUN: %clang_cc1 -I. -x c++ -fmodule-maps -fmodule-name=test-base -fno-modules-implicit-maps -fmodules -emit-module -fno-validate-pch -fmodules-strict-decluse Inputs/dependency-gen-base.modulemap -dependency-file %t-base.d -MT %t-base.pcm -o %t-base.pcm -fmodule-map-file-home-is-cwd -// RUN: %clang_cc1 -I. -x c++ -fmodule-maps -fmodule-name=test -fno-modules-implicit-maps -fmodules -emit-module -fno-validate-pch -fmodules-strict-decluse -fmodule-file=%t-base.pcm %s -dependency-file %t.d -MT %t.pcm -o %t.pcm -fmodule-map-file-home-is-cwd +// RUN: %clang_cc1 -I. -x c++ -fmodule-name=test-base -fmodules -emit-module -fno-validate-pch -fmodules-strict-decluse Inputs/dependency-gen-base.modulemap -dependency-file %t-base.d -MT %t-base.pcm -o %t-base.pcm -fmodule-map-file-home-is-cwd +// RUN: %clang_cc1 -I. -x c++ -fmodule-name=test -fmodules -emit-module -fno-validate-pch -fmodules-strict-decluse -fmodule-file=%t-base.pcm %s -dependency-file %t.d -MT %t.pcm -o %t.pcm -fmodule-map-file-home-is-cwd // RUN: FileCheck %s < %t.d module "test" { export * diff --git a/test/Modules/diag-pragma.c b/test/Modules/diag-pragma.c index 89435c176ed5..63be4bf93afc 100644 --- a/test/Modules/diag-pragma.c +++ b/test/Modules/diag-pragma.c @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diag_pragma %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -verify -fmodules-cache-path=%t -I %S/Inputs %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diag_pragma %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -verify -fmodules-cache-path=%t -I %S/Inputs %s // FIXME: When we have a syntax for modules in C, use that. @import diag_pragma; diff --git a/test/Modules/diamond-pch.c b/test/Modules/diamond-pch.c index f66ad877dee4..41cfd9c53b85 100644 --- a/test/Modules/diamond-pch.c +++ b/test/Modules/diamond-pch.c @@ -1,10 +1,10 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_top %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_left %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_right %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_bottom %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -emit-pch -fmodules-cache-path=%t -I %S/Inputs -o %t.pch %S/Inputs/diamond.h -// RUN: %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -include-pch %t.pch %s -I %S/Inputs -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_top %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_left %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_right %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_bottom %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -emit-pch -fmodules-cache-path=%t -I %S/Inputs -o %t.pch %S/Inputs/diamond.h +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -include-pch %t.pch %s -I %S/Inputs -verify // FIXME: When we have a syntax for modules in C, use that. void test_diamond(int i, float f, double d, char c) { diff --git a/test/Modules/diamond.c b/test/Modules/diamond.c index 8b824081a1e3..c2e009fbc1d9 100644 --- a/test/Modules/diamond.c +++ b/test/Modules/diamond.c @@ -1,9 +1,9 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_top %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_left %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_right %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_bottom %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -I %S/Inputs %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_top %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_left %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_right %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -emit-module -fmodules-cache-path=%t -fmodule-name=diamond_bottom %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -I %S/Inputs %s -verify // FIXME: When we have a syntax for modules in C, use that. @import diamond_bottom; diff --git a/test/Modules/direct-module-import.m b/test/Modules/direct-module-import.m index 00c13faccf43..3216eb908ab6 100644 --- a/test/Modules/direct-module-import.m +++ b/test/Modules/direct-module-import.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -F %S/Inputs -include Module/Module.h %s -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -include Module/Module.h %s -emit-llvm -o - | FileCheck %s // CHECK: call i8* @getModuleVersion const char* getVer(void) { diff --git a/test/Modules/driver.c b/test/Modules/driver.c index 79d1bbe13c07..34fc163a5ccd 100644 --- a/test/Modules/driver.c +++ b/test/Modules/driver.c @@ -1,5 +1,5 @@ -// RUN: %clang -fmodules %s -### 2>&1 | FileCheck -check-prefix CHECK-NO_MODULE_CACHE %s -// RUN: %clang -fmodules -fmodules-cache-path=blarg %s -### 2>&1 | FileCheck -check-prefix CHECK-WITH_MODULE_CACHE %s +// RUN: %clang -fmodules -fimplicit-module-maps %s -### 2>&1 | FileCheck -check-prefix CHECK-NO_MODULE_CACHE %s +// RUN: %clang -fmodules -fimplicit-module-maps -fmodules-cache-path=blarg %s -### 2>&1 | FileCheck -check-prefix CHECK-WITH_MODULE_CACHE %s // CHECK-NO_MODULE_CACHE: {{clang.*"-fmodules-cache-path=.*ModuleCache"}} diff --git a/test/Modules/empty.modulemap b/test/Modules/empty.modulemap index ef1d4a80ecfc..6350e2f63eb6 100644 --- a/test/Modules/empty.modulemap +++ b/test/Modules/empty.modulemap @@ -1,12 +1,12 @@ // RUN: rm -rf %t // // RUN: %clang_cc1 -fmodules -x c++ -fmodules-cache-path=%t \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -emit-module -fmodule-name=empty -o %t/base.pcm \ // RUN: %s // // RUN: %clang_cc1 -fmodules -x c++ -fmodules-cache-path=%t \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -emit-module -fmodule-name=empty -o %t/check.pcm \ // RUN: %s // diff --git a/test/Modules/epic-fail.m b/test/Modules/epic-fail.m index 7ce9571255f9..b368ceaec898 100644 --- a/test/Modules/epic-fail.m +++ b/test/Modules/epic-fail.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: not %clang_cc1 -fmodules-cache-path=%t -fmodules -F %S/Inputs -DgetModuleVersion="epic fail" %s 2>&1 | FileCheck %s +// RUN: not %clang_cc1 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -DgetModuleVersion="epic fail" %s 2>&1 | FileCheck %s @import Module; @import DependsOnModule; diff --git a/test/Modules/exclude-header.c b/test/Modules/exclude-header.c index 4134c82483d3..b3e6d8d6dd12 100644 --- a/test/Modules/exclude-header.c +++ b/test/Modules/exclude-header.c @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c -fmodules -fmodules-cache-path=%t -I %S/Inputs/exclude-header %s -verify +// RUN: %clang_cc1 -x objective-c -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/exclude-header %s -verify @import x; diff --git a/test/Modules/explicit-build-relpath.cpp b/test/Modules/explicit-build-relpath.cpp index f16556641d79..708c9fd208b8 100644 --- a/test/Modules/explicit-build-relpath.cpp +++ b/test/Modules/explicit-build-relpath.cpp @@ -4,38 +4,38 @@ // ---------------------- // Build modules A and B. -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-name=a -emit-module %S/Inputs/explicit-build/module.modulemap -o a.pcm // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-file=a.pcm \ // RUN: -fmodule-name=b -emit-module %S/Inputs/explicit-build/module.modulemap -o b-rel.pcm // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -fmodule-name=b -emit-module %S/Inputs/explicit-build/module.modulemap -o b-abs.pcm // ------------------------------------------ // Mix and match relative and absolute paths. -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -fmodule-file=a.pcm \ // RUN: -verify %s // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -fmodule-file=b-rel.pcm \ // RUN: -verify %s // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=a.pcm \ // RUN: -fmodule-file=b-abs.pcm \ // RUN: -verify %s // -// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=b-rel.pcm \ // RUN: -fmodule-file=b-abs.pcm \ diff --git a/test/Modules/explicit-build.cpp b/test/Modules/explicit-build.cpp index 6fe9f7ee46a3..01aa5dc68bf8 100644 --- a/test/Modules/explicit-build.cpp +++ b/test/Modules/explicit-build.cpp @@ -2,16 +2,16 @@ // ------------------------------- // Build chained modules A, B, and C -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-name=a -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/a.pcm \ // RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-IMPLICIT-BUILD %s --allow-empty // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -fmodule-name=b -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/b.pcm \ // RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-IMPLICIT-BUILD %s --allow-empty // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-file=%t/b.pcm \ // RUN: -fmodule-name=c -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/c.pcm \ // RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-IMPLICIT-BUILD %s --allow-empty @@ -20,7 +20,7 @@ // ------------------------------- // Build B with an implicit build of A -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-name=b -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/b-not-a.pcm \ // RUN: 2>&1 | FileCheck --check-prefix=CHECK-B-NO-A %s // @@ -29,36 +29,36 @@ // ------------------------------- // Check that we can use the explicitly-built A, B, and C modules. -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -verify %s -DHAVE_A // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-map-file=%S/Inputs/explicit-build/module.modulemap \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -verify %s -DHAVE_A // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=%t/b.pcm \ // RUN: -verify %s -DHAVE_A -DHAVE_B // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -fmodule-file=%t/b.pcm \ // RUN: -verify %s -DHAVE_A -DHAVE_B // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -fmodule-file=%t/b.pcm \ // RUN: -fmodule-file=%t/c.pcm \ // RUN: -verify %s -DHAVE_A -DHAVE_B -DHAVE_C // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -fmodule-file=%t/c.pcm \ @@ -67,12 +67,12 @@ // ------------------------------- // Check that -fmodule-file= in a module build makes the file transitively // available even if it's not used. -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fno-implicit-modules -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fno-implicit-modules -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-file=%t/b.pcm \ // RUN: -fmodule-name=d -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/d.pcm \ // RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-IMPLICIT-BUILD %s --allow-empty // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fno-implicit-modules -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fno-implicit-modules -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=%t/d.pcm \ // RUN: -verify %s -DHAVE_A -DHAVE_B @@ -104,35 +104,35 @@ // ------------------------------- // Check that we can use a mixture of implicit and explicit modules. -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=%t/b-not-a.pcm \ // RUN: -verify %s -DHAVE_A -DHAVE_B // ------------------------------- // Try to use two different flavors of the 'a' module. -// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -fmodule-file=%t/b-not-a.pcm \ // RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-MULTIPLE-AS %s // -// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -fmodule-file=%t/b-not-a.pcm \ // RUN: -fmodule-map-file=%S/Inputs/explicit-build/module.modulemap \ // RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-MULTIPLE-AS %s // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-name=a -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/a-alt.pcm \ // RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-IMPLICIT-BUILD %s --allow-empty // -// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -fmodule-file=%t/a-alt.pcm \ // RUN: -fmodule-map-file=%S/Inputs/explicit-build/module.modulemap \ // RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-MULTIPLE-AS %s // -// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-file=%t/a-alt.pcm \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -fmodule-map-file=%S/Inputs/explicit-build/module.modulemap \ @@ -142,11 +142,11 @@ // ------------------------------- // Try to import a PCH with -fmodule-file= -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-name=a -emit-pch %S/Inputs/explicit-build/a.h -o %t/a.pch \ // RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-IMPLICIT-BUILD %s --allow-empty // -// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-file=%t/a.pch \ // RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-A-AS-PCH %s // @@ -157,20 +157,20 @@ // // RUN: touch %t/not.pcm // -// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-file=%t/not.pcm \ // RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-BAD-FILE %s // // CHECK-BAD-FILE: fatal error: file '{{.*}}not.pcm' is not a valid precompiled module file -// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -fmodule-file=%t/nonexistent.pcm \ // RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-NO-FILE %s // // CHECK-NO-FILE: fatal error: module file '{{.*}}nonexistent.pcm' not found // RUN: mv %t/a.pcm %t/a-tmp.pcm -// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=%t/c.pcm \ // RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-NO-FILE-INDIRECT %s @@ -184,7 +184,7 @@ // Check that we don't get upset if B's timestamp is newer than C's. // RUN: touch %t/b.pcm // -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=%t/c.pcm \ // RUN: -verify %s -DHAVE_A -DHAVE_B -DHAVE_C @@ -193,7 +193,7 @@ // // RUN: cp %t/b-not-a.pcm %t/b.pcm // -// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ // RUN: -I%S/Inputs/explicit-build \ // RUN: -fmodule-file=%t/c.pcm \ // RUN: %s -DHAVE_A -DHAVE_B -DHAVE_C 2>&1 | FileCheck --check-prefix=CHECK-MISMATCHED-B %s diff --git a/test/Modules/exponential-paths.cpp b/test/Modules/exponential-paths.cpp index 34ab4205131d..b5641933f8d0 100644 --- a/test/Modules/exponential-paths.cpp +++ b/test/Modules/exponential-paths.cpp @@ -137,51 +137,51 @@ // // Explicitly build all the modules. // -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a0 -x c++ -emit-module %t/module.modulemap -o %t/a0.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b0 -x c++ -emit-module %t/module.modulemap -o %t/b0.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a1 -x c++ -emit-module %t/module.modulemap -o %t/a1.pcm -fmodule-file=%t/a0.pcm -fmodule-file=%t/b0.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b1 -x c++ -emit-module %t/module.modulemap -o %t/b1.pcm -fmodule-file=%t/a0.pcm -fmodule-file=%t/b0.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a2 -x c++ -emit-module %t/module.modulemap -o %t/a2.pcm -fmodule-file=%t/a1.pcm -fmodule-file=%t/b1.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b2 -x c++ -emit-module %t/module.modulemap -o %t/b2.pcm -fmodule-file=%t/a1.pcm -fmodule-file=%t/b1.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a3 -x c++ -emit-module %t/module.modulemap -o %t/a3.pcm -fmodule-file=%t/a2.pcm -fmodule-file=%t/b2.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b3 -x c++ -emit-module %t/module.modulemap -o %t/b3.pcm -fmodule-file=%t/a2.pcm -fmodule-file=%t/b2.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a4 -x c++ -emit-module %t/module.modulemap -o %t/a4.pcm -fmodule-file=%t/a3.pcm -fmodule-file=%t/b3.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b4 -x c++ -emit-module %t/module.modulemap -o %t/b4.pcm -fmodule-file=%t/a3.pcm -fmodule-file=%t/b3.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a5 -x c++ -emit-module %t/module.modulemap -o %t/a5.pcm -fmodule-file=%t/a4.pcm -fmodule-file=%t/b4.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b5 -x c++ -emit-module %t/module.modulemap -o %t/b5.pcm -fmodule-file=%t/a4.pcm -fmodule-file=%t/b4.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a6 -x c++ -emit-module %t/module.modulemap -o %t/a6.pcm -fmodule-file=%t/a5.pcm -fmodule-file=%t/b5.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b6 -x c++ -emit-module %t/module.modulemap -o %t/b6.pcm -fmodule-file=%t/a5.pcm -fmodule-file=%t/b5.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a7 -x c++ -emit-module %t/module.modulemap -o %t/a7.pcm -fmodule-file=%t/a6.pcm -fmodule-file=%t/b6.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b7 -x c++ -emit-module %t/module.modulemap -o %t/b7.pcm -fmodule-file=%t/a6.pcm -fmodule-file=%t/b6.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a8 -x c++ -emit-module %t/module.modulemap -o %t/a8.pcm -fmodule-file=%t/a7.pcm -fmodule-file=%t/b7.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b8 -x c++ -emit-module %t/module.modulemap -o %t/b8.pcm -fmodule-file=%t/a7.pcm -fmodule-file=%t/b7.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a9 -x c++ -emit-module %t/module.modulemap -o %t/a9.pcm -fmodule-file=%t/a8.pcm -fmodule-file=%t/b8.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b9 -x c++ -emit-module %t/module.modulemap -o %t/b9.pcm -fmodule-file=%t/a8.pcm -fmodule-file=%t/b8.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a10 -x c++ -emit-module %t/module.modulemap -o %t/a10.pcm -fmodule-file=%t/a9.pcm -fmodule-file=%t/b9.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b10 -x c++ -emit-module %t/module.modulemap -o %t/b10.pcm -fmodule-file=%t/a9.pcm -fmodule-file=%t/b9.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a11 -x c++ -emit-module %t/module.modulemap -o %t/a11.pcm -fmodule-file=%t/a10.pcm -fmodule-file=%t/b10.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b11 -x c++ -emit-module %t/module.modulemap -o %t/b11.pcm -fmodule-file=%t/a10.pcm -fmodule-file=%t/b10.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a12 -x c++ -emit-module %t/module.modulemap -o %t/a12.pcm -fmodule-file=%t/a11.pcm -fmodule-file=%t/b11.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b12 -x c++ -emit-module %t/module.modulemap -o %t/b12.pcm -fmodule-file=%t/a11.pcm -fmodule-file=%t/b11.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a13 -x c++ -emit-module %t/module.modulemap -o %t/a13.pcm -fmodule-file=%t/a12.pcm -fmodule-file=%t/b12.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b13 -x c++ -emit-module %t/module.modulemap -o %t/b13.pcm -fmodule-file=%t/a12.pcm -fmodule-file=%t/b12.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a14 -x c++ -emit-module %t/module.modulemap -o %t/a14.pcm -fmodule-file=%t/a13.pcm -fmodule-file=%t/b13.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b14 -x c++ -emit-module %t/module.modulemap -o %t/b14.pcm -fmodule-file=%t/a13.pcm -fmodule-file=%t/b13.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a15 -x c++ -emit-module %t/module.modulemap -o %t/a15.pcm -fmodule-file=%t/a14.pcm -fmodule-file=%t/b14.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b15 -x c++ -emit-module %t/module.modulemap -o %t/b15.pcm -fmodule-file=%t/a14.pcm -fmodule-file=%t/b14.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a16 -x c++ -emit-module %t/module.modulemap -o %t/a16.pcm -fmodule-file=%t/a15.pcm -fmodule-file=%t/b15.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b16 -x c++ -emit-module %t/module.modulemap -o %t/b16.pcm -fmodule-file=%t/a15.pcm -fmodule-file=%t/b15.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a17 -x c++ -emit-module %t/module.modulemap -o %t/a17.pcm -fmodule-file=%t/a16.pcm -fmodule-file=%t/b16.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b17 -x c++ -emit-module %t/module.modulemap -o %t/b17.pcm -fmodule-file=%t/a16.pcm -fmodule-file=%t/b16.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a18 -x c++ -emit-module %t/module.modulemap -o %t/a18.pcm -fmodule-file=%t/a17.pcm -fmodule-file=%t/b17.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b18 -x c++ -emit-module %t/module.modulemap -o %t/b18.pcm -fmodule-file=%t/a17.pcm -fmodule-file=%t/b17.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a19 -x c++ -emit-module %t/module.modulemap -o %t/a19.pcm -fmodule-file=%t/a18.pcm -fmodule-file=%t/b18.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b19 -x c++ -emit-module %t/module.modulemap -o %t/b19.pcm -fmodule-file=%t/a18.pcm -fmodule-file=%t/b18.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=a20 -x c++ -emit-module %t/module.modulemap -o %t/a20.pcm -fmodule-file=%t/a19.pcm -fmodule-file=%t/b19.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fmodule-name=b20 -x c++ -emit-module %t/module.modulemap -o %t/b20.pcm -fmodule-file=%t/a19.pcm -fmodule-file=%t/b19.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a0 -x c++ -emit-module %t/module.modulemap -o %t/a0.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b0 -x c++ -emit-module %t/module.modulemap -o %t/b0.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a1 -x c++ -emit-module %t/module.modulemap -o %t/a1.pcm -fmodule-file=%t/a0.pcm -fmodule-file=%t/b0.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b1 -x c++ -emit-module %t/module.modulemap -o %t/b1.pcm -fmodule-file=%t/a0.pcm -fmodule-file=%t/b0.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a2 -x c++ -emit-module %t/module.modulemap -o %t/a2.pcm -fmodule-file=%t/a1.pcm -fmodule-file=%t/b1.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b2 -x c++ -emit-module %t/module.modulemap -o %t/b2.pcm -fmodule-file=%t/a1.pcm -fmodule-file=%t/b1.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a3 -x c++ -emit-module %t/module.modulemap -o %t/a3.pcm -fmodule-file=%t/a2.pcm -fmodule-file=%t/b2.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b3 -x c++ -emit-module %t/module.modulemap -o %t/b3.pcm -fmodule-file=%t/a2.pcm -fmodule-file=%t/b2.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a4 -x c++ -emit-module %t/module.modulemap -o %t/a4.pcm -fmodule-file=%t/a3.pcm -fmodule-file=%t/b3.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b4 -x c++ -emit-module %t/module.modulemap -o %t/b4.pcm -fmodule-file=%t/a3.pcm -fmodule-file=%t/b3.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a5 -x c++ -emit-module %t/module.modulemap -o %t/a5.pcm -fmodule-file=%t/a4.pcm -fmodule-file=%t/b4.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b5 -x c++ -emit-module %t/module.modulemap -o %t/b5.pcm -fmodule-file=%t/a4.pcm -fmodule-file=%t/b4.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a6 -x c++ -emit-module %t/module.modulemap -o %t/a6.pcm -fmodule-file=%t/a5.pcm -fmodule-file=%t/b5.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b6 -x c++ -emit-module %t/module.modulemap -o %t/b6.pcm -fmodule-file=%t/a5.pcm -fmodule-file=%t/b5.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a7 -x c++ -emit-module %t/module.modulemap -o %t/a7.pcm -fmodule-file=%t/a6.pcm -fmodule-file=%t/b6.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b7 -x c++ -emit-module %t/module.modulemap -o %t/b7.pcm -fmodule-file=%t/a6.pcm -fmodule-file=%t/b6.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a8 -x c++ -emit-module %t/module.modulemap -o %t/a8.pcm -fmodule-file=%t/a7.pcm -fmodule-file=%t/b7.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b8 -x c++ -emit-module %t/module.modulemap -o %t/b8.pcm -fmodule-file=%t/a7.pcm -fmodule-file=%t/b7.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a9 -x c++ -emit-module %t/module.modulemap -o %t/a9.pcm -fmodule-file=%t/a8.pcm -fmodule-file=%t/b8.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b9 -x c++ -emit-module %t/module.modulemap -o %t/b9.pcm -fmodule-file=%t/a8.pcm -fmodule-file=%t/b8.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a10 -x c++ -emit-module %t/module.modulemap -o %t/a10.pcm -fmodule-file=%t/a9.pcm -fmodule-file=%t/b9.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b10 -x c++ -emit-module %t/module.modulemap -o %t/b10.pcm -fmodule-file=%t/a9.pcm -fmodule-file=%t/b9.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a11 -x c++ -emit-module %t/module.modulemap -o %t/a11.pcm -fmodule-file=%t/a10.pcm -fmodule-file=%t/b10.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b11 -x c++ -emit-module %t/module.modulemap -o %t/b11.pcm -fmodule-file=%t/a10.pcm -fmodule-file=%t/b10.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a12 -x c++ -emit-module %t/module.modulemap -o %t/a12.pcm -fmodule-file=%t/a11.pcm -fmodule-file=%t/b11.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b12 -x c++ -emit-module %t/module.modulemap -o %t/b12.pcm -fmodule-file=%t/a11.pcm -fmodule-file=%t/b11.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a13 -x c++ -emit-module %t/module.modulemap -o %t/a13.pcm -fmodule-file=%t/a12.pcm -fmodule-file=%t/b12.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b13 -x c++ -emit-module %t/module.modulemap -o %t/b13.pcm -fmodule-file=%t/a12.pcm -fmodule-file=%t/b12.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a14 -x c++ -emit-module %t/module.modulemap -o %t/a14.pcm -fmodule-file=%t/a13.pcm -fmodule-file=%t/b13.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b14 -x c++ -emit-module %t/module.modulemap -o %t/b14.pcm -fmodule-file=%t/a13.pcm -fmodule-file=%t/b13.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a15 -x c++ -emit-module %t/module.modulemap -o %t/a15.pcm -fmodule-file=%t/a14.pcm -fmodule-file=%t/b14.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b15 -x c++ -emit-module %t/module.modulemap -o %t/b15.pcm -fmodule-file=%t/a14.pcm -fmodule-file=%t/b14.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a16 -x c++ -emit-module %t/module.modulemap -o %t/a16.pcm -fmodule-file=%t/a15.pcm -fmodule-file=%t/b15.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b16 -x c++ -emit-module %t/module.modulemap -o %t/b16.pcm -fmodule-file=%t/a15.pcm -fmodule-file=%t/b15.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a17 -x c++ -emit-module %t/module.modulemap -o %t/a17.pcm -fmodule-file=%t/a16.pcm -fmodule-file=%t/b16.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b17 -x c++ -emit-module %t/module.modulemap -o %t/b17.pcm -fmodule-file=%t/a16.pcm -fmodule-file=%t/b16.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a18 -x c++ -emit-module %t/module.modulemap -o %t/a18.pcm -fmodule-file=%t/a17.pcm -fmodule-file=%t/b17.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b18 -x c++ -emit-module %t/module.modulemap -o %t/b18.pcm -fmodule-file=%t/a17.pcm -fmodule-file=%t/b17.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a19 -x c++ -emit-module %t/module.modulemap -o %t/a19.pcm -fmodule-file=%t/a18.pcm -fmodule-file=%t/b18.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b19 -x c++ -emit-module %t/module.modulemap -o %t/b19.pcm -fmodule-file=%t/a18.pcm -fmodule-file=%t/b18.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=a20 -x c++ -emit-module %t/module.modulemap -o %t/a20.pcm -fmodule-file=%t/a19.pcm -fmodule-file=%t/b19.pcm +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fmodule-name=b20 -x c++ -emit-module %t/module.modulemap -o %t/b20.pcm -fmodule-file=%t/a19.pcm -fmodule-file=%t/b19.pcm // // Build, using all the modules. -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%t -fsyntax-only %s \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%t -fsyntax-only %s \ // RUN: -fmodule-file=%t/a0.pcm -fmodule-file=%t/b0.pcm \ // RUN: -fmodule-file=%t/a1.pcm -fmodule-file=%t/b1.pcm \ // RUN: -fmodule-file=%t/a2.pcm -fmodule-file=%t/b2.pcm \ diff --git a/test/Modules/extern_c.cpp b/test/Modules/extern_c.cpp index ba466f2a53a2..f505c11f7c9d 100644 --- a/test/Modules/extern_c.cpp +++ b/test/Modules/extern_c.cpp @@ -1,16 +1,16 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs %s -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs %s -DEXTERN_C -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs %s -DEXTERN_CXX -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs %s -DEXTERN_C -DEXTERN_CXX -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs %s -DEXTERN_C -DNAMESPACE -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs %s -DCXX_HEADER -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs %s -DCXX_HEADER -DEXTERN_C -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs %s -DCXX_HEADER -DEXTERN_CXX -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs %s -DCXX_HEADER -DEXTERN_C -DEXTERN_CXX -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs %s -DCXX_HEADER -DEXTERN_C -DNAMESPACE -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs -x c %s -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs/elsewhere -I %S/Inputs %s -DEXTERN_C -DINDIRECT +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs %s -DEXTERN_C +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs %s -DEXTERN_CXX +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs %s -DEXTERN_C -DEXTERN_CXX +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs %s -DEXTERN_C -DNAMESPACE +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs %s -DCXX_HEADER +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs %s -DCXX_HEADER -DEXTERN_C +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs %s -DCXX_HEADER -DEXTERN_CXX +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs %s -DCXX_HEADER -DEXTERN_C -DEXTERN_CXX +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs %s -DCXX_HEADER -DEXTERN_C -DNAMESPACE +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs -x c %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs/elsewhere -I %S/Inputs %s -DEXTERN_C -DINDIRECT #ifdef INDIRECT #include "c-header-indirect.h" diff --git a/test/Modules/extern_c_bad.cpp b/test/Modules/extern_c_bad.cpp index bafdc046ce0a..c34416a4b715 100644 --- a/test/Modules/extern_c_bad.cpp +++ b/test/Modules/extern_c_bad.cpp @@ -1,2 +1,2 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -verify -fmodules -x c++ -emit-module -fmodules-cache-path=%t -fmodule-name=c_library_bad %S/Inputs/module.map +// RUN: %clang_cc1 -verify -fmodules -fimplicit-module-maps -x c++ -emit-module -fmodules-cache-path=%t -fmodule-name=c_library_bad %S/Inputs/module.map diff --git a/test/Modules/fatal-module-loader-error.m b/test/Modules/fatal-module-loader-error.m index 2d8dd24e5135..99a42c2aff42 100644 --- a/test/Modules/fatal-module-loader-error.m +++ b/test/Modules/fatal-module-loader-error.m @@ -1,8 +1,8 @@ // RUN: rm -rf %t // RUN: mkdir %t // RUN: touch %t/Module.pcm -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t %s -fdisable-module-hash -F %S/Inputs -verify -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t %s -fdisable-module-hash -F %S/Inputs -DIMPLICIT -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t %s -fdisable-module-hash -F %S/Inputs -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t %s -fdisable-module-hash -F %S/Inputs -DIMPLICIT -verify // This tests that after a fatal module loader error, we do not continue parsing. @@ -21,6 +21,6 @@ #endif // Also check that libclang does not create a PCH with such an error. -// RUN: not c-index-test -write-pch %t.pch -fmodules -fmodules-cache-path=%t \ +// RUN: not c-index-test -write-pch %t.pch -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: %s -Xclang -fdisable-module-hash -F %S/Inputs 2>&1 | FileCheck %s // CHECK: {{^}}Failure: AST deserialization error occurred{{$}} diff --git a/test/Modules/filename.cpp b/test/Modules/filename.cpp index 460b6e6b9571..e2b5ad141891 100644 --- a/test/Modules/filename.cpp +++ b/test/Modules/filename.cpp @@ -1,5 +1,5 @@ // RUN: cd %S -// RUN: %clang_cc1 -I. -fmodule-maps -fmodule-name=A -fmodule-map-file=%S/Inputs/filename/module.map %s -E | FileCheck %s +// RUN: %clang_cc1 -I. -fmodule-name=A -fmodule-map-file=%S/Inputs/filename/module.map %s -E | FileCheck %s #include "Inputs/filename/a.h" diff --git a/test/Modules/fmodules-validate-once-per-build-session.c b/test/Modules/fmodules-validate-once-per-build-session.c index dcbd0db3cbfe..dc552eaabde7 100644 --- a/test/Modules/fmodules-validate-once-per-build-session.c +++ b/test/Modules/fmodules-validate-once-per-build-session.c @@ -13,8 +13,8 @@ // === // Compile the module. -// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -isystem %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s -// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache-user -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -isystem %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t/modules-cache-user -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s // RUN: ls -R %t/modules-cache | grep Foo.pcm.timestamp // RUN: ls -R %t/modules-cache-user | grep Foo.pcm.timestamp // RUN: cp %t/modules-cache/Foo.pcm %t/modules-to-compare/Foo-before.pcm @@ -22,8 +22,8 @@ // === // Use it, and make sure that we did not recompile it. -// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -isystem %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s -// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache-user -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -isystem %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t/modules-cache-user -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s // RUN: ls -R %t/modules-cache | grep Foo.pcm.timestamp // RUN: ls -R %t/modules-cache-user | grep Foo.pcm.timestamp // RUN: cp %t/modules-cache/Foo.pcm %t/modules-to-compare/Foo-after.pcm @@ -39,8 +39,8 @@ // === // Use the module, and make sure that we did not recompile it if foo.h is a // system header, even though the sources changed. -// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -isystem %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s -// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache-user -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -isystem %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t/modules-cache-user -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s // RUN: ls -R %t/modules-cache | grep Foo.pcm.timestamp // RUN: ls -R %t/modules-cache-user | grep Foo.pcm.timestamp // RUN: cp %t/modules-cache/Foo.pcm %t/modules-to-compare/Foo-after.pcm @@ -52,7 +52,7 @@ // === // Recompile the module if the today's date is before 01 January 2030. -// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -isystem %t/Inputs -fbuild-session-timestamp=1893456000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -isystem %t/Inputs -fbuild-session-timestamp=1893456000 -fmodules-validate-once-per-build-session %s // RUN: ls -R %t/modules-cache | grep Foo.pcm.timestamp // RUN: cp %t/modules-cache/Foo.pcm %t/modules-to-compare/Foo-after.pcm diff --git a/test/Modules/global_index.m b/test/Modules/global_index.m index b255b6300077..64a70f2a43ff 100644 --- a/test/Modules/global_index.m +++ b/test/Modules/global_index.m @@ -1,12 +1,12 @@ // RUN: rm -rf %t // Run without global module index -// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fdisable-module-hash -fmodules -fno-modules-global-index -F %S/Inputs %s -verify +// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fdisable-module-hash -fmodules -fimplicit-module-maps -fno-modules-global-index -F %S/Inputs %s -verify // RUN: ls %t|not grep modules.idx // Run and create the global module index -// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fdisable-module-hash -fmodules -F %S/Inputs %s -verify +// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fdisable-module-hash -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify // RUN: ls %t|grep modules.idx // Run and use the global module index -// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fdisable-module-hash -fmodules -F %S/Inputs %s -verify -print-stats 2>&1 | FileCheck %s +// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fdisable-module-hash -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify -print-stats 2>&1 | FileCheck %s // expected-no-diagnostics @import DependsOnModule; diff --git a/test/Modules/header-import.m b/test/Modules/header-import.m index baeb1d304dcf..f95c3bd6af67 100644 --- a/test/Modules/header-import.m +++ b/test/Modules/header-import.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -F %S/Inputs -I %S/Inputs -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -F %S/Inputs -I %S/Inputs -verify %s // expected-no-diagnostics #import "point.h" diff --git a/test/Modules/ignored_macros.m b/test/Modules/ignored_macros.m index 669db4ddc2da..a87a11f89c31 100644 --- a/test/Modules/ignored_macros.m +++ b/test/Modules/ignored_macros.m @@ -1,14 +1,14 @@ // First trial: pass -DIGNORED=1 to both. This should obviously work. // RUN: rm -rf %t.modules -// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules -I %S/Inputs -emit-pch -o %t.pch -x objective-c-header %s -verify -// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules -I %S/Inputs -include-pch %t.pch %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules -fimplicit-module-maps -I %S/Inputs -emit-pch -o %t.pch -x objective-c-header %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules -fimplicit-module-maps -I %S/Inputs -include-pch %t.pch %s -verify // Second trial: pass -DIGNORED=1 only to the second invocation. We // should detect the failure. // // RUN: rm -rf %t.modules -// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -fmodules -I %S/Inputs -emit-pch -o %t.pch -x objective-c-header %s -verify -// RUN: not %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules -I %S/Inputs -include-pch %t.pch %s > %t.err 2>&1 +// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -fmodules -fimplicit-module-maps -I %S/Inputs -emit-pch -o %t.pch -x objective-c-header %s -verify +// RUN: not %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules -fimplicit-module-maps -I %S/Inputs -include-pch %t.pch %s > %t.err 2>&1 // RUN: FileCheck -check-prefix=CHECK-CONFLICT %s < %t.err // CHECK-CONFLICT: PCH was compiled with module cache path @@ -16,22 +16,22 @@ // make it ignored. There should be no failure, IGNORED is defined in // the translation unit but not the module. // RUN: rm -rf %t.modules -// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -fmodules -I %S/Inputs -emit-pch -o %t.pch -x objective-c-header %s -verify -// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules -I %S/Inputs -include-pch %t.pch -fmodules-ignore-macro=IGNORED %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -fmodules -fimplicit-module-maps -I %S/Inputs -emit-pch -o %t.pch -x objective-c-header %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules -fimplicit-module-maps -I %S/Inputs -include-pch %t.pch -fmodules-ignore-macro=IGNORED %s -verify // Fourth trial: pass -DIGNORED=1 and -fmodules-ignore-macro=IGNORED // to both invocations, so modules will be built without the IGNORED // macro. // RUN: rm -rf %t.modules -// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules-ignore-macro=IGNORED -fmodules -I %S/Inputs -emit-pch -o %t.pch -x objective-c-header %s -verify -// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules -I %S/Inputs -include-pch %t.pch -fmodules-ignore-macro=IGNORED -DNO_IGNORED_ANYWHERE -fmodules-ignore-macro=NO_IGNORED_ANYWHERE %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules-ignore-macro=IGNORED -fmodules -fimplicit-module-maps -I %S/Inputs -emit-pch -o %t.pch -x objective-c-header %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules -fimplicit-module-maps -I %S/Inputs -include-pch %t.pch -fmodules-ignore-macro=IGNORED -DNO_IGNORED_ANYWHERE -fmodules-ignore-macro=NO_IGNORED_ANYWHERE %s -verify // Fifth trial: pass -DIGNORED=1 and -fmodules-ignore-macro=IGNORED=1 // to both invocations, so modules will be built without the IGNORED // macro. // RUN: rm -rf %t.modules -// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules-ignore-macro=IGNORED=1 -fmodules -I %S/Inputs -emit-pch -o %t.pch -x objective-c-header %s -verify -// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules -I %S/Inputs -include-pch %t.pch -fmodules-ignore-macro=IGNORED=1 -DNO_IGNORED_ANYWHERE -fmodules-ignore-macro=NO_IGNORED_ANYWHERE %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules-ignore-macro=IGNORED=1 -fmodules -fimplicit-module-maps -I %S/Inputs -emit-pch -o %t.pch -x objective-c-header %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t.modules -DIGNORED=1 -fmodules -fimplicit-module-maps -I %S/Inputs -include-pch %t.pch -fmodules-ignore-macro=IGNORED=1 -DNO_IGNORED_ANYWHERE -fmodules-ignore-macro=NO_IGNORED_ANYWHERE %s -verify // expected-no-diagnostics diff --git a/test/Modules/implementation-of-module.m b/test/Modules/implementation-of-module.m index 818cce8c36de..37e2cfbe30fd 100644 --- a/test/Modules/implementation-of-module.m +++ b/test/Modules/implementation-of-module.m @@ -3,19 +3,19 @@ // CHECK-IMPL-OF-ERR: conflicting module names specified: '-fmodule-name=Bar' and '-fmodule-implementation-of Foo' // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ // RUN: -fmodule-implementation-of category_right -fsyntax-only -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ // RUN: -fmodule-implementation-of category_right -dM -E -o - 2>&1 | FileCheck %s // CHECK-NOT: __building_module -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ // RUN: -fmodule-implementation-of category_left -verify -// RUN: %clang_cc1 -x objective-c-header -fmodules -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ +// RUN: %clang_cc1 -x objective-c-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ // RUN: -fmodule-implementation-of category_right -emit-pch -o %t.pch -// RUN: %clang_cc1 -x objective-c-header -fmodules -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ +// RUN: %clang_cc1 -x objective-c-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ // RUN: -DWITH_PREFIX -fmodules-ignore-macro=WITH_PREFIX -include-pch %t.pch -fmodule-implementation-of category_right #ifndef WITH_PREFIX diff --git a/test/Modules/import-self.m b/test/Modules/import-self.m index 68be565eaf40..aa7437132372 100644 --- a/test/Modules/import-self.m +++ b/test/Modules/import-self.m @@ -1,9 +1,9 @@ // RUN: rm -rf %t -// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t \ +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -I %S/Inputs/submodules %s 2>&1 | FileCheck %s // CHECK: import of module 'import_self.c' appears within same top-level module 'import_self' -// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t \ +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -I %S/Inputs/submodules -fmodule-name=import_self %s \ // RUN: 2>&1 | FileCheck -check-prefix=CHECK-fmodule-name %s // CHECK-fmodule-name: import of module 'import_self.b' appears within same top-level module 'import_self' diff --git a/test/Modules/include-relative.c b/test/Modules/include-relative.c index 264df5f31897..84d44cb569ad 100644 --- a/test/Modules/include-relative.c +++ b/test/Modules/include-relative.c @@ -2,7 +2,7 @@ // RUN: mkdir %t // RUN: cp -r %S/Inputs/include-relative %t/include-relative // RUN: cd %t -// RUN: %clang_cc1 -fmodules -x c -verify -fmodules-cache-path=%t -I include-relative %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x c -verify -fmodules-cache-path=%t -I include-relative %s // expected-no-diagnostics diff --git a/test/Modules/include_next.c b/test/Modules/include_next.c index f2dafb4a91de..15658cb58a67 100644 --- a/test/Modules/include_next.c +++ b/test/Modules/include_next.c @@ -1,6 +1,6 @@ // RUN: rm -rf %t // RUN: %clang_cc1 -I%S/Inputs/include_next/x -I%S/Inputs/include_next/y -verify %s -// RUN: %clang_cc1 -I%S/Inputs/include_next/x -I%S/Inputs/include_next/y -verify %s -fmodules -fmodules-cache-path=%t +// RUN: %clang_cc1 -I%S/Inputs/include_next/x -I%S/Inputs/include_next/y -verify %s -fmodules -fimplicit-module-maps -fmodules-cache-path=%t // expected-no-diagnostics #include "a.h" diff --git a/test/Modules/incomplete-module.m b/test/Modules/incomplete-module.m index 8181ae863de9..e338a40c9ab5 100644 --- a/test/Modules/incomplete-module.m +++ b/test/Modules/incomplete-module.m @@ -1,9 +1,9 @@ @import incomplete_mod; // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules-cache-path=%t -Wincomplete-module -fmodules -I %S/Inputs %s 2>&1 | FileCheck %s +// RUN: %clang_cc1 -fmodules-cache-path=%t -Wincomplete-module -fmodules -fimplicit-module-maps -I %S/Inputs %s 2>&1 | FileCheck %s // CHECK: warning: include of non-modular header inside module 'incomplete_mod' // RUN: rm -rf %t -// RUN: not %clang_cc1 -fmodules-cache-path=%t -fmodules-strict-decluse -fmodules -I %S/Inputs %s 2>&1 | FileCheck %s -check-prefix=DECLUSE +// RUN: not %clang_cc1 -fmodules-cache-path=%t -fmodules-strict-decluse -fmodules -fimplicit-module-maps -I %S/Inputs %s 2>&1 | FileCheck %s -check-prefix=DECLUSE // DECLUSE: error: module incomplete_mod does not depend on a module exporting {{'.*incomplete_mod_missing.h'}} diff --git a/test/Modules/inferred-attributes.mm b/test/Modules/inferred-attributes.mm index 5fc1d623f396..b1bcd93ab543 100644 --- a/test/Modules/inferred-attributes.mm +++ b/test/Modules/inferred-attributes.mm @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -F %S/Inputs/inferred-attr -fsyntax-only -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -F %S/Inputs/inferred-attr -fsyntax-only -verify %s // expected-no-diagnostics extern "C" { @import InferredExternC; diff --git a/test/Modules/inferred-framework-case.m b/test/Modules/inferred-framework-case.m index e511155de9ef..2ed443f2b5a1 100644 --- a/test/Modules/inferred-framework-case.m +++ b/test/Modules/inferred-framework-case.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -F %S/Inputs %s -verify -DA +// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify -DA // FIXME: PR20299 - getCanonicalName() is not implemented on Windows. // REQUIRES: shell diff --git a/test/Modules/inferred-frameworks.m b/test/Modules/inferred-frameworks.m index 372e4f2a9250..838237d916b2 100644 --- a/test/Modules/inferred-frameworks.m +++ b/test/Modules/inferred-frameworks.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c -Wauto-import -fmodules-cache-path=%t -fmodules -F %S/Inputs %s -verify +// RUN: %clang_cc1 -x objective-c -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify #include <NotAModule/NotAModule.h> diff --git a/test/Modules/inferred-submodules.m b/test/Modules/inferred-submodules.m index f801d04a0e78..a0b7d985486e 100644 --- a/test/Modules/inferred-submodules.m +++ b/test/Modules/inferred-submodules.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c -Wauto-import -fmodules-cache-path=%t -fmodules -F %S/Inputs %s -verify +// RUN: %clang_cc1 -x objective-c -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify // expected-no-diagnostics @import Module.Sub; diff --git a/test/Modules/invalidate-identifiers.c b/test/Modules/invalidate-identifiers.c index de3aa10db46b..c679813ab61b 100644 --- a/test/Modules/invalidate-identifiers.c +++ b/test/Modules/invalidate-identifiers.c @@ -1,4 +1,4 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/invalidate-identifiers -emit-llvm-only %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/invalidate-identifiers -emit-llvm-only %s #include "b.h" diff --git a/test/Modules/irgen.c b/test/Modules/irgen.c index c44afb1becb1..f09cc7b5388f 100644 --- a/test/Modules/irgen.c +++ b/test/Modules/irgen.c @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=irgen -triple x86_64-apple-darwin10 %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -I %S/Inputs -triple x86_64-apple-darwin10 -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=irgen -triple x86_64-apple-darwin10 %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -I %S/Inputs -triple x86_64-apple-darwin10 -emit-llvm -o - %s | FileCheck %s // FIXME: When we have a syntax for modules in C, use that. @import irgen; diff --git a/test/Modules/linkage-merge.cpp b/test/Modules/linkage-merge.cpp index 3ac8053761bf..005206afadb3 100644 --- a/test/Modules/linkage-merge.cpp +++ b/test/Modules/linkage-merge.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -verify -fmodules -fmodules-cache-path=%t -I %S/Inputs %s +// RUN: %clang_cc1 -verify -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s #include "linkage-merge-bar.h" diff --git a/test/Modules/linkage-merge.m b/test/Modules/linkage-merge.m index 12ad32fa3d18..955eb1aa95ea 100644 --- a/test/Modules/linkage-merge.m +++ b/test/Modules/linkage-merge.m @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=linkage_merge_left %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs -w %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=linkage_merge_left %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -w %s -verify // Test redeclarations of functions where the original declaration is // still hidden. diff --git a/test/Modules/load-after-failure.m b/test/Modules/load-after-failure.m index 38d4a3653205..73ed0e79708b 100644 --- a/test/Modules/load-after-failure.m +++ b/test/Modules/load-after-failure.m @@ -11,9 +11,9 @@ // RUN: echo 'module C { header "C.h" }' >> %t/module.modulemap // RUN: echo 'module D { header "D.h" }' >> %t/module.modulemap -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %t %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %t %s -verify // RUN: echo " " >> %t/D.h -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %t %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %t %s -verify // expected-no-diagnostics diff --git a/test/Modules/load_failure.c b/test/Modules/load_failure.c index 8b0d202ee8b5..6e63ba2adb19 100644 --- a/test/Modules/load_failure.c +++ b/test/Modules/load_failure.c @@ -7,11 +7,11 @@ #endif // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c++ -fmodules-cache-path=%t -fdisable-module-hash -emit-module -fmodule-name=load_failure %S/Inputs/module.map -// RUN: not %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -I %S/Inputs -fdisable-module-hash %s -DNONEXISTENT 2>&1 | FileCheck -check-prefix=CHECK-NONEXISTENT %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -fmodules-cache-path=%t -fdisable-module-hash -emit-module -fmodule-name=load_failure %S/Inputs/module.map +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -I %S/Inputs -fdisable-module-hash %s -DNONEXISTENT 2>&1 | FileCheck -check-prefix=CHECK-NONEXISTENT %s // CHECK-NONEXISTENT: load_failure.c:2:9: fatal error: module 'load_nonexistent' not found -// RUN: not %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -I %S/Inputs -fdisable-module-hash %s -DFAILURE 2> %t.out +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -I %S/Inputs -fdisable-module-hash %s -DFAILURE 2> %t.out // RUN: FileCheck -check-prefix=CHECK-FAILURE %s < %t.out // FIXME: Clean up diagnostic text below and give it a location diff --git a/test/Modules/lookup.cpp b/test/Modules/lookup.cpp index bfe0307a0b2e..e847d78b274f 100644 --- a/test/Modules/lookup.cpp +++ b/test/Modules/lookup.cpp @@ -24,10 +24,10 @@ void f() { } // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c++ -emit-module -fmodules-cache-path=%t -fmodule-name=lookup_left_cxx %S/Inputs/module.map -verify -// RUN: %clang_cc1 -fmodules -x objective-c++ -emit-module -fmodules-cache-path=%t -fmodule-name=lookup_right_cxx %S/Inputs/module.map -verify -// RUN: %clang_cc1 -fmodules -x objective-c++ -fmodules-cache-path=%t -I %S/Inputs %s -verify -// RUN: %clang_cc1 -fmodules -ast-print -x objective-c++ -fmodules-cache-path=%t -I %S/Inputs %s | FileCheck -check-prefix=CHECK-PRINT %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -emit-module -fmodules-cache-path=%t -fmodule-name=lookup_left_cxx %S/Inputs/module.map -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -emit-module -fmodules-cache-path=%t -fmodule-name=lookup_right_cxx %S/Inputs/module.map -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -fmodules-cache-path=%t -I %S/Inputs %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -ast-print -x objective-c++ -fmodules-cache-path=%t -I %S/Inputs %s | FileCheck -check-prefix=CHECK-PRINT %s // FIXME: When we have a syntax for modules in C++, use that. // CHECK-PRINT: int *f0(int *); diff --git a/test/Modules/lookup.m b/test/Modules/lookup.m index 187e8763ca63..edf70639e5cc 100644 --- a/test/Modules/lookup.m +++ b/test/Modules/lookup.m @@ -1,8 +1,8 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -emit-module -x objective-c -fmodule-name=lookup_left_objc %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -emit-module -x objective-c -fmodule-name=lookup_right_objc %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -I %S/Inputs -verify %s -// RUN: %clang_cc1 -fmodules -ast-print -x objective-c -fmodules-cache-path=%t -I %S/Inputs %s | FileCheck -check-prefix=CHECK-PRINT %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -emit-module -x objective-c -fmodule-name=lookup_left_objc %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -emit-module -x objective-c -fmodule-name=lookup_right_objc %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -I %S/Inputs -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -ast-print -x objective-c -fmodules-cache-path=%t -I %S/Inputs %s | FileCheck -check-prefix=CHECK-PRINT %s @import lookup_left_objc; @import lookup_right_objc; diff --git a/test/Modules/macro-ambiguity.cpp b/test/Modules/macro-ambiguity.cpp index af43b35839ab..747a80bf38ca 100644 --- a/test/Modules/macro-ambiguity.cpp +++ b/test/Modules/macro-ambiguity.cpp @@ -5,7 +5,7 @@ // RUN: -v \ // RUN: -iquote Inputs/macro-ambiguity/a/quote \ // RUN: -isystem Inputs/macro-ambiguity/a/system \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -emit-module -fmodule-name=a -o %t/a.pcm \ // RUN: Inputs/macro-ambiguity/module.modulemap @@ -14,7 +14,7 @@ // RUN: -v \ // RUN: -iquote Inputs/macro-ambiguity/b/quote \ // RUN: -isystem Inputs/macro-ambiguity/b/system \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -emit-module -fmodule-name=b -o %t/b.pcm \ // RUN: Inputs/macro-ambiguity/module.modulemap @@ -23,7 +23,7 @@ // RUN: -v \ // RUN: -iquote Inputs/macro-ambiguity/c/quote \ // RUN: -isystem Inputs/macro-ambiguity/c/system \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -emit-module -fmodule-name=c -o %t/c.pcm \ // RUN: Inputs/macro-ambiguity/module.modulemap @@ -32,7 +32,7 @@ // RUN: -v \ // RUN: -iquote Inputs/macro-ambiguity/d/quote \ // RUN: -isystem Inputs/macro-ambiguity/d/system \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -emit-module -fmodule-name=d -o %t/d.pcm \ // RUN: Inputs/macro-ambiguity/module.modulemap @@ -49,7 +49,7 @@ // RUN: -isystem Inputs/macro-ambiguity/d/system \ // RUN: -iquote Inputs/macro-ambiguity/e/quote \ // RUN: -isystem Inputs/macro-ambiguity/e/system \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -fmodule-map-file=Inputs/macro-ambiguity/module.modulemap \ // RUN: -fmodule-file=%t/a.pcm \ @@ -70,7 +70,7 @@ // RUN: -isystem Inputs/macro-ambiguity/d/system \ // RUN: -iquote Inputs/macro-ambiguity/e/quote \ // RUN: -isystem Inputs/macro-ambiguity/e/system \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -fmodule-map-file=Inputs/macro-ambiguity/module.modulemap \ // RUN: -fmodule-file=%t/a.pcm \ diff --git a/test/Modules/macro-hiding.cpp b/test/Modules/macro-hiding.cpp index b166f4b194cf..37402ad07748 100644 --- a/test/Modules/macro-hiding.cpp +++ b/test/Modules/macro-hiding.cpp @@ -1,69 +1,69 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB2 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB2 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB2 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DB2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DB2 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DB2 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DB2 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB2 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB2 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB2 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DB2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DB2 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DB2 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DB2 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB2 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB2 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB2 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DB2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DB2 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DB2 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DB2 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB2 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB2 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB2 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DC1 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DB2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DB2 -DD1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DB2 -DC1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DB2 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB2 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB2 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB2 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DB2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DB2 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DB2 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DB1 -DB2 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB2 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB2 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB2 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DB2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DB2 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DB2 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA2 -DB1 -DB2 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB2 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB2 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB2 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DB2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DB2 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DB2 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DB1 -DB2 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB2 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB2 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB2 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DC1 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DB2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DB2 -DD1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DB2 -DC1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DA1 -DA2 -DB1 -DB2 -DC1 -DD1 // -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DE1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/macro-hiding %s -DE1 #ifdef A1 #include "a1.h" diff --git a/test/Modules/macro-masking.cpp b/test/Modules/macro-masking.cpp index 3d4e8e0ba49a..cd97c0769853 100644 --- a/test/Modules/macro-masking.cpp +++ b/test/Modules/macro-masking.cpp @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fsyntax-only -fmodules %s -fmodules-cache-path=%t -verify -I%S/Inputs/macro-masking -// RxN: %clang_cc1 -fsyntax-only -fmodules -fmodules-local-submodule-visibility %s -fmodules-cache-path=%t -verify -I%S/Inputs/macro-masking -DLOCAL_VISIBILITY +// RUN: %clang_cc1 -fsyntax-only -fmodules -fimplicit-module-maps %s -fmodules-cache-path=%t -verify -I%S/Inputs/macro-masking +// RxN: %clang_cc1 -fsyntax-only -fmodules -fimplicit-module-maps -fmodules-local-submodule-visibility %s -fmodules-cache-path=%t -verify -I%S/Inputs/macro-masking -DLOCAL_VISIBILITY // expected-no-diagnostics #include "a.h" diff --git a/test/Modules/macro-reexport.cpp b/test/Modules/macro-reexport.cpp index 2be6f1532cb4..4e825a07bd80 100644 --- a/test/Modules/macro-reexport.cpp +++ b/test/Modules/macro-reexport.cpp @@ -1,21 +1,21 @@ // RUN: rm -rf %t // RUN: %clang_cc1 -fsyntax-only -DC1 -I%S/Inputs/macro-reexport %s -fmodules-cache-path=%t -verify -// RUN: %clang_cc1 -fsyntax-only -DC1 -I%S/Inputs/macro-reexport -fmodules %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fsyntax-only -DC1 -I%S/Inputs/macro-reexport -fmodules -fimplicit-module-maps %s -fmodules-cache-path=%t -verify // RUN: %clang_cc1 -fsyntax-only -DD1 -I%S/Inputs/macro-reexport %s -fmodules-cache-path=%t -verify -// RUN: %clang_cc1 -fsyntax-only -DD1 -I%S/Inputs/macro-reexport -fmodules %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fsyntax-only -DD1 -I%S/Inputs/macro-reexport -fmodules -fimplicit-module-maps %s -fmodules-cache-path=%t -verify // RUN: %clang_cc1 -fsyntax-only -DD2 -I%S/Inputs/macro-reexport %s -fmodules-cache-path=%t -verify -// RUN: %clang_cc1 -fsyntax-only -DD2 -I%S/Inputs/macro-reexport -fmodules %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fsyntax-only -DD2 -I%S/Inputs/macro-reexport -fmodules -fimplicit-module-maps %s -fmodules-cache-path=%t -verify // RUN: %clang_cc1 -fsyntax-only -DF1 -I%S/Inputs/macro-reexport %s -fmodules-cache-path=%t -verify -// RUN: %clang_cc1 -fsyntax-only -DF1 -I%S/Inputs/macro-reexport -fmodules %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fsyntax-only -DF1 -I%S/Inputs/macro-reexport -fmodules -fimplicit-module-maps %s -fmodules-cache-path=%t -verify // // RUN: %clang_cc1 -fmodules-local-submodule-visibility -fsyntax-only -DC1 -I%S/Inputs/macro-reexport %s -fmodules-cache-path=%t -verify -// RUN: %clang_cc1 -fmodules-local-submodule-visibility -fsyntax-only -DC1 -I%S/Inputs/macro-reexport -fmodules %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fmodules-local-submodule-visibility -fsyntax-only -DC1 -I%S/Inputs/macro-reexport -fmodules -fimplicit-module-maps %s -fmodules-cache-path=%t -verify // RUN: %clang_cc1 -fmodules-local-submodule-visibility -fsyntax-only -DD1 -I%S/Inputs/macro-reexport %s -fmodules-cache-path=%t -verify -// RUN: %clang_cc1 -fmodules-local-submodule-visibility -fsyntax-only -DD1 -I%S/Inputs/macro-reexport -fmodules %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fmodules-local-submodule-visibility -fsyntax-only -DD1 -I%S/Inputs/macro-reexport -fmodules -fimplicit-module-maps %s -fmodules-cache-path=%t -verify // RUN: %clang_cc1 -fmodules-local-submodule-visibility -fsyntax-only -DD2 -I%S/Inputs/macro-reexport %s -fmodules-cache-path=%t -verify -// RUN: %clang_cc1 -fmodules-local-submodule-visibility -fsyntax-only -DD2 -I%S/Inputs/macro-reexport -fmodules %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fmodules-local-submodule-visibility -fsyntax-only -DD2 -I%S/Inputs/macro-reexport -fmodules -fimplicit-module-maps %s -fmodules-cache-path=%t -verify // RUN: %clang_cc1 -fmodules-local-submodule-visibility -fsyntax-only -DF1 -I%S/Inputs/macro-reexport %s -fmodules-cache-path=%t -verify -// RUN: %clang_cc1 -fmodules-local-submodule-visibility -fsyntax-only -DF1 -I%S/Inputs/macro-reexport -fmodules %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fmodules-local-submodule-visibility -fsyntax-only -DF1 -I%S/Inputs/macro-reexport -fmodules -fimplicit-module-maps %s -fmodules-cache-path=%t -verify #if defined(F1) #include "f1.h" diff --git a/test/Modules/macro-undef-through-pch.m b/test/Modules/macro-undef-through-pch.m index 0e5e99fb8bef..fc32229bec54 100644 --- a/test/Modules/macro-undef-through-pch.m +++ b/test/Modules/macro-undef-through-pch.m @@ -1,8 +1,8 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c-header -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -x objective-c-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -I%S/Inputs/macro-undef-through-pch -emit-pch \ // RUN: %S/Inputs/macro-undef-through-pch/foo.h -o %t.pch -// RUN: %clang_cc1 -x objective-c -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -x objective-c -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -I%S/Inputs/macro-undef-through-pch -emit-pch \ // RUN: -include-pch %t.pch %s diff --git a/test/Modules/macros.c b/test/Modules/macros.c index 538d4a8d6a74..54dca191645e 100644 --- a/test/Modules/macros.c +++ b/test/Modules/macros.c @@ -1,8 +1,8 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c -verify -fmodules-cache-path=%t -I %S/Inputs %s -// RUN: %clang_cc1 -fmodules -x objective-c -verify -fmodules-cache-path=%t -I %S/Inputs %s -detailed-preprocessing-record -// RUN: %clang_cc1 -fmodules -DLOCAL_VISIBILITY -fmodules-local-submodule-visibility -x objective-c++ -verify -fmodules-cache-path=%t -I %S/Inputs %s -// RUN: not %clang_cc1 -E -fmodules -x objective-c -fmodules-cache-path=%t -I %S/Inputs %s | FileCheck -check-prefix CHECK-PREPROCESSED %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -verify -fmodules-cache-path=%t -I %S/Inputs %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -verify -fmodules-cache-path=%t -I %S/Inputs %s -detailed-preprocessing-record +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -DLOCAL_VISIBILITY -fmodules-local-submodule-visibility -x objective-c++ -verify -fmodules-cache-path=%t -I %S/Inputs %s +// RUN: not %clang_cc1 -E -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -I %S/Inputs %s | FileCheck -check-prefix CHECK-PREPROCESSED %s // FIXME: When we have a syntax for modules in C, use that. // These notes come from headers in modules, and are bogus. diff --git a/test/Modules/macros2.c b/test/Modules/macros2.c index 0bb801ee995b..7d669d10c290 100644 --- a/test/Modules/macros2.c +++ b/test/Modules/macros2.c @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c -verify -fmodules-cache-path=%t -I %S/Inputs %s -// RUN: %clang_cc1 -fmodules -fmodules-local-submodule-visibility -x objective-c++ -verify -fmodules-cache-path=%t -I %S/Inputs %s -DLOCAL_VISIBILITY +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -verify -fmodules-cache-path=%t -I %S/Inputs %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-local-submodule-visibility -x objective-c++ -verify -fmodules-cache-path=%t -I %S/Inputs %s -DLOCAL_VISIBILITY // This test checks some of the same things as macros.c, but imports modules in // a different order. diff --git a/test/Modules/malformed.cpp b/test/Modules/malformed.cpp index 2d07c4cd0da7..7d5bcc8c9d66 100644 --- a/test/Modules/malformed.cpp +++ b/test/Modules/malformed.cpp @@ -3,9 +3,9 @@ // // RUN: rm -rf %t // RUN: cd %S -// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -I Inputs/malformed -DHEADER="a1.h" %s 2>&1 | FileCheck %s --check-prefix=CHECK-A -// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -I Inputs/malformed -DHEADER="b1.h" %s 2>&1 | FileCheck %s --check-prefix=CHECK-B -// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -I Inputs/malformed -DHEADER="c.h" malformed.cpp 2>&1 | FileCheck %s --check-prefix=CHECK-C +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I Inputs/malformed -DHEADER="a1.h" %s 2>&1 | FileCheck %s --check-prefix=CHECK-A +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I Inputs/malformed -DHEADER="b1.h" %s 2>&1 | FileCheck %s --check-prefix=CHECK-B +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I Inputs/malformed -DHEADER="c.h" malformed.cpp 2>&1 | FileCheck %s --check-prefix=CHECK-C #define STR2(x) #x #define STR(x) STR2(x) diff --git a/test/Modules/merge-anon-in-template.cpp b/test/Modules/merge-anon-in-template.cpp index 6e4e6e09e9cd..3d0db37122d3 100644 --- a/test/Modules/merge-anon-in-template.cpp +++ b/test/Modules/merge-anon-in-template.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/merge-anon-in-template -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/merge-anon-in-template -verify %s // expected-no-diagnostics #include "a.h" #include "c.h" diff --git a/test/Modules/merge-class-definition-visibility.cpp b/test/Modules/merge-class-definition-visibility.cpp new file mode 100644 index 000000000000..e8602c0d5489 --- /dev/null +++ b/test/Modules/merge-class-definition-visibility.cpp @@ -0,0 +1,15 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -fmodule-map-file=%S/Inputs/merge-class-definition-visibility/modmap \ +// RUN: -I%S/Inputs/merge-class-definition-visibility \ +// RUN: -fmodules-cache-path=%t %s -verify +// expected-no-diagnostics + +#include "c.h" +template<typename T> struct X { T t; }; +typedef X<A> XA; + +#include "d.h" +// Ensure that this triggers the import of the second definition from d.h, +// which is necessary to make the definition of A visible in the template +// instantiation. +XA xa; diff --git a/test/Modules/merge-decl-context.cpp b/test/Modules/merge-decl-context.cpp index 208ba9212e82..55219ed587b0 100644 --- a/test/Modules/merge-decl-context.cpp +++ b/test/Modules/merge-decl-context.cpp @@ -1,19 +1,19 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodule-name=b -o %t/b.pcm -fmodule-maps \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodule-name=b -o %t/b.pcm \ // RUN: -emit-module %S/Inputs/merge-decl-context/merge-decl-context.modulemap -I%S/Inputs \ // RUN: -I %S/Inputs/merge-decl-context -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodule-name=c -o %t/c.pcm -fmodule-maps \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodule-name=c -o %t/c.pcm \ // RUN: -fmodule-file=%t/b.pcm -fno-implicit-modules \ // RUN: -emit-module %S/Inputs/merge-decl-context/merge-decl-context.modulemap -I%S/Inputs \ // RUN: -I %S/Inputs/merge-decl-context -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodule-name=d -o %t/d.pcm -fmodule-maps \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodule-name=d -o %t/d.pcm \ // RUN: -fmodule-file=%t/b.pcm -fno-implicit-modules \ // RUN: -emit-module %S/Inputs/merge-decl-context/merge-decl-context.modulemap -I%S/Inputs \ // RUN: -I %S/Inputs/merge-decl-context // Use the two modules in a single compile. -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodule-file=%t/c.pcm -fmodule-file=%t/b.pcm \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodule-file=%t/c.pcm -fmodule-file=%t/b.pcm \ // RUN: -fmodule-file=%t/d.pcm -fno-implicit-modules \ // RUN: -fmodule-map-file=%S/Inputs/merge-decl-context/merge-decl-context.modulemap -I%S/Inputs \ // RUN: -emit-llvm -o %t/test.o %s diff --git a/test/Modules/merge-decl-order.cpp b/test/Modules/merge-decl-order.cpp index d3b21fdf8ae5..91ec048b38c5 100644 --- a/test/Modules/merge-decl-order.cpp +++ b/test/Modules/merge-decl-order.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/merge-decl-order -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/merge-decl-order -verify %s // expected-no-diagnostics // Check that we include all decls from 'a' before the decls from 'b' in foo's diff --git a/test/Modules/merge-dependent-friends.cpp b/test/Modules/merge-dependent-friends.cpp index 0b0c903c318f..9dfcb19d7fd4 100644 --- a/test/Modules/merge-dependent-friends.cpp +++ b/test/Modules/merge-dependent-friends.cpp @@ -1,4 +1,4 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/merge-dependent-friends -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/merge-dependent-friends -verify %s // expected-no-diagnostics #include "d.h" diff --git a/test/Modules/merge-enumerators.cpp b/test/Modules/merge-enumerators.cpp new file mode 100644 index 000000000000..34a4ec9523fa --- /dev/null +++ b/test/Modules/merge-enumerators.cpp @@ -0,0 +1,11 @@ +// RUN: rm -rf %t +// RUN: mkdir %t +// RUN: echo 'namespace N { enum E { A }; }' > %t/a.h +// RUN: echo '#include "a.h"' > %t/b.h +// RUN: touch %t/x.h +// RUN: echo 'module B { module b { header "b.h" } module x { header "x.h" } }' > %t/b.modulemap +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x c++ -fmodule-map-file=%t/b.modulemap %s -I%t -verify +// expected-no-diagnostics +#include "a.h" +#include "x.h" +N::E e = N::A; diff --git a/test/Modules/merge-friends.cpp b/test/Modules/merge-friends.cpp index 8284bfee680a..0aff9294cbc2 100644 --- a/test/Modules/merge-friends.cpp +++ b/test/Modules/merge-friends.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/merge-friends -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/merge-friends -verify %s // expected-no-diagnostics #include "friend.h" N::foo *use; diff --git a/test/Modules/merge-implicit-special-members.cpp b/test/Modules/merge-implicit-special-members.cpp index a8b917cb01b9..eb1fccd87ca6 100644 --- a/test/Modules/merge-implicit-special-members.cpp +++ b/test/Modules/merge-implicit-special-members.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/merge-implicit-special-members -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/merge-implicit-special-members -verify %s // expected-no-diagnostics #include "c.h" int n = pthread_mutex_t().lock; diff --git a/test/Modules/merge-name-for-linkage.cpp b/test/Modules/merge-name-for-linkage.cpp index 1700b610a5c2..da1664ca343d 100644 --- a/test/Modules/merge-name-for-linkage.cpp +++ b/test/Modules/merge-name-for-linkage.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/merge-name-for-linkage -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/merge-name-for-linkage -verify %s // expected-no-diagnostics typedef union {} pthread_mutex_t; #include "a.h" diff --git a/test/Modules/merge-nested-templates.cpp b/test/Modules/merge-nested-templates.cpp index 42764eaed64f..3abb2bb3d976 100644 --- a/test/Modules/merge-nested-templates.cpp +++ b/test/Modules/merge-nested-templates.cpp @@ -1,4 +1,4 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/merge-nested-templates -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/merge-nested-templates -verify %s // expected-no-diagnostics #include "c.h" diff --git a/test/Modules/merge-target-features.cpp b/test/Modules/merge-target-features.cpp index ccf3aab3d0fa..8b82c8a9789b 100644 --- a/test/Modules/merge-target-features.cpp +++ b/test/Modules/merge-target-features.cpp @@ -3,7 +3,7 @@ // // RUN: %clang_cc1 -fmodules -x c++ -fmodules-cache-path=%t \ // RUN: -iquote Inputs/merge-target-features \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -emit-module -fmodule-name=foo -o %t/foo.pcm \ // RUN: -triple i386-unknown-unknown \ @@ -12,7 +12,7 @@ // // RUN: not %clang_cc1 -fmodules -x c++ -fmodules-cache-path=%t \ // RUN: -iquote Inputs/merge-target-features \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -fmodule-map-file=Inputs/merge-target-features/module.modulemap \ // RUN: -fmodule-file=%t/foo.pcm \ @@ -24,7 +24,7 @@ // // RUN: %clang_cc1 -fmodules -x c++ -fmodules-cache-path=%t \ // RUN: -iquote Inputs/merge-target-features \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -fmodule-map-file=Inputs/merge-target-features/module.modulemap \ // RUN: -fmodule-file=%t/foo.pcm \ @@ -36,7 +36,7 @@ // // RUN: %clang_cc1 -fmodules -x c++ -fmodules-cache-path=%t \ // RUN: -iquote Inputs/merge-target-features \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -fmodule-map-file=Inputs/merge-target-features/module.modulemap \ // RUN: -fmodule-file=%t/foo.pcm \ @@ -48,7 +48,7 @@ // // RUN: not %clang_cc1 -fmodules -x c++ -fmodules-cache-path=%t \ // RUN: -iquote Inputs/merge-target-features \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -fmodule-map-file=Inputs/merge-target-features/module.modulemap \ // RUN: -fmodule-file=%t/foo.pcm \ diff --git a/test/Modules/merge-template-friend.cpp b/test/Modules/merge-template-friend.cpp index 8a1910dad620..37508a6c6390 100644 --- a/test/Modules/merge-template-friend.cpp +++ b/test/Modules/merge-template-friend.cpp @@ -1,14 +1,14 @@ // RUN: rm -rf %t // -// RUN: %clang_cc1 -fmodules -x c++ -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x c++ -fmodules-cache-path=%t \ // RUN: -emit-module -fmodule-name=a -o %t/a.pcm \ // RUN: %S/Inputs/merge-template-friend/module.modulemap // -// RUN: %clang_cc1 -fmodules -x c++ -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x c++ -fmodules-cache-path=%t \ // RUN: -emit-module -fmodule-name=b -o %t/b.pcm \ // RUN: %S/Inputs/merge-template-friend/module.modulemap // -// RUN: %clang_cc1 -fmodules -x c++ -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x c++ -fmodules-cache-path=%t \ // RUN: -I%S/Inputs/merge-template-friend \ // RUN: -fmodule-file=%t/a.pcm \ // RUN: -fmodule-file=%t/b.pcm \ diff --git a/test/Modules/merge-template-members.cpp b/test/Modules/merge-template-members.cpp index 1fdaa9c29be2..88f5fc6c6af1 100644 --- a/test/Modules/merge-template-members.cpp +++ b/test/Modules/merge-template-members.cpp @@ -1,7 +1,7 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/merge-template-members -verify -emit-llvm-only %s -DTEST=1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/merge-template-members -verify -emit-llvm-only %s -DTEST=2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/merge-template-members -verify -emit-llvm-only %s -DTEST=3 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/merge-template-members -verify -emit-llvm-only %s -DTEST=1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/merge-template-members -verify -emit-llvm-only %s -DTEST=2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/merge-template-members -verify -emit-llvm-only %s -DTEST=3 // expected-no-diagnostics #if TEST == 1 diff --git a/test/Modules/merge-typedefs.cpp b/test/Modules/merge-typedefs.cpp index 607f8c5ad0ec..da92a0955749 100644 --- a/test/Modules/merge-typedefs.cpp +++ b/test/Modules/merge-typedefs.cpp @@ -1,6 +1,6 @@ // RUN: rm -rf %t // RUN: %clang_cc1 -x c++ -I%S/Inputs/merge-typedefs -verify %s -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x c++ -I%S/Inputs/merge-typedefs -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x c++ -I%S/Inputs/merge-typedefs -verify %s #include "b2.h" #include "a1.h" diff --git a/test/Modules/merge-using-decls.cpp b/test/Modules/merge-using-decls.cpp index 3b84d0e5a3a0..789f75b57400 100644 --- a/test/Modules/merge-using-decls.cpp +++ b/test/Modules/merge-using-decls.cpp @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x c++ -I%S/Inputs/merge-using-decls -verify %s -DORDER=1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x c++ -I%S/Inputs/merge-using-decls -verify %s -DORDER=2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x c++ -I%S/Inputs/merge-using-decls -verify %s -DORDER=1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x c++ -I%S/Inputs/merge-using-decls -verify %s -DORDER=2 #if ORDER == 1 #include "a.h" diff --git a/test/Modules/merge-vtable-codegen.cpp b/test/Modules/merge-vtable-codegen.cpp index 7372073891c5..3c9299c64ea5 100644 --- a/test/Modules/merge-vtable-codegen.cpp +++ b/test/Modules/merge-vtable-codegen.cpp @@ -1,15 +1,15 @@ // RUN: rm -rf %t // First, build two modules that both re-export the same header. -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodule-name=b -o %t/b.pcm -fmodule-maps \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodule-name=b -o %t/b.pcm \ // RUN: -emit-module %S/Inputs/merge-vtable-codegen/merge-vtable-codegen.modulemap \ // RUN: -I %S/Inputs/merge-vtable-codegen -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodule-name=c -o %t/c.pcm -fmodule-maps \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodule-name=c -o %t/c.pcm \ // RUN: -emit-module %S/Inputs/merge-vtable-codegen/merge-vtable-codegen.modulemap \ // RUN: -I %S/Inputs/merge-vtable-codegen // Use the two modules in a single compile. -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodule-file=%t/b.pcm -fmodule-file=%t/c.pcm \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodule-file=%t/b.pcm -fmodule-file=%t/c.pcm \ // RUN: -fmodule-map-file=%S/Inputs/merge-vtable-codegen/merge-vtable-codegen.modulemap \ // RUN: -emit-llvm -o %t/test.o %s diff --git a/test/Modules/method_pool.m b/test/Modules/method_pool.m index f7d5ae700c97..1d76a8404c6b 100644 --- a/test/Modules/method_pool.m +++ b/test/Modules/method_pool.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -I %S/Inputs %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs %s -verify @import MethodPoolA; diff --git a/test/Modules/missing-header.m b/test/Modules/missing-header.m index c2c1673ac5b0..d865078e3a2f 100644 --- a/test/Modules/missing-header.m +++ b/test/Modules/missing-header.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: not %clang_cc1 -x objective-c -fmodules-cache-path=%t -fmodules -I %S/Inputs/submodules %s 2>&1 | FileCheck %s +// RUN: not %clang_cc1 -x objective-c -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules %s 2>&1 | FileCheck %s // FIXME: cannot use -verify, because the error from inside the module build has // a different source manager than the verifier. diff --git a/test/Modules/missing-submodule.m b/test/Modules/missing-submodule.m index 4f3553ce6c4b..4586ce6762f1 100644 --- a/test/Modules/missing-submodule.m +++ b/test/Modules/missing-submodule.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -F %S/Inputs %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -F %S/Inputs %s -verify #include <Module/NotInModule.h> // expected-warning{{missing submodule 'Module.NotInModule'}} int getNotInModule() { diff --git a/test/Modules/modify-module.m b/test/Modules/modify-module.m index 953c917cddcc..f9a70b25c877 100644 --- a/test/Modules/modify-module.m +++ b/test/Modules/modify-module.m @@ -6,15 +6,15 @@ // RUN: cp %S/Inputs/Modified/A.h %t/include // RUN: cp %S/Inputs/Modified/B.h %t/include // RUN: cp %S/Inputs/Modified/module.map %t/include -// RUN: %clang_cc1 -fdisable-module-hash -fmodules-cache-path=%t/cache -fmodules -I %t/include %s -verify +// RUN: %clang_cc1 -fdisable-module-hash -fmodules-cache-path=%t/cache -fmodules -fimplicit-module-maps -I %t/include %s -verify // RUN: echo '' >> %t/include/B.h -// RUN: %clang_cc1 -fdisable-module-hash -fmodules-cache-path=%t/cache -fmodules -I %t/include %s -verify +// RUN: %clang_cc1 -fdisable-module-hash -fmodules-cache-path=%t/cache -fmodules -fimplicit-module-maps -I %t/include %s -verify // RUN: echo 'int getA(); int getA2();' > %t/include/A.h -// RUN: %clang_cc1 -fdisable-module-hash -fmodules-cache-path=%t/cache -fmodules -I %t/include %s -verify +// RUN: %clang_cc1 -fdisable-module-hash -fmodules-cache-path=%t/cache -fmodules -fimplicit-module-maps -I %t/include %s -verify // RUN: rm %t/cache/ModA.pcm -// RUN: %clang_cc1 -fdisable-module-hash -fmodules-cache-path=%t/cache -fmodules -I %t/include %s -verify +// RUN: %clang_cc1 -fdisable-module-hash -fmodules-cache-path=%t/cache -fmodules -fimplicit-module-maps -I %t/include %s -verify // RUN: touch %t/cache/ModA.pcm -// RUN: %clang_cc1 -fdisable-module-hash -fmodules-cache-path=%t/cache -fmodules -I %t/include %s -verify +// RUN: %clang_cc1 -fdisable-module-hash -fmodules-cache-path=%t/cache -fmodules -fimplicit-module-maps -I %t/include %s -verify // expected-no-diagnostics diff --git a/test/Modules/modular_maps.cpp b/test/Modules/modular_maps.cpp index bedf2e02fb4c..3b6afc7552d6 100644 --- a/test/Modules/modular_maps.cpp +++ b/test/Modules/modular_maps.cpp @@ -1,15 +1,15 @@ // RUN: rm -rf %t // -// RxN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=%S/Inputs/modular_maps/modulea.map -fmodule-map-file=%S/Inputs/modular_maps/modulec.map -I %S/Inputs/modular_maps %s -verify -// RxN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=%S/Inputs/modular_maps/modulec.map -fmodule-map-file=%S/Inputs/modular_maps/modulea.map -I %S/Inputs/modular_maps %s -verify +// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=%S/Inputs/modular_maps/modulea.map -fmodule-map-file=%S/Inputs/modular_maps/modulec.map -I %S/Inputs/modular_maps %s -verify +// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=%S/Inputs/modular_maps/modulec.map -fmodule-map-file=%S/Inputs/modular_maps/modulea.map -I %S/Inputs/modular_maps %s -verify // -// RxN: cd %S -// RxN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=Inputs/modular_maps/modulea.map -fmodule-map-file=Inputs/modular_maps/modulec.map -I Inputs/modular_maps %s -verify -// RxN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=Inputs/modular_maps/modulec.map -fmodule-map-file=Inputs/modular_maps/modulea.map -I Inputs/modular_maps %s -verify +// RUN: cd %S +// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=Inputs/modular_maps/modulea.map -fmodule-map-file=Inputs/modular_maps/modulec.map -I Inputs/modular_maps %s -verify +// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=Inputs/modular_maps/modulec.map -fmodule-map-file=Inputs/modular_maps/modulea.map -I Inputs/modular_maps %s -verify // // RUN: cd %S // RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=Inputs/modular_maps/modulea-cwd.map -fmodule-map-file=Inputs/modular_maps/modulec-cwd.map -I Inputs/modular_maps %s -verify -fmodule-map-file-home-is-cwd -// RxN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=Inputs/modular_maps/modulec-cwd.map -fmodule-map-file=Inputs/modular_maps/modulea-cwd.map -I Inputs/modular_maps %s -verify -fmodule-map-file-home-is-cwd +// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=Inputs/modular_maps/modulec-cwd.map -fmodule-map-file=Inputs/modular_maps/modulea-cwd.map -I Inputs/modular_maps %s -verify -fmodule-map-file-home-is-cwd #include "common.h" #include "a.h" diff --git a/test/Modules/module-private.cpp b/test/Modules/module-private.cpp index 9213a0f20cbc..6e723c863ce3 100644 --- a/test/Modules/module-private.cpp +++ b/test/Modules/module-private.cpp @@ -1,7 +1,7 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c++ -fmodules-cache-path=%t -fmodule-name=module_private_left -emit-module %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c++ -fmodules-cache-path=%t -fmodule-name=module_private_right -emit-module %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c++ -fmodules-cache-path=%t -I %S/Inputs %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -fmodules-cache-path=%t -fmodule-name=module_private_left -emit-module %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -fmodules-cache-path=%t -fmodule-name=module_private_right -emit-module %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -fmodules-cache-path=%t -I %S/Inputs %s -verify // FIXME: When we have a syntax for modules in C++, use that. @import module_private_left; @@ -14,7 +14,7 @@ void test() { int test_broken() { HiddenStruct hidden; // \ // expected-error{{must use 'struct' tag to refer to type 'HiddenStruct' in this scope}} \ - // expected-error{{definition of 'struct HiddenStruct' must be imported}} + // expected-error{{definition of 'HiddenStruct' must be imported}} // expected-note@Inputs/module_private_left.h:3 {{previous definition is here}} Integer i; // expected-error{{unknown type name 'Integer'}} diff --git a/test/Modules/module_file_info.m b/test/Modules/module_file_info.m index 1b0a838bf823..01d5073650b4 100644 --- a/test/Modules/module_file_info.m +++ b/test/Modules/module_file_info.m @@ -2,7 +2,7 @@ @import DependsOnModule; // RUN: rm -rf %t -// RUN: %clang_cc1 -w -Wunused -fmodules -fdisable-module-hash -fmodules-cache-path=%t -F %S/Inputs -DBLARG -DWIBBLE=WOBBLE %s +// RUN: %clang_cc1 -w -Wunused -fmodules -fimplicit-module-maps -fdisable-module-hash -fmodules-cache-path=%t -F %S/Inputs -DBLARG -DWIBBLE=WOBBLE %s // RUN: %clang_cc1 -module-file-info %t/DependsOnModule.pcm | FileCheck %s // CHECK: Generated by this Clang: diff --git a/test/Modules/modulemap-locations.m b/test/Modules/modulemap-locations.m index 949c4786263d..3c80db582d1d 100644 --- a/test/Modules/modulemap-locations.m +++ b/test/Modules/modulemap-locations.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/ModuleMapLocations/Module_ModuleMap -I %S/Inputs/ModuleMapLocations/Both -F %S/Inputs/ModuleMapLocations -I %S/Inputs/ModuleMapLocations -F %S/Inputs -x objective-c -fsyntax-only %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/ModuleMapLocations/Module_ModuleMap -I %S/Inputs/ModuleMapLocations/Both -F %S/Inputs/ModuleMapLocations -I %S/Inputs/ModuleMapLocations -F %S/Inputs -x objective-c -fsyntax-only %s -verify // regular @import module_modulemap; diff --git a/test/Modules/modules-with-same-name.m b/test/Modules/modules-with-same-name.m index d362f756a60a..b5cb6fafb851 100644 --- a/test/Modules/modules-with-same-name.m +++ b/test/Modules/modules-with-same-name.m @@ -1,22 +1,22 @@ // RUN: rm -rf %t // A from path 1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fmodules-ignore-macro=EXPECTED_PATH -fmodules-ignore-macro=DIRECT -fsyntax-only %s -verify -I %S/Inputs/modules-with-same-name/path1/A -DDIRECT -DEXPECTED_PATH=1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fmodules-ignore-macro=EXPECTED_PATH -fmodules-ignore-macro=DIRECT -fsyntax-only %s -verify -I %S/Inputs/modules-with-same-name/path1/A -DDIRECT -DEXPECTED_PATH=1 // A from path 2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fmodules-ignore-macro=EXPECTED_PATH -fmodules-ignore-macro=DIRECT -fsyntax-only %s -verify -I %S/Inputs/modules-with-same-name/path2/A -DDIRECT -DEXPECTED_PATH=2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fmodules-ignore-macro=EXPECTED_PATH -fmodules-ignore-macro=DIRECT -fsyntax-only %s -verify -I %S/Inputs/modules-with-same-name/path2/A -DDIRECT -DEXPECTED_PATH=2 // Confirm that we have two pcm files (one for each 'A'). // RUN: find %t -name "A-*.pcm" | count 2 // DependsOnA, using A from path 1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fmodules-ignore-macro=EXPECTED_PATH -fmodules-ignore-macro=DIRECT -fsyntax-only %s -verify -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path1/A -DEXPECTED_PATH=1 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fmodules-ignore-macro=EXPECTED_PATH -fmodules-ignore-macro=DIRECT -fsyntax-only %s -verify -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path1/A -DEXPECTED_PATH=1 // Confirm that we have three pcm files (one for each 'A', and one for 'DependsOnA') // RUN: find %t -name "*.pcm" | count 3 // DependsOnA, using A from path 2 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fmodules-ignore-macro=EXPECTED_PATH -fmodules-ignore-macro=DIRECT -fsyntax-only %s -verify -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path2/A -DEXPECTED_PATH=2 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fmodules-ignore-macro=EXPECTED_PATH -fmodules-ignore-macro=DIRECT -fsyntax-only %s -verify -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path2/A -DEXPECTED_PATH=2 // Confirm that we still have three pcm files, since DependsOnA will be rebuilt // RUN: find %t -name "*.pcm" | count 3 diff --git a/test/Modules/namespaces.cpp b/test/Modules/namespaces.cpp index a6f4c25cc094..5c0e18325b0a 100644 --- a/test/Modules/namespaces.cpp +++ b/test/Modules/namespaces.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify int &global(int); int &global2(int); diff --git a/test/Modules/no-implicit-builds.cpp b/test/Modules/no-implicit-builds.cpp index d9e8fa1da1c8..bfc3562dbcf4 100644 --- a/test/Modules/no-implicit-builds.cpp +++ b/test/Modules/no-implicit-builds.cpp @@ -1,12 +1,12 @@ // RUN: rm -rf %t // Produce an error if a module is needed, but not found. -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -fmodule-map-file=%S/Inputs/no-implicit-builds/b.modulemap \ // RUN: -fno-implicit-modules %s -verify // Compile the module and put it into the cache. -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -fmodule-map-file=%S/Inputs/no-implicit-builds/b.modulemap \ // RUN: %s -Rmodule-build 2>&1 | FileCheck --check-prefix=CHECK-CACHE-BUILD %s // CHECK-CACHE-BUILD: {{building module 'b'}} @@ -14,19 +14,19 @@ // Produce an error if a module is found in the cache but implicit modules is off. // Note that the command line must match the command line for the first check, otherwise // this check might not find the module in the cache and trivially succeed. -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -fmodule-map-file=%S/Inputs/no-implicit-builds/b.modulemap \ // RUN: %s -Rmodule-build -fno-implicit-modules -verify // Verify that we can still pass the module via -fmodule-file when implicit modules // are switched off: // - First, explicitly compile the module: -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodule-name=b -o %t/b.pcm \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodule-name=b -o %t/b.pcm \ // RUN: -emit-module %S/Inputs/no-implicit-builds/b.modulemap \ // RUN: -fno-implicit-modules // // - Next, verify that we can load it: -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodule-file=%t/b.pcm \ +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodule-file=%t/b.pcm \ // RUN: -fmodule-map-file=%S/Inputs/no-implicit-builds/b.modulemap \ // RUN: -fno-implicit-modules %s diff --git a/test/Modules/no-implicit-maps.cpp b/test/Modules/no-implicit-maps.cpp index cb270a05014e..ddcad5df1e6f 100644 --- a/test/Modules/no-implicit-maps.cpp +++ b/test/Modules/no-implicit-maps.cpp @@ -1,3 +1,3 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c -fno-modules-implicit-maps -fmodules-cache-path=%t -fmodules -I %S/Inputs/private %s -verify +// RUN: %clang_cc1 -x objective-c -fmodules-cache-path=%t -fmodules -I %S/Inputs/private %s -verify @import libPrivate1; // expected-error {{not found}} diff --git a/test/Modules/no-stale-modtime.m b/test/Modules/no-stale-modtime.m index 53512126a1b6..b90daf123ef0 100644 --- a/test/Modules/no-stale-modtime.m +++ b/test/Modules/no-stale-modtime.m @@ -11,18 +11,18 @@ // RUN: echo 'module b { header "b.h" } module l { header "l.h" }' > %t/module.map // RUN: echo 'module r { header "r.h" } module t { header "t.h" }' >> %t/module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -I %t -fsyntax-only %s -Rmodule-build 2>&1 \ // RUN: | FileCheck -check-prefix=REBUILD-ALL %s -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -I %t -fsyntax-only %s -Rmodule-build -verify // Add an identifier to ensure everything depending on t is out of date // RUN: echo 'extern int a;' >> %t/t.h -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -I %t -fsyntax-only %s -Rmodule-build 2>&1 \ // RUN: | FileCheck -check-prefix=REBUILD-ALL %s -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash \ // RUN: -I %t -fsyntax-only %s -Rmodule-build -verify // REBUILD-ALL: building module 'b' diff --git a/test/Modules/normal-module-map.cpp b/test/Modules/normal-module-map.cpp index 70fed60b1295..5db1f3f33e94 100644 --- a/test/Modules/normal-module-map.cpp +++ b/test/Modules/normal-module-map.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c -fmodules-cache-path=%t -fmodules -I %S/Inputs/normal-module-map %s -verify +// RUN: %clang_cc1 -x objective-c -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/normal-module-map %s -verify #include "Umbrella/umbrella_sub.h" int getUmbrella() { diff --git a/test/Modules/objc-categories.m b/test/Modules/objc-categories.m index a66ab8d63125..e8549fabb50e 100644 --- a/test/Modules/objc-categories.m +++ b/test/Modules/objc-categories.m @@ -1,10 +1,10 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x objective-c -fmodule-name=category_top -emit-module %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x objective-c -fmodule-name=category_left -emit-module %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x objective-c -fmodule-name=category_right -emit-module %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x objective-c -fmodule-name=category_bottom -emit-module %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x objective-c -fmodule-name=category_other -emit-module %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x objective-c -fmodule-name=category_top -emit-module %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x objective-c -fmodule-name=category_left -emit-module %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x objective-c -fmodule-name=category_right -emit-module %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x objective-c -fmodule-name=category_bottom -emit-module %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x objective-c -fmodule-name=category_other -emit-module %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify @import category_bottom; diff --git a/test/Modules/objc_redef.m b/test/Modules/objc_redef.m index 28e47665f24f..2e57f41bc662 100644 --- a/test/Modules/objc_redef.m +++ b/test/Modules/objc_redef.m @@ -6,8 +6,8 @@ int test(id x) { } // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=redeclarations_left %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=weird_objc %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=redeclarations_left %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=weird_objc %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify // expected-no-diagnostics diff --git a/test/Modules/odr.cpp b/test/Modules/odr.cpp index 4ac257cd03aa..30143968ffb2 100644 --- a/test/Modules/odr.cpp +++ b/test/Modules/odr.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs/odr %s -verify -std=c++11 +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/odr %s -verify -std=c++11 // expected-error@a.h:8 {{'X::n' from module 'a' is not present in definition of 'X' provided earlier}} struct X { // expected-note {{definition has no member 'n'}} diff --git a/test/Modules/on-demand-build.m b/test/Modules/on-demand-build.m index e95875942029..f84245c0ca78 100644 --- a/test/Modules/on-demand-build.m +++ b/test/Modules/on-demand-build.m @@ -1,7 +1,7 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fno-objc-infer-related-result-type -Werror -Wno-error=incomplete-umbrella -fmodules-cache-path=%t -F %S/Inputs -I %S/Inputs -verify %s -// RUN: %clang_cc1 -fmodules -fno-objc-infer-related-result-type -Werror -Wno-error=incomplete-umbrella -x objective-c++ -fmodules-cache-path=%t -F %S/Inputs -I %S/Inputs -verify %s -// RUN: %clang_cc1 -fmodules -fno-objc-infer-related-result-type -Werror -Wno-error=incomplete-umbrella -fmodules-cache-path=%t -F %S/Inputs -I %S/Inputs -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fno-objc-infer-related-result-type -Werror -Wno-error=incomplete-umbrella -fmodules-cache-path=%t -F %S/Inputs -I %S/Inputs -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fno-objc-infer-related-result-type -Werror -Wno-error=incomplete-umbrella -x objective-c++ -fmodules-cache-path=%t -F %S/Inputs -I %S/Inputs -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fno-objc-infer-related-result-type -Werror -Wno-error=incomplete-umbrella -fmodules-cache-path=%t -F %S/Inputs -I %S/Inputs -verify %s #define FOO @import Module; @interface OtherClass diff --git a/test/Modules/on-demand-macros.m b/test/Modules/on-demand-macros.m index 3c16fa7055f8..d179122c1b18 100644 --- a/test/Modules/on-demand-macros.m +++ b/test/Modules/on-demand-macros.m @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -F %S/Inputs -DFOO_RETURNS_INT_PTR -verify %s -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -F %S/Inputs -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -F %S/Inputs -DFOO_RETURNS_INT_PTR -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -F %S/Inputs -verify %s // expected-no-diagnostics @import CmdLine; diff --git a/test/Modules/pch-used.m b/test/Modules/pch-used.m index 74f21f5dac0f..cdfadb2cf966 100644 --- a/test/Modules/pch-used.m +++ b/test/Modules/pch-used.m @@ -1,7 +1,7 @@ // RUN: rm -rf %t // RUN: mkdir %t -// RUN: %clang_cc1 -x objective-c-header -emit-pch %S/Inputs/pch-used.h -o %t/pch-used.h.pch -fmodules -fmodules-cache-path=%t/cache -O0 -isystem %S/Inputs/System/usr/include -// RUN: %clang_cc1 %s -include-pch %t/pch-used.h.pch -fmodules -fmodules-cache-path=%t/cache -O0 -isystem %S/Inputs/System/usr/include -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -x objective-c-header -emit-pch %S/Inputs/pch-used.h -o %t/pch-used.h.pch -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -O0 -isystem %S/Inputs/System/usr/include +// RUN: %clang_cc1 %s -include-pch %t/pch-used.h.pch -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -O0 -isystem %S/Inputs/System/usr/include -emit-llvm -o - | FileCheck %s void f() { SPXTrace(); } void g() { double x = DBL_MAX; } diff --git a/test/Modules/pr19692.cpp b/test/Modules/pr19692.cpp index 6cc515312f00..72829ad37f3d 100644 --- a/test/Modules/pr19692.cpp +++ b/test/Modules/pr19692.cpp @@ -1,6 +1,6 @@ // RUN: rm -rf %t // RUN: %clang_cc1 -I%S/Inputs/pr19692 -verify %s -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/pr19692 -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/pr19692 -verify %s #include "TFoo.h" #include "stdint.h" diff --git a/test/Modules/pr20399.cpp b/test/Modules/pr20399.cpp index 4f4a02561fc2..4195f50204d6 100644 --- a/test/Modules/pr20399.cpp +++ b/test/Modules/pr20399.cpp @@ -1,2 +1,2 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fmodule-name=libGdml -emit-module -x c++ -std=c++11 %S/Inputs/PR20399/module.modulemap +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fmodule-name=libGdml -emit-module -x c++ -std=c++11 %S/Inputs/PR20399/module.modulemap diff --git a/test/Modules/pr20786.cpp b/test/Modules/pr20786.cpp index 4c0426ed5e58..47e5b6c10b96 100644 --- a/test/Modules/pr20786.cpp +++ b/test/Modules/pr20786.cpp @@ -1,2 +1,2 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fmodule-name=TBranchProxy -emit-module -x c++ %S/Inputs/PR20786/module.modulemap +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fmodule-name=TBranchProxy -emit-module -x c++ %S/Inputs/PR20786/module.modulemap diff --git a/test/Modules/pr21687.cpp b/test/Modules/pr21687.cpp index ad67489541d8..51eb47ddee88 100644 --- a/test/Modules/pr21687.cpp +++ b/test/Modules/pr21687.cpp @@ -1,3 +1,3 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/PR21687 -emit-llvm-only %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/PR21687 -emit-llvm-only %s #include "c.h" diff --git a/test/Modules/preprocess.m b/test/Modules/preprocess.m index 9b563fef821c..8d740d1de287 100644 --- a/test/Modules/preprocess.m +++ b/test/Modules/preprocess.m @@ -1,11 +1,11 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs -I %S/Inputs/preprocess -include %S/Inputs/preprocess-prefix.h -E %s | FileCheck -strict-whitespace %s -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs -I %S/Inputs/preprocess -x objective-c-header -emit-pch %S/Inputs/preprocess-prefix.h -o %t.pch -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs -I %S/Inputs/preprocess -include-pch %t.pch -E %s | FileCheck -strict-whitespace %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -I %S/Inputs/preprocess -include %S/Inputs/preprocess-prefix.h -E %s | FileCheck -strict-whitespace %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -I %S/Inputs/preprocess -x objective-c-header -emit-pch %S/Inputs/preprocess-prefix.h -o %t.pch +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -I %S/Inputs/preprocess -include-pch %t.pch -E %s | FileCheck -strict-whitespace %s // -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs -I %S/Inputs/preprocess -x objective-c++ -include %S/Inputs/preprocess-prefix.h -E %s | FileCheck -strict-whitespace %s -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs -I %S/Inputs/preprocess -x objective-c++-header -emit-pch %S/Inputs/preprocess-prefix.h -o %t.pch -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs -I %S/Inputs/preprocess -x objective-c++ -include-pch %t.pch -E %s | FileCheck -strict-whitespace %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -I %S/Inputs/preprocess -x objective-c++ -include %S/Inputs/preprocess-prefix.h -E %s | FileCheck -strict-whitespace %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -I %S/Inputs/preprocess -x objective-c++-header -emit-pch %S/Inputs/preprocess-prefix.h -o %t.pch +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -I %S/Inputs/preprocess -x objective-c++ -include-pch %t.pch -E %s | FileCheck -strict-whitespace %s #import "diamond_right.h" #import "diamond_right.h" // to check that imports get their own line #include "file.h" diff --git a/test/Modules/private.cpp b/test/Modules/private.cpp index 31e60e47e3d5..52812b38645f 100644 --- a/test/Modules/private.cpp +++ b/test/Modules/private.cpp @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c -fmodules-cache-path=%t -fmodules -I %S/Inputs/private %s -verify -// RUN: %clang_cc1 -x objective-c -fmodules-cache-path=%t -fmodules -I %S/Inputs/private %s -fsyntax-only -Wno-private-header +// RUN: %clang_cc1 -x objective-c -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/private %s -verify +// RUN: %clang_cc1 -x objective-c -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/private %s -fsyntax-only -Wno-private-header #include "common.h" @import libPrivate1; diff --git a/test/Modules/private1.cpp b/test/Modules/private1.cpp index 811a2333d1db..f3be826c7c11 100644 --- a/test/Modules/private1.cpp +++ b/test/Modules/private1.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c -fmodules-cache-path=%t -fmodules -I %S/Inputs/private0 -I %S/Inputs/private1 -I %S/Inputs/private2 %s -verify +// RUN: %clang_cc1 -x objective-c -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/private0 -I %S/Inputs/private1 -I %S/Inputs/private2 %s -verify #include "common.h" @import libPrivateN2; diff --git a/test/Modules/prune.m b/test/Modules/prune.m index 7bc771f7843d..6676407c9acd 100644 --- a/test/Modules/prune.m +++ b/test/Modules/prune.m @@ -11,8 +11,8 @@ // Clear out the module cache // RUN: rm -rf %t // Run Clang twice so we end up creating the timestamp file (the second time). -// RUN: %clang_cc1 -DIMPORT_DEPENDS_ON_MODULE -fmodules-ignore-macro=DIMPORT_DEPENDS_ON_MODULE -fmodules -F %S/Inputs -fmodules-cache-path=%t %s -verify -// RUN: %clang_cc1 -DIMPORT_DEPENDS_ON_MODULE -fmodules-ignore-macro=DIMPORT_DEPENDS_ON_MODULE -fmodules -F %S/Inputs -fmodules-cache-path=%t %s -verify +// RUN: %clang_cc1 -DIMPORT_DEPENDS_ON_MODULE -fmodules-ignore-macro=DIMPORT_DEPENDS_ON_MODULE -fmodules -fimplicit-module-maps -F %S/Inputs -fmodules-cache-path=%t %s -verify +// RUN: %clang_cc1 -DIMPORT_DEPENDS_ON_MODULE -fmodules-ignore-macro=DIMPORT_DEPENDS_ON_MODULE -fmodules -fimplicit-module-maps -F %S/Inputs -fmodules-cache-path=%t %s -verify // RUN: ls %t | grep modules.timestamp // RUN: ls -R %t | grep ^Module.*pcm // RUN: ls -R %t | grep DependsOnModule.*pcm @@ -20,7 +20,7 @@ // Set the timestamp back more than two days. We should try to prune, // but nothing gets pruned because the module files are new enough. // RUN: touch -m -a -t 201101010000 %t/modules.timestamp -// RUN: %clang_cc1 -fmodules -F %S/Inputs -fmodules-cache-path=%t -fmodules -fmodules-prune-interval=172800 -fmodules-prune-after=345600 %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -F %S/Inputs -fmodules-cache-path=%t -fmodules -fmodules-prune-interval=172800 -fmodules-prune-after=345600 %s -verify // RUN: ls %t | grep modules.timestamp // RUN: ls -R %t | grep ^Module.*pcm // RUN: ls -R %t | grep DependsOnModule.*pcm @@ -29,7 +29,7 @@ // This shouldn't prune anything, because the timestamp has been updated, so // the pruning mechanism won't fire. // RUN: find %t -name DependsOnModule*.pcm | xargs touch -a -t 201101010000 -// RUN: %clang_cc1 -fmodules -F %S/Inputs -fmodules-cache-path=%t -fmodules -fmodules-prune-interval=172800 -fmodules-prune-after=345600 %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -F %S/Inputs -fmodules-cache-path=%t -fmodules -fmodules-prune-interval=172800 -fmodules-prune-after=345600 %s -verify // RUN: ls %t | grep modules.timestamp // RUN: ls -R %t | grep ^Module.*pcm // RUN: ls -R %t | grep DependsOnModule.*pcm @@ -38,7 +38,7 @@ // This should trigger pruning, which will remove DependsOnModule but not Module. // RUN: touch -m -a -t 201101010000 %t/modules.timestamp // RUN: find %t -name DependsOnModule*.pcm | xargs touch -a -t 201101010000 -// RUN: %clang_cc1 -fmodules -F %S/Inputs -fmodules-cache-path=%t -fmodules -fmodules-prune-interval=172800 -fmodules-prune-after=345600 %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -F %S/Inputs -fmodules-cache-path=%t -fmodules -fmodules-prune-interval=172800 -fmodules-prune-after=345600 %s -verify // RUN: ls %t | grep modules.timestamp // RUN: ls -R %t | grep ^Module.*pcm // RUN: ls -R %t | not grep DependsOnModule.*pcm diff --git a/test/Modules/rebuild.m b/test/Modules/rebuild.m index 4d4d05529e7d..40f2d47e09e8 100644 --- a/test/Modules/rebuild.m +++ b/test/Modules/rebuild.m @@ -1,19 +1,19 @@ // RUN: rm -rf %t // Build Module and set its timestamp -// RUN: echo '@import Module;' | %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs -x objective-c - +// RUN: echo '@import Module;' | %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs -x objective-c - // RUN: touch -m -a -t 201101010000 %t/Module.pcm // RUN: cp %t/Module.pcm %t/Module.pcm.saved // RUN: wc -c %t/Module.pcm > %t/Module.size.saved // Build DependsOnModule -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs %s // RUN: diff %t/Module.pcm %t/Module.pcm.saved // RUN: cp %t/DependsOnModule.pcm %t/DependsOnModule.pcm.saved // Rebuild Module, reset its timestamp, and verify its size hasn't changed // RUN: rm %t/Module.pcm -// RUN: echo '@import Module;' | %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs -x objective-c - +// RUN: echo '@import Module;' | %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs -x objective-c - // RUN: touch -m -a -t 201101010000 %t/Module.pcm // RUN: wc -c %t/Module.pcm > %t/Module.size // RUN: diff %t/Module.size %t/Module.size.saved @@ -21,13 +21,13 @@ // But the signature at least is expected to change, so we rebuild DependsOnModule. // NOTE: if we change how the signature is created, this test may need updating. -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs %s // RUN: diff %t/Module.pcm %t/Module.pcm.saved.2 // RUN: not diff %t/DependsOnModule.pcm %t/DependsOnModule.pcm.saved // Rebuild Module, reset its timestamp, and verify its size hasn't changed // RUN: rm %t/Module.pcm -// RUN: echo '@import Module;' | %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs -x objective-c - +// RUN: echo '@import Module;' | %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs -x objective-c - // RUN: touch -m -a -t 201101010000 %t/Module.pcm // RUN: wc -c %t/Module.pcm > %t/Module.size // RUN: diff %t/Module.size %t/Module.size.saved @@ -35,7 +35,7 @@ // Verify again with Module pre-imported. // NOTE: if we change how the signature is created, this test may need updating. -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs %s // RUN: diff %t/Module.pcm %t/Module.pcm.saved.2 // RUN: not diff %t/DependsOnModule.pcm %t/DependsOnModule.pcm.saved diff --git a/test/Modules/recursive.c b/test/Modules/recursive.c index 5315b10522b4..9c03a6ac4548 100644 --- a/test/Modules/recursive.c +++ b/test/Modules/recursive.c @@ -1,9 +1,9 @@ // RUN: rm -rf %t -// RUN: not %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -I %S/Inputs %s 2>&1 | FileCheck %s +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -I %S/Inputs %s 2>&1 | FileCheck %s #include "recursive1.h" // RUN: rm -rf %t -// RUN: not %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=recursive1 %S/Inputs/module.map 2>&1 | FileCheck %s +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=recursive1 %S/Inputs/module.map 2>&1 | FileCheck %s // CHECK: While building module 'recursive1'{{( imported from .*[/\]recursive.c:3)?}}: // CHECK-NEXT: While building module 'recursive2' imported from {{.*Inputs[/\]}}recursive1.h:1: diff --git a/test/Modules/recursive_visibility.mm b/test/Modules/recursive_visibility.mm index f37410aa44e1..12894f3366e8 100644 --- a/test/Modules/recursive_visibility.mm +++ b/test/Modules/recursive_visibility.mm @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 // expected-no-diagnostics diff --git a/test/Modules/redecl-add-after-load.cpp b/test/Modules/redecl-add-after-load.cpp index 8ca70ad9580b..f888460f297e 100644 --- a/test/Modules/redecl-add-after-load.cpp +++ b/test/Modules/redecl-add-after-load.cpp @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 -// RUN: %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 -DIMPORT_DECLS +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 -DIMPORT_DECLS // expected-no-diagnostics diff --git a/test/Modules/redecl-found-building-chains.cpp b/test/Modules/redecl-found-building-chains.cpp index 1173863cebad..91524fba0cfd 100644 --- a/test/Modules/redecl-found-building-chains.cpp +++ b/test/Modules/redecl-found-building-chains.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/redecl-found-building-chains -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/redecl-found-building-chains -verify %s // expected-no-diagnostics int n, m; #include "d.h" diff --git a/test/Modules/redecl-merge.m b/test/Modules/redecl-merge.m index 37e5967f4e3b..59a19af7ff06 100644 --- a/test/Modules/redecl-merge.m +++ b/test/Modules/redecl-merge.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -Wreturn-type -fmodules-cache-path=%t -I %S/Inputs %s -verify -Wno-objc-root-class +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -Wreturn-type -fmodules-cache-path=%t -I %S/Inputs %s -verify -Wno-objc-root-class @class C2; @class C3; diff --git a/test/Modules/redecl-merge2.m b/test/Modules/redecl-merge2.m index 3431ecc90b39..dfa9c12d697a 100644 --- a/test/Modules/redecl-merge2.m +++ b/test/Modules/redecl-merge2.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify -Wno-objc-root-class +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify -Wno-objc-root-class // expected-no-diagnostics @import redecl_merge_bottom.prefix; diff --git a/test/Modules/redecl-namespaces.mm b/test/Modules/redecl-namespaces.mm index 203daa9a2bb0..e17af86feba8 100644 --- a/test/Modules/redecl-namespaces.mm +++ b/test/Modules/redecl-namespaces.mm @@ -8,6 +8,6 @@ void test() { } // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c++ -fmodules-cache-path=%t -emit-module -fmodule-name=redecl_namespaces_left %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c++ -fmodules-cache-path=%t -emit-module -fmodule-name=redecl_namespaces_right %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs -w %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -fmodules-cache-path=%t -emit-module -fmodule-name=redecl_namespaces_left %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -fmodules-cache-path=%t -emit-module -fmodule-name=redecl_namespaces_right %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -w %s -verify diff --git a/test/Modules/redecl-templates.cpp b/test/Modules/redecl-templates.cpp index 6bbec02f1056..ee42dc9c6a84 100644 --- a/test/Modules/redecl-templates.cpp +++ b/test/Modules/redecl-templates.cpp @@ -1,6 +1,6 @@ // RUN: rm -rf %t // RUN: %clang_cc1 -x c++ -I %S/Inputs/redecl-templates %s -verify -std=c++14 -// RUN: %clang_cc1 -x c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs/redecl-templates %s -verify -std=c++14 +// RUN: %clang_cc1 -x c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/redecl-templates %s -verify -std=c++14 // expected-no-diagnostics template<int N> struct A {}; diff --git a/test/Modules/redeclarations.m b/test/Modules/redeclarations.m index 11aca7597830..e3f78f28d75c 100644 --- a/test/Modules/redeclarations.m +++ b/test/Modules/redeclarations.m @@ -5,8 +5,8 @@ @end // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=redeclarations_left %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=redeclarations_right %S/Inputs/module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=redeclarations_left %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c -fmodules-cache-path=%t -emit-module -fmodule-name=redeclarations_right %S/Inputs/module.map +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify // expected-no-diagnostics diff --git a/test/Modules/redecls.m b/test/Modules/redecls.m index fa643b90ac8a..d6ad22e609ea 100644 --- a/test/Modules/redecls.m +++ b/test/Modules/redecls.m @@ -1,7 +1,7 @@ // RUN: rm -rf %t.mcp -// RUN: %clang_cc1 -fmodules %s -emit-pch -o %t1.pch -fmodules-cache-path=%t.mcp -I %S/Inputs/redecls -// RUN: %clang_cc1 -fmodules %s -emit-pch -o %t2.pch -include-pch %t1.pch -fmodules-cache-path=%t.mcp -I %S/Inputs/redecls -// RUN: %clang_cc1 -fmodules %s -fsyntax-only -include-pch %t2.pch -I %S/Inputs/redecls -fmodules-cache-path=%t.mcp -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps %s -emit-pch -o %t1.pch -fmodules-cache-path=%t.mcp -I %S/Inputs/redecls +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps %s -emit-pch -o %t2.pch -include-pch %t1.pch -fmodules-cache-path=%t.mcp -I %S/Inputs/redecls +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps %s -fsyntax-only -include-pch %t2.pch -I %S/Inputs/redecls -fmodules-cache-path=%t.mcp -verify #ifndef HEADER1 #define HEADER1 diff --git a/test/Modules/renamed.m b/test/Modules/renamed.m index ec2616e9a724..46a8f942fe83 100644 --- a/test/Modules/renamed.m +++ b/test/Modules/renamed.m @@ -3,6 +3,6 @@ int f() { return same_api; } // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -I %S/Inputs/oldname -fmodules-cache-path=%t %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -I %S/Inputs/oldname -fmodules-cache-path=%t %s -verify // expected-no-diagnostics diff --git a/test/Modules/require-modular-includes.m b/test/Modules/require-modular-includes.m index 302e4cd191cd..0254444bf59b 100644 --- a/test/Modules/require-modular-includes.m +++ b/test/Modules/require-modular-includes.m @@ -2,80 +2,80 @@ // Including a header from the imported module // RUN: echo '@import FromImportedModuleOK;' | \ -// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules \ +// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules -fimplicit-module-maps \ // RUN: -fmodules-cache-path=%t -F %S/Inputs/require-modular-includes \ // RUN: -Werror -fsyntax-only -x objective-c - // Including a non-modular header // RUN: echo '@import FromImportedModuleFail;' | \ -// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules \ +// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules -fimplicit-module-maps \ // RUN: -fmodules-cache-path=%t -F %S/Inputs/require-modular-includes \ // RUN: -I %S/Inputs/require-modular-includes \ // RUN: -fsyntax-only -x objective-c - 2>&1 | FileCheck %s // Including a header from a subframework // RUN: echo '@import FromSubframework;' | \ -// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules \ +// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules -fimplicit-module-maps \ // RUN: -fmodules-cache-path=%t -F %S/Inputs/require-modular-includes \ // RUN: -Werror -fsyntax-only -x objective-c - // Including a header from a subframework (fail) // RUN: echo '@import FromNonModularSubframework;' | \ -// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules \ +// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules -fimplicit-module-maps \ // RUN: -fmodules-cache-path=%t -F %S/Inputs/require-modular-includes \ // RUN: -I %S/Inputs/require-modular-includes \ // RUN: -fsyntax-only -x objective-c - 2>&1 | FileCheck %s // Including a non-modular header from a submodule // RUN: echo '@import FromImportedSubModule;' | \ -// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules \ +// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules -fimplicit-module-maps \ // RUN: -fmodules-cache-path=%t -F %S/Inputs/require-modular-includes \ // RUN: -I %S/Inputs/require-modular-includes \ // RUN: -fsyntax-only -x objective-c - 2>&1 | FileCheck %s // Including a non-modular header (directly) with -fmodule-name set // RUN: echo '#include "NotInModule.h"' | \ -// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules \ +// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules -fimplicit-module-maps \ // RUN: -fmodules-cache-path=%t -I %S/Inputs/require-modular-includes \ // RUN: -Werror -fmodule-name=A -fsyntax-only -x objective-c - // Including an excluded header // RUN: echo '@import IncludeExcluded;' | \ -// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules \ +// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules -fimplicit-module-maps \ // RUN: -fmodules-cache-path=%t -F %S/Inputs/require-modular-includes \ // RUN: -Werror -fsyntax-only -x objective-c - // Including a header from another module // RUN: echo '@import FromAnotherModule;' | \ -// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules \ +// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules -fimplicit-module-maps \ // RUN: -fmodules-cache-path=%t -F %S/Inputs/require-modular-includes \ // RUN: -I %S/Inputs/require-modular-includes \ // RUN: -Werror -fsyntax-only -x objective-c - // Including an excluded header from another module // RUN: echo '@import ExcludedFromAnotherModule;' | \ -// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules \ +// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules -fimplicit-module-maps \ // RUN: -fmodules-cache-path=%t -F %S/Inputs/require-modular-includes \ // RUN: -I %S/Inputs/require-modular-includes \ // RUN: -Werror -fsyntax-only -x objective-c - // Including a header from an umbrella directory // RUN: echo '@import FromUmbrella;' | \ -// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules \ +// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules -fimplicit-module-maps \ // RUN: -fmodules-cache-path=%t -F %S/Inputs/require-modular-includes \ // RUN: -I %S/Inputs/require-modular-includes \ // RUN: -Werror -fsyntax-only -x objective-c - // A includes B includes non-modular C // RUN: echo '@import A;' | \ -// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules \ +// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules -fimplicit-module-maps \ // RUN: -fmodules-cache-path=%t -F %S/Inputs/require-modular-includes \ // RUN: -I %S/Inputs/require-modular-includes \ // RUN: -fsyntax-only -x objective-c - 2>&1 | FileCheck %s // Non-framework module (pass) // RUN: echo '@import NotFramework;' | \ -// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules \ +// RUN: %clang_cc1 -Wnon-modular-include-in-framework-module -fmodules -fimplicit-module-maps \ // RUN: -fmodules-cache-path=%t -I %S/Inputs/require-modular-includes \ // RUN: -Werror -fsyntax-only -x objective-c - diff --git a/test/Modules/requires.m b/test/Modules/requires.m index ff0ddfeb3359..155c6aec5dc4 100644 --- a/test/Modules/requires.m +++ b/test/Modules/requires.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -F %S/Inputs %s -verify -fmodule-feature custom_req1 +// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify -fmodule-feature custom_req1 @import DependsOnModule.CXX; // expected-error{{module 'DependsOnModule.CXX' requires feature 'cplusplus'}} @import DependsOnModule.NotCXX; diff --git a/test/Modules/requires.mm b/test/Modules/requires.mm index 736f2fab646a..cc64a500bd57 100644 --- a/test/Modules/requires.mm +++ b/test/Modules/requires.mm @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -F %S/Inputs %s -verify +// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify @import DependsOnModule.CXX; @import DependsOnModule.NotCXX; // expected-error{{module 'DependsOnModule.NotCXX' is incompatible with feature 'cplusplus'}} diff --git a/test/Modules/resolution-change.m b/test/Modules/resolution-change.m index 6882fe44c5cb..bf95104968a3 100644 --- a/test/Modules/resolution-change.m +++ b/test/Modules/resolution-change.m @@ -1,24 +1,24 @@ // RUN: rm -rf %t // Build PCH using A from path 1 -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path1/A -emit-pch -o %t-A.pch %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path1/A -emit-pch -o %t-A.pch %s // Use the PCH with the same header search options; should be fine -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path1/A -include-pch %t-A.pch %s -fsyntax-only -Werror +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path1/A -include-pch %t-A.pch %s -fsyntax-only -Werror // Different -W options are ok -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path1/A -include-pch %t-A.pch %s -fsyntax-only -Werror -Wauto-import +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path1/A -include-pch %t-A.pch %s -fsyntax-only -Werror -Wauto-import // Use the PCH with no way to resolve DependsOnA -// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -include-pch %t-A.pch %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CHECK-NODOA %s +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -include-pch %t-A.pch %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CHECK-NODOA %s // CHECK-NODOA: module 'DependsOnA' in AST file '{{.*DependsOnA.*pcm}}' (imported by AST file '{{.*A.pch}}') is not defined in any loaded module map // Use the PCH with no way to resolve A -// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -include-pch %t-A.pch %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CHECK-NOA %s +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -include-pch %t-A.pch %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CHECK-NOA %s // CHECK-NOA: module 'A' in AST file '{{.*A.*pcm}}' (imported by AST file '{{.*DependsOnA.*pcm}}') is not defined in any loaded module map // Use the PCH and have it resolve to the other A -// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path2/A -include-pch %t-A.pch %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CHECK-WRONGA %s +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path2/A -include-pch %t-A.pch %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CHECK-WRONGA %s // CHECK-WRONGA: module 'A' was built in directory '{{.*Inputs.modules-with-same-name.path1.A}}' but now resides in directory '{{.*Inputs.modules-with-same-name.path2.A}}' #ifndef HEADER diff --git a/test/Modules/stddef.c b/test/Modules/stddef.c index aefc90f9a117..16de854563fc 100644 --- a/test/Modules/stddef.c +++ b/test/Modules/stddef.c @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/StdDef %s -verify -fno-modules-error-recovery +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/StdDef %s -verify -fno-modules-error-recovery #include "ptrdiff_t.h" diff --git a/test/Modules/stddef.m b/test/Modules/stddef.m index 83f73f9d33ab..9af526e5d562 100644 --- a/test/Modules/stddef.m +++ b/test/Modules/stddef.m @@ -3,5 +3,5 @@ size_t getSize(); // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/StdDef %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/StdDef %s -verify // expected-no-diagnostics diff --git a/test/Modules/stress1.cpp b/test/Modules/stress1.cpp index df690aa7e657..4f3c34ab640b 100644 --- a/test/Modules/stress1.cpp +++ b/test/Modules/stress1.cpp @@ -3,14 +3,14 @@ // // RUN: %clang_cc1 -fmodules -x c++ -std=c++11 \ // RUN: -I Inputs/stress1 \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -emit-module -fmodule-name=m00 -o %t/m00.pcm \ // RUN: Inputs/stress1/module.modulemap // // RUN: %clang_cc1 -fmodules -x c++ -std=c++11 \ // RUN: -I Inputs/stress1 \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -emit-module -fmodule-name=m00 -o %t/m00_check.pcm \ // RUN: Inputs/stress1/module.modulemap @@ -19,14 +19,14 @@ // // RUN: %clang_cc1 -fmodules -x c++ -std=c++11 -fdelayed-template-parsing \ // RUN: -I Inputs/stress1 \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -emit-module -fmodule-name=m01 -o %t/m01.pcm \ // RUN: Inputs/stress1/module.modulemap // // RUN: %clang_cc1 -fmodules -x c++ -std=c++11 -fdelayed-template-parsing \ // RUN: -I Inputs/stress1 \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -emit-module -fmodule-name=m01 -o %t/m01_check.pcm \ // RUN: Inputs/stress1/module.modulemap @@ -35,21 +35,21 @@ // // RUN: %clang_cc1 -fmodules -x c++ -std=c++11 \ // RUN: -I Inputs/stress1 \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -emit-module -fmodule-name=m02 -o %t/m02.pcm \ // RUN: Inputs/stress1/module.modulemap // // RUN: %clang_cc1 -fmodules -x c++ -std=c++11 \ // RUN: -I Inputs/stress1 \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -emit-module -fmodule-name=m03 -o %t/m03.pcm \ // RUN: Inputs/stress1/module.modulemap // // RUN: %clang_cc1 -fmodules -x c++ -std=c++11 \ // RUN: -I Inputs/stress1 \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -fmodule-file=%t/m00.pcm \ // RUN: -fmodule-file=%t/m01.pcm \ @@ -60,7 +60,7 @@ // // RUN: %clang_cc1 -fmodules -x c++ -std=c++11 \ // RUN: -I Inputs/stress1 \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -fmodule-file=%t/m00.pcm \ // RUN: -fmodule-file=%t/m01.pcm \ @@ -73,7 +73,7 @@ // // RUN: %clang_cc1 -fmodules -x c++ -std=c++11 \ // RUN: -I Inputs/stress1 \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -fmodule-map-file=Inputs/stress1/module.modulemap \ // RUN: -fmodule-file=%t/m00.pcm \ @@ -85,7 +85,7 @@ // // RUN: %clang_cc1 -fmodules -x c++ -std=c++11 \ // RUN: -I Inputs/stress1 \ -// RUN: -fno-implicit-modules -fno-modules-implicit-maps \ +// RUN: -fno-implicit-modules \ // RUN: -fmodule-map-file-home-is-cwd \ // RUN: -fmodule-map-file=Inputs/stress1/module.modulemap \ // RUN: -fmodule-file=%t/m00.pcm \ diff --git a/test/Modules/strict-decluse.cpp b/test/Modules/strict-decluse.cpp index fa6955aef0d6..a8b5248b8516 100644 --- a/test/Modules/strict-decluse.cpp +++ b/test/Modules/strict-decluse.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodule-maps -fmodules-cache-path=%t -fmodules-strict-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify +// RUN: %clang_cc1 -fimplicit-module-maps -fmodules-cache-path=%t -fmodules-strict-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify #include "g.h" #include "e.h" diff --git a/test/Modules/string_names.cpp b/test/Modules/string_names.cpp index ed65aa8a6703..43068f13c012 100644 --- a/test/Modules/string_names.cpp +++ b/test/Modules/string_names.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -fmodules-decluse -I %S/Inputs/string_names %s -fmodule-name="my/module-a" -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -fmodules-decluse -I %S/Inputs/string_names %s -fmodule-name="my/module-a" -verify #include "a.h" #include "b.h" // expected-error {{does not depend on a module exporting}} diff --git a/test/Modules/subframework-from-intermediate-path.m b/test/Modules/subframework-from-intermediate-path.m index ae0bd64e394a..394cc45f2f60 100644 --- a/test/Modules/subframework-from-intermediate-path.m +++ b/test/Modules/subframework-from-intermediate-path.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -F %S/Inputs -F %S/Inputs/DependsOnModule.framework/Frameworks %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -F %S/Inputs/DependsOnModule.framework/Frameworks %s -verify @import DependsOnModule; @import SubFramework; // expected-error{{module 'SubFramework' not found}} diff --git a/test/Modules/subframeworks.m b/test/Modules/subframeworks.m index 5d70bc0840d5..21081843d78c 100644 --- a/test/Modules/subframeworks.m +++ b/test/Modules/subframeworks.m @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -F %S/Inputs -F %S/Inputs/DependsOnModule.framework/Frameworks %s -verify -// RUN: %clang_cc1 -x objective-c++ -Wauto-import -fmodules-cache-path=%t -fmodules -F %S/Inputs -F %S/Inputs/DependsOnModule.framework/Frameworks %s -verify +// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -F %S/Inputs/DependsOnModule.framework/Frameworks %s -verify +// RUN: %clang_cc1 -x objective-c++ -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -F %S/Inputs/DependsOnModule.framework/Frameworks %s -verify @import DependsOnModule; diff --git a/test/Modules/submodule-visibility-cycles.cpp b/test/Modules/submodule-visibility-cycles.cpp index fca8df9f77ee..f26f6f21eea6 100644 --- a/test/Modules/submodule-visibility-cycles.cpp +++ b/test/Modules/submodule-visibility-cycles.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fno-modules-error-recovery -fmodules-local-submodule-visibility -fmodules-cache-path=%t -I%S/Inputs/submodule-visibility -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-local-submodule-visibility -fmodules-cache-path=%t -I%S/Inputs/submodule-visibility -verify %s #include "cycle1.h" C1 c1; diff --git a/test/Modules/submodule-visibility.cpp b/test/Modules/submodule-visibility.cpp index 07be1c2d0c34..084f811f231f 100644 --- a/test/Modules/submodule-visibility.cpp +++ b/test/Modules/submodule-visibility.cpp @@ -1,8 +1,8 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/submodule-visibility -verify %s -DALLOW_NAME_LEAKAGE -// RUN: %clang_cc1 -fmodules -fmodules-local-submodule-visibility -fmodules-cache-path=%t -I%S/Inputs/submodule-visibility -verify %s -DIMPORT -// RUN: %clang_cc1 -fmodules -fmodules-local-submodule-visibility -fmodules-cache-path=%t -fmodule-name=x -I%S/Inputs/submodule-visibility -verify %s -// RUN: %clang_cc1 -fmodule-maps -fmodules-local-submodule-visibility -fmodules-cache-path=%t -I%S/Inputs/submodule-visibility -verify %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/submodule-visibility -verify %s -DALLOW_NAME_LEAKAGE +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-local-submodule-visibility -fmodules-cache-path=%t -I%S/Inputs/submodule-visibility -verify %s -DIMPORT +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-local-submodule-visibility -fmodules-cache-path=%t -fmodule-name=x -I%S/Inputs/submodule-visibility -verify %s +// RUN: %clang_cc1 -fimplicit-module-maps -fmodules-local-submodule-visibility -fmodules-cache-path=%t -I%S/Inputs/submodule-visibility -verify %s #include "a.h" #include "b.h" diff --git a/test/Modules/submodules-merge-defs.cpp b/test/Modules/submodules-merge-defs.cpp index 0e2f5d9e5468..94c0fd354c98 100644 --- a/test/Modules/submodules-merge-defs.cpp +++ b/test/Modules/submodules-merge-defs.cpp @@ -1,16 +1,28 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -DTEXTUAL -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility -DTEXTUAL -// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -DTEXTUAL +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility -DTEXTUAL +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility -DTEXTUAL -DEARLY_INDIRECT_INCLUDE +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility -fmodule-feature use_defs_twice -DIMPORT_USE_2 // Trigger import of definitions, but don't make them visible. #include "empty.h" +#ifdef EARLY_INDIRECT_INCLUDE +#include "indirect.h" +#endif -A pre_a; // expected-error {{must be imported}} expected-error {{must use 'struct'}} +A pre_a; // expected-error {{must use 'struct'}} +#ifdef IMPORT_USE_2 +// expected-error-re@-2 {{must be imported from one of {{.*}}stuff.use{{.*}}stuff.use-2}} +#elif EARLY_INDIRECT_INCLUDE +// expected-error@-4 {{must be imported from module 'merged-defs'}} +#else +// expected-error@-6 {{must be imported from module 'stuff.use'}} +#endif // expected-note@defs.h:1 +{{here}} -// FIXME: We should warn that use_a is being used without being imported. -int pre_use_a = use_a(pre_a); // expected-error {{'A' must be imported}} +// expected-note@defs.h:2 +{{here}} +int pre_use_a = use_a(pre_a); // expected-error {{'A' must be imported}} expected-error {{'use_a' must be imported}} B::Inner2 pre_bi; // expected-error +{{must be imported}} // expected-note@defs.h:4 +{{here}} @@ -36,9 +48,28 @@ int pre_ff = F<int>().f(); // expected-error +{{must be imported}} int pre_fg = F<int>().g<int>(); // expected-error +{{must be imported}} // expected-note@defs.h:26 +{{here}} +G::A pre_ga // expected-error +{{must be imported}} + = G::a; // expected-error +{{must be imported}} +// expected-note@defs.h:40 +{{here}} +// expected-note@defs.h:41 +{{here}} +decltype(G::h) pre_gh = G::h; // expected-error +{{must be imported}} +// expected-note@defs.h:42 +{{here}} + +J<> pre_j; // expected-error {{declaration of 'J' must be imported}} +#ifdef IMPORT_USE_2 +// expected-error-re@-2 {{default argument of 'J' must be imported from one of {{.*}}stuff.use{{.*}}stuff.use-2}} +#elif EARLY_INDIRECT_INCLUDE +// expected-error@-4 {{default argument of 'J' must be imported from module 'merged-defs'}} +#else +// expected-error@-6 {{default argument of 'J' must be imported from module 'stuff.use'}} +#endif +// expected-note@defs.h:49 +{{here}} + // Make definitions from second module visible. #ifdef TEXTUAL #include "import-and-redefine.h" +#elif defined IMPORT_USE_2 +#include "use-defs-2.h" #else #include "merged-defs.h" #endif @@ -54,3 +85,10 @@ int post_use_dx = use_dx(post_dx); int post_e = E(0); int post_ff = F<char>().f(); int post_fg = F<char>().g<int>(); +G::A post_ga = G::a; +decltype(G::h) post_gh = G::h; +J<> post_j; +template<typename T, int N, template<typename> class K> struct J; +J<> post_j2; +FriendDefArg::Y<int> friend_def_arg; +FriendDefArg::D<> friend_def_arg_d; diff --git a/test/Modules/submodules-preprocess.cpp b/test/Modules/submodules-preprocess.cpp index 7040b5111b76..c9fad10d5e51 100644 --- a/test/Modules/submodules-preprocess.cpp +++ b/test/Modules/submodules-preprocess.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -x objective-c++ -Eonly -fmodules-cache-path=%t -I %S/Inputs/submodules %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -Eonly -fmodules-cache-path=%t -I %S/Inputs/submodules %s -verify // FIXME: When we have a syntax for modules in C++, use that. @import std.vector; diff --git a/test/Modules/submodules.cpp b/test/Modules/submodules.cpp index c3b2623016a8..a3dde23cb5b5 100644 --- a/test/Modules/submodules.cpp +++ b/test/Modules/submodules.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -I %S/Inputs/submodules %s -verify +// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules %s -verify // FIXME: When we have a syntax for modules in C++, use that. @import std.vector; diff --git a/test/Modules/submodules.m b/test/Modules/submodules.m index 7187e75f0dc5..04e758d3353a 100644 --- a/test/Modules/submodules.m +++ b/test/Modules/submodules.m @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -F %S/Inputs %s -verify +// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify // expected-no-diagnostics // Note: transitively imports Module.Sub2. diff --git a/test/Modules/system_headers.m b/test/Modules/system_headers.m index 8adc7e857699..165e8e866401 100644 --- a/test/Modules/system_headers.m +++ b/test/Modules/system_headers.m @@ -1,7 +1,7 @@ // Test that system-headerness works for building modules. // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t/cache -isystem %S/Inputs -pedantic -Werror %s -verify -std=c11 +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -isystem %S/Inputs -pedantic -Werror %s -verify -std=c11 // expected-no-diagnostics @import warning; diff --git a/test/Modules/system_version.m b/test/Modules/system_version.m index 55174ef1506c..b1bc3609272e 100644 --- a/test/Modules/system_version.m +++ b/test/Modules/system_version.m @@ -9,21 +9,21 @@ // RUN: cp %S/Inputs/Modified/module.map %t/usr/include // Run once with no system version file. We should end up with one module. -// RUN: %clang_cc1 -fmodules-cache-path=%t/cache -fmodules -isysroot %t -I %t/usr/include %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t/cache -fmodules -fimplicit-module-maps -isysroot %t -I %t/usr/include %s -verify // RUN: ls -R %t | grep -c "ModA.*pcm" | grep 1 // Add a system version file and run again. We should now have two // module variants. // RUN: mkdir -p %t/System/Library/CoreServices // RUN: echo "hello" > %t/System/Library/CoreServices/SystemVersion.plist -// RUN: %clang_cc1 -fmodules-cache-path=%t/cache -fmodules -isysroot %t -I %t/usr/include %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t/cache -fmodules -fimplicit-module-maps -isysroot %t -I %t/usr/include %s -verify // RUN: ls -R %t | grep -c "ModA.*pcm" | grep 2 // Change the system version file and run again. We should now have three // module variants. // RUN: mkdir -p %t/System/Library/CoreServices // RUN: echo "modules" > %t/System/Library/CoreServices/SystemVersion.plist -// RUN: %clang_cc1 -fmodules-cache-path=%t/cache -fmodules -isysroot %t -I %t/usr/include %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t/cache -fmodules -fimplicit-module-maps -isysroot %t -I %t/usr/include %s -verify // RUN: ls -R %t | grep -c "ModA.*pcm" | grep 3 // expected-no-diagnostics diff --git a/test/Modules/template-default-args.cpp b/test/Modules/template-default-args.cpp index 63187b8dc190..dc44534302b2 100644 --- a/test/Modules/template-default-args.cpp +++ b/test/Modules/template-default-args.cpp @@ -1,12 +1,13 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs/template-default-args -std=c++11 %s -// -// expected-no-diagnostics +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -fno-modules-error-recovery -I %S/Inputs/template-default-args -std=c++11 %s template<typename T> struct A; template<typename T> struct B; template<typename T> struct C; template<typename T = int> struct D; +template<typename T = int> struct E {}; +template<typename T> struct H {}; +template<typename T = int, typename U = int> struct I {}; #include "b.h" @@ -15,8 +16,19 @@ template<typename T> struct B {}; template<typename T = int> struct B; template<typename T = int> struct C; template<typename T> struct D {}; +template<typename T> struct F {}; +template<typename T> struct G {}; + +#include "c.h" A<> a; B<> b; extern C<> c; D<> d; +E<> e; +F<> f; +G<> g; // expected-error {{default argument of 'G' must be imported from module 'X.A' before it is required}} +// expected-note@a.h:6 {{default argument declared here}} +H<> h; // expected-error {{default argument of 'H' must be imported from module 'X.A' before it is required}} +// expected-note@a.h:7 {{default argument declared here}} +I<> i; diff --git a/test/Modules/template-specialization-visibility.cpp b/test/Modules/template-specialization-visibility.cpp index efcfd93dd88b..6f4f6efc9edc 100644 --- a/test/Modules/template-specialization-visibility.cpp +++ b/test/Modules/template-specialization-visibility.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -verify -fmodules-cache-path=%t -I %S/Inputs/template-specialization-visibility -std=c++11 %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -verify -fmodules-cache-path=%t -I %S/Inputs/template-specialization-visibility -std=c++11 %s // // expected-no-diagnostics diff --git a/test/Modules/templates-2.mm b/test/Modules/templates-2.mm index 8a752f761335..78d203ab42b4 100644 --- a/test/Modules/templates-2.mm +++ b/test/Modules/templates-2.mm @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++11 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs -verify %s -Wno-objc-root-class -// RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++11 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs -emit-llvm %s -o - -Wno-objc-root-class | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++11 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -verify %s -Wno-objc-root-class +// RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++11 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -emit-llvm %s -o - -Wno-objc-root-class | FileCheck %s // expected-no-diagnostics @import templates_top; diff --git a/test/Modules/templates.mm b/test/Modules/templates.mm index aafe0186c3ec..503f4bb459e0 100644 --- a/test/Modules/templates.mm +++ b/test/Modules/templates.mm @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++11 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs -verify %s -Wno-objc-root-class -// RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++11 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs -emit-llvm %s -o - -Wno-objc-root-class | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++11 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -verify %s -Wno-objc-root-class +// RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++11 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -emit-llvm %s -o - -Wno-objc-root-class | FileCheck %s // expected-no-diagnostics @import templates_left; diff --git a/test/Modules/textual-headers.cpp b/test/Modules/textual-headers.cpp index cab9991e3291..4df741cfe4a3 100644 --- a/test/Modules/textual-headers.cpp +++ b/test/Modules/textual-headers.cpp @@ -1,6 +1,6 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodule-maps -fmodules-cache-path=%t -fmodules-strict-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fmodules-strict-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify -fno-modules-error-recovery +// RUN: %clang_cc1 -fimplicit-module-maps -fmodules-cache-path=%t -fmodules-strict-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fmodules-strict-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify -fno-modules-error-recovery #define GIMME_A_K #include "k.h" diff --git a/test/Modules/undefined-type-fixit1.cpp b/test/Modules/undefined-type-fixit1.cpp index 78ce174f5462..3b7345710726 100644 --- a/test/Modules/undefined-type-fixit1.cpp +++ b/test/Modules/undefined-type-fixit1.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -fmodules-search-all -I %S/Inputs/undefined-type-fixit %s -verify +// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -fmodules-search-all -I %S/Inputs/undefined-type-fixit %s -verify //#include "public1.h" #include "public2.h" diff --git a/test/Modules/unnecessary-module-map-parsing.c b/test/Modules/unnecessary-module-map-parsing.c index 4c83448179e0..9dfd36cb30d5 100644 --- a/test/Modules/unnecessary-module-map-parsing.c +++ b/test/Modules/unnecessary-module-map-parsing.c @@ -1,6 +1,6 @@ // This checks that we are not parsing module maps if modules are not enabled. -// RUN: not %clang_cc1 -fmodules -I %S/Inputs/unnecessary-module-map-parsing -fsyntax-only %s 2>&1 | FileCheck %s +// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -I %S/Inputs/unnecessary-module-map-parsing -fsyntax-only %s 2>&1 | FileCheck %s // RUN: %clang_cc1 -I %S/Inputs/unnecessary-module-map-parsing -fsyntax-only %s // CHECK: error: expected umbrella, header, submodule, or module export diff --git a/test/Modules/update-after-load.cpp b/test/Modules/update-after-load.cpp index f497ea47945b..621674cf680f 100644 --- a/test/Modules/update-after-load.cpp +++ b/test/Modules/update-after-load.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -I %S/Inputs/update-after-load -verify -fmodules-cache-path=%t %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -I %S/Inputs/update-after-load -verify -fmodules-cache-path=%t %s // expected-no-diagnostics #include "a.h" diff --git a/test/Modules/update-exception-spec.cpp b/test/Modules/update-exception-spec.cpp index bccdddc9c09b..f678f6e76ecc 100644 --- a/test/Modules/update-exception-spec.cpp +++ b/test/Modules/update-exception-spec.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -fmodules -fmodules-cache-path=%t -I%S/Inputs/update-exception-spec -emit-llvm-only %s +// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/update-exception-spec -emit-llvm-only %s #include "a.h" void use(B *p); #include "c.h" diff --git a/test/Modules/using-decl.cpp b/test/Modules/using-decl.cpp index 4432738f060a..a388a5b7e711 100644 --- a/test/Modules/using-decl.cpp +++ b/test/Modules/using-decl.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify +// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify @import using_decl.a; diff --git a/test/Modules/va_list.m b/test/Modules/va_list.m index 5a305180fcfa..d13b39b48f4a 100644 --- a/test/Modules/va_list.m +++ b/test/Modules/va_list.m @@ -1,22 +1,22 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -fmodules-ignore-macro=PREFIX -DPREFIX -I %S/Inputs/va_list \ // RUN: -x objective-c-header %s -o %t.pch -emit-pch // Include the pch, as a sanity check. -// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -fmodules-ignore-macro=PREFIX -I %S/Inputs/va_list -include-pch %t.pch \ // RUN: -x objective-c %s -fsyntax-only // Repeat the previous emit-pch, but not we will have a global module index. // For some reason, this results in an identifier for __va_list_tag being // emitted into the pch. -// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -fmodules-ignore-macro=PREFIX -DPREFIX -I %S/Inputs/va_list \ // RUN: -x objective-c-header %s -o %t.pch -emit-pch // Include the pch, which now has __va_list_tag in it, which needs to be merged. -// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fmodules-cache-path=%t \ +// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -fmodules-ignore-macro=PREFIX -I %S/Inputs/va_list -include-pch %t.pch \ // RUN: -x objective-c %s -fsyntax-only diff --git a/test/Modules/validate-system-headers.m b/test/Modules/validate-system-headers.m index 8cdc886322bd..d05fae777bb1 100644 --- a/test/Modules/validate-system-headers.m +++ b/test/Modules/validate-system-headers.m @@ -5,37 +5,37 @@ //// // Build a module using a system header -// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s +// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s // RUN: cp %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved //// // Modify the system header, and confirm that we don't notice without -fmodules-validate-system-headers. // The pcm file in the cache should fail to validate. // RUN: echo ' ' >> %t/Inputs/usr/include/foo.h -// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s +// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s // RUN: diff %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved //// // Now make sure we rebuild the module when -fmodules-validate-system-headers is set. -// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fmodules-validate-system-headers -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s +// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fimplicit-module-maps -fmodules-validate-system-headers -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s // RUN: not diff %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved //// // This should override -fmodules-validate-once-per-build-session // RUN: cp %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved -// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session +// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session // RUN: diff %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved // Modify the system header... // RUN: echo ' ' >> %t/Inputs/usr/include/foo.h // Don't recompile due to -fmodules-validate-once-per-build-session -// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session +// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session // RUN: diff %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved // Now add -fmodules-validate-system-headers and rebuild -// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fmodules-validate-system-headers -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session +// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fimplicit-module-maps -fmodules-validate-system-headers -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session // RUN: not diff %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved @import Foo; diff --git a/test/Modules/warn-unused-local-typedef.cpp b/test/Modules/warn-unused-local-typedef.cpp index 030a52de4647..14cfcc3ebcf0 100644 --- a/test/Modules/warn-unused-local-typedef.cpp +++ b/test/Modules/warn-unused-local-typedef.cpp @@ -1,7 +1,6 @@ -// XFAIL: hexagon // RUN: rm -rf %t -// RUN: %clang -Wunused-local-typedef -c -x objective-c++ -fcxx-modules -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=CHECK_1 -// RUN: %clang -Wunused-local-typedef -c -x objective-c++ -fcxx-modules -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=CHECK_2 -allow-empty +// RUN: %clang_cc1 -Wunused-local-typedef -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -fsyntax-only 2>&1 | FileCheck %s -check-prefix=CHECK_1 +// RUN: %clang_cc1 -Wunused-local-typedef -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -fsyntax-only 2>&1 | FileCheck %s -check-prefix=CHECK_2 --allow-empty // For modules, the warning should only fire the first time, when the module is // built. diff --git a/test/Modules/wildcard-submodule-exports.cpp b/test/Modules/wildcard-submodule-exports.cpp index f377dbecde86..321d930435d8 100644 --- a/test/Modules/wildcard-submodule-exports.cpp +++ b/test/Modules/wildcard-submodule-exports.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -I %S/Inputs/wildcard-submodule-exports %s -verify +// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/wildcard-submodule-exports %s -verify // FIXME: When we have a syntax for modules in C++, use that. @import C.One; diff --git a/test/OpenMP/for_simd_codegen.cpp b/test/OpenMP/for_simd_codegen.cpp new file mode 100644 index 000000000000..00ec6cb0d6c7 --- /dev/null +++ b/test/OpenMP/for_simd_codegen.cpp @@ -0,0 +1,686 @@ +// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG +// +// expected-no-diagnostics +#ifndef HEADER +#define HEADER + +long long get_val() { return 0; } +double *g_ptr; + +// CHECK-LABEL: define {{.*void}} @{{.*}}simple{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}}) +void simple(float *a, float *b, float *c, float *d) { + #pragma omp for simd +// CHECK: call void @__kmpc_for_static_init_4(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i32* [[LB:%[^,]+]], i32* [[UB:%[^,]+]], i32* [[STRIDE:%[^,]+]], i32 1, i32 1) +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: [[CMP:%.+]] = icmp sgt i32 [[UB_VAL]], 5 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i32 [ 5, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i32 [[UP]], i32* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i32, i32* [[LB]], +// CHECK: store i32 [[LB_VAL]], i32* [[OMP_IV:%[^,]+]], + +// CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP]], label %[[SIMPLE_LOOP1_BODY:.+]], label %[[SIMPLE_LOOP1_END:[^,]+]] + for (int i = 3; i < 32; i += 5) { +// CHECK: [[SIMPLE_LOOP1_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV1_1:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// CHECK: [[CALC_I_1:%.+]] = mul nsw i32 [[IV1_1]], 5 +// CHECK-NEXT: [[CALC_I_2:%.+]] = add nsw i32 3, [[CALC_I_1]] +// CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// ... loop body ... +// End of body: store into a[i]: +// CHECK: store float [[RESULT:%.+]], float* {{%.+}}{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] + a[i] = b[i] * c[i] * d[i]; +// CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1 +// CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// br label %{{.+}}, !llvm.loop !{{.+}} + } +// CHECK: [[SIMPLE_LOOP1_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + + long long k = get_val(); + + #pragma omp for simd linear(k : 3) schedule(dynamic) +// CHECK: [[K0:%.+]] = call {{.*}}i64 @{{.*}}get_val +// CHECK-NEXT: store i64 [[K0]], i64* [[K_VAR:%[^,]+]] +// CHECK: [[K0LOAD:%.+]] = load i64, i64* [[K_VAR]] +// CHECK-NEXT: store i64 [[K0LOAD]], i64* [[LIN0:%[^,]+]] + +// CHECK: call void @__kmpc_dispatch_init_4(%ident_t* {{.+}}, i32 %{{.+}}, i32 35, i32 0, i32 8, i32 1, i32 1) +// CHECK: [[NEXT:%.+]] = call i32 @__kmpc_dispatch_next_4(%ident_t* {{.+}}, i32 %{{.+}}, i32* %{{.+}}, i32* [[LB:%.+]], i32* [[UB:%.+]], i32* %{{.+}}) +// CHECK: [[COND:%.+]] = icmp ne i32 [[NEXT]], 0 +// CHECK: br i1 [[COND]], label %[[CONT:.+]], label %[[END:.+]] +// CHECK: [[CONT]] +// CHECK: [[LB_VAL:%.+]] = load i32, i32* [[LB]], +// CHECK: store i32 [[LB_VAL]], i32* [[OMP_IV2:%[^,]+]], + +// CHECK: [[IV2:%.+]] = load i32, i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// CHECK-NEXT: [[CMP2:%.+]] = icmp sle i32 [[IV2]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP2]], label %[[SIMPLE_LOOP2_BODY:.+]], label %[[SIMPLE_LOOP2_END:[^,]+]] + for (int i = 10; i > 1; i--) { +// CHECK: [[SIMPLE_LOOP2_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV2_0:%.+]] = load i32, i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// FIXME: It is interesting, why the following "mul 1" was not constant folded? +// CHECK-NEXT: [[IV2_1:%.+]] = mul nsw i32 [[IV2_0]], 1 +// CHECK-NEXT: [[LC_I_1:%.+]] = sub nsw i32 10, [[IV2_1]] +// CHECK-NEXT: store i32 [[LC_I_1]], i32* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// +// CHECK-NEXT: [[LIN0_1:%.+]] = load i64, i64* [[LIN0]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// CHECK-NEXT: [[IV2_2:%.+]] = load i32, i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// CHECK-NEXT: [[LIN_MUL1:%.+]] = mul nsw i32 [[IV2_2]], 3 +// CHECK-NEXT: [[LIN_EXT1:%.+]] = sext i32 [[LIN_MUL1]] to i64 +// CHECK-NEXT: [[LIN_ADD1:%.+]] = add nsw i64 [[LIN0_1]], [[LIN_EXT1]] +// Update of the privatized version of linear variable! +// CHECK-NEXT: store i64 [[LIN_ADD1]], i64* [[K_PRIVATIZED:%[^,]+]] + a[k]++; + k = k + 3; +// CHECK: [[IV2_2:%.+]] = load i32, i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// CHECK-NEXT: [[ADD2_2:%.+]] = add nsw i32 [[IV2_2]], 1 +// CHECK-NEXT: store i32 [[ADD2_2]], i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// br label {{.+}}, !llvm.loop ![[SIMPLE_LOOP2_ID]] + } +// CHECK: [[SIMPLE_LOOP2_END]] +// +// Update linear vars after loop, as the loop was operating on a private version. +// CHECK: [[LIN0_2:%.+]] = load i64, i64* [[LIN0]] +// CHECK-NEXT: [[LIN_ADD2:%.+]] = add nsw i64 [[LIN0_2]], 27 +// CHECK-NEXT: store i64 [[LIN_ADD2]], i64* [[K_VAR]] +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + + int lin = 12; + #pragma omp for simd linear(lin : get_val()), linear(g_ptr) + +// Init linear private var. +// CHECK: store i32 12, i32* [[LIN_VAR:%[^,]+]] +// CHECK: [[LIN_LOAD:%.+]] = load i32, i32* [[LIN_VAR]] +// CHECK-NEXT: store i32 [[LIN_LOAD]], i32* [[LIN_START:%[^,]+]] +// Remember linear step. +// CHECK: [[CALL_VAL:%.+]] = invoke +// CHECK: store i64 [[CALL_VAL]], i64* [[LIN_STEP:%[^,]+]] + +// CHECK: [[GLIN_LOAD:%.+]] = load double*, double** [[GLIN_VAR:@[^,]+]] +// CHECK-NEXT: store double* [[GLIN_LOAD]], double** [[GLIN_START:%[^,]+]] + +// CHECK: call void @__kmpc_for_static_init_8u(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i64* [[LB:%[^,]+]], i64* [[UB:%[^,]+]], i64* [[STRIDE:%[^,]+]], i64 1, i64 1) +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: [[CMP:%.+]] = icmp ugt i64 [[UB_VAL]], 3 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i64 [ 3, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i64 [[UP]], i64* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i64, i64* [[LB]], +// CHECK: store i64 [[LB_VAL]], i64* [[OMP_IV3:%[^,]+]], + +// CHECK: [[IV3:%.+]] = load i64, i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NEXT: [[CMP3:%.+]] = icmp ule i64 [[IV3]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP3]], label %[[SIMPLE_LOOP3_BODY:.+]], label %[[SIMPLE_LOOP3_END:[^,]+]] + for (unsigned long long it = 2000; it >= 600; it-=400) { +// CHECK: [[SIMPLE_LOOP3_BODY]] +// Start of body: calculate it from IV: +// CHECK: [[IV3_0:%.+]] = load i64, i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul i64 [[IV3_0]], 400 +// CHECK-NEXT: [[LC_IT_2:%.+]] = sub i64 2000, [[LC_IT_1]] +// CHECK-NEXT: store i64 [[LC_IT_2]], i64* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// +// Linear start and step are used to calculate current value of the linear variable. +// CHECK: [[LINSTART:.+]] = load i32, i32* [[LIN_START]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK: [[LINSTEP:.+]] = load i64, i64* [[LIN_STEP]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NOT: store i32 {{.+}}, i32* [[LIN_VAR]],{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK: [[GLINSTART:.+]] = load double*, double** [[GLIN_START]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NEXT: [[IV3_1:%.+]] = load i64, i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NEXT: [[MUL:%.+]] = mul i64 [[IV3_1]], 1 +// CHECK: [[GEP:%.+]] = getelementptr{{.*}}[[GLINSTART]] +// CHECK-NEXT: store double* [[GEP]], double** [[G_PTR_CUR:%[^,]+]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] + *g_ptr++ = 0.0; +// CHECK: [[GEP_VAL:%.+]] = load double{{.*}}[[G_PTR_CUR]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK: store double{{.*}}[[GEP_VAL]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] + a[it + lin]++; +// CHECK: [[FLT_INC:%.+]] = fadd float +// CHECK-NEXT: store float [[FLT_INC]],{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK: [[IV3_2:%.+]] = load i64, i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NEXT: [[ADD3_2:%.+]] = add i64 [[IV3_2]], 1 +// CHECK-NEXT: store i64 [[ADD3_2]], i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] + } +// CHECK: [[SIMPLE_LOOP3_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// +// Linear start and step are used to calculate final value of the linear variables. +// CHECK: [[LINSTART:.+]] = load i32, i32* [[LIN_START]] +// CHECK: [[LINSTEP:.+]] = load i64, i64* [[LIN_STEP]] +// CHECK: store i32 {{.+}}, i32* [[LIN_VAR]], +// CHECK: [[GLINSTART:.+]] = load double*, double** [[GLIN_START]] +// CHECK: store double* {{.*}}[[GLIN_VAR]] +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + + #pragma omp for simd +// CHECK: call void @__kmpc_for_static_init_4(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i32* [[LB:%[^,]+]], i32* [[UB:%[^,]+]], i32* [[STRIDE:%[^,]+]], i32 1, i32 1) +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: [[CMP:%.+]] = icmp sgt i32 [[UB_VAL]], 3 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i32 [ 3, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i32 [[UP]], i32* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i32, i32* [[LB]], +// CHECK: store i32 [[LB_VAL]], i32* [[OMP_IV4:%[^,]+]], + +// CHECK: [[IV4:%.+]] = load i32, i32* [[OMP_IV4]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] +// CHECK-NEXT: [[CMP4:%.+]] = icmp sle i32 [[IV4]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP4]], label %[[SIMPLE_LOOP4_BODY:.+]], label %[[SIMPLE_LOOP4_END:[^,]+]] + for (short it = 6; it <= 20; it-=-4) { +// CHECK: [[SIMPLE_LOOP4_BODY]] +// Start of body: calculate it from IV: +// CHECK: [[IV4_0:%.+]] = load i32, i32* [[OMP_IV4]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul nsw i32 [[IV4_0]], 4 +// CHECK-NEXT: [[LC_IT_2:%.+]] = add nsw i32 6, [[LC_IT_1]] +// CHECK-NEXT: [[LC_IT_3:%.+]] = trunc i32 [[LC_IT_2]] to i16 +// CHECK-NEXT: store i16 [[LC_IT_3]], i16* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] + +// CHECK: [[IV4_2:%.+]] = load i32, i32* [[OMP_IV4]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] +// CHECK-NEXT: [[ADD4_2:%.+]] = add nsw i32 [[IV4_2]], 1 +// CHECK-NEXT: store i32 [[ADD4_2]], i32* [[OMP_IV4]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] + } +// CHECK: [[SIMPLE_LOOP4_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + + #pragma omp for simd +// CHECK: call void @__kmpc_for_static_init_4(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i32* [[LB:%[^,]+]], i32* [[UB:%[^,]+]], i32* [[STRIDE:%[^,]+]], i32 1, i32 1) +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: [[CMP:%.+]] = icmp sgt i32 [[UB_VAL]], 25 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i32 [ 25, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i32 [[UP]], i32* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i32, i32* [[LB]], +// CHECK: store i32 [[LB_VAL]], i32* [[OMP_IV5:%[^,]+]], + +// CHECK: [[IV5:%.+]] = load i32, i32* [[OMP_IV5]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] +// CHECK-NEXT: [[CMP5:%.+]] = icmp sle i32 [[IV5]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP5]], label %[[SIMPLE_LOOP5_BODY:.+]], label %[[SIMPLE_LOOP5_END:[^,]+]] + for (unsigned char it = 'z'; it >= 'a'; it+=-1) { +// CHECK: [[SIMPLE_LOOP5_BODY]] +// Start of body: calculate it from IV: +// CHECK: [[IV5_0:%.+]] = load i32, i32* [[OMP_IV5]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] +// CHECK-NEXT: [[IV5_1:%.+]] = mul nsw i32 [[IV5_0]], 1 +// CHECK-NEXT: [[LC_IT_1:%.+]] = sub nsw i32 122, [[IV5_1]] +// CHECK-NEXT: [[LC_IT_2:%.+]] = trunc i32 [[LC_IT_1]] to i8 +// CHECK-NEXT: store i8 [[LC_IT_2]], i8* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] + +// CHECK: [[IV5_2:%.+]] = load i32, i32* [[OMP_IV5]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] +// CHECK-NEXT: [[ADD5_2:%.+]] = add nsw i32 [[IV5_2]], 1 +// CHECK-NEXT: store i32 [[ADD5_2]], i32* [[OMP_IV5]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] + } +// CHECK: [[SIMPLE_LOOP5_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + +// CHECK-NOT: mul i32 %{{.+}}, 10 + #pragma omp for simd + for (unsigned i=100; i<10; i+=10) { + } + + int A; + #pragma omp parallel + { + // CHECK: store i32 -1, i32* [[A:%.+]], + A = -1; + #pragma omp for simd lastprivate(A) +// CHECK: call void @__kmpc_for_static_init_8(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i64* [[LB:%[^,]+]], i64* [[UB:%[^,]+]], i64* [[STRIDE:%[^,]+]], i64 1, i64 1) +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: [[CMP:%.+]] = icmp sgt i64 [[UB_VAL]], 6 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i64 [ 6, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i64 [[UP]], i64* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i64, i64* [[LB]], +// CHECK: store i64 [[LB_VAL]], i64* [[OMP_IV7:%[^,]+]], + +// CHECK: br label %[[SIMD_LOOP7_COND:[^,]+]] +// CHECK: [[SIMD_LOOP7_COND]] +// CHECK-NEXT: [[IV7:%.+]] = load i64, i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID:[0-9]+]] +// CHECK-NEXT: [[UB_VAL:%.+]] = load i64, i64* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[CMP7:%.+]] = icmp sle i64 [[IV7]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP7]], label %[[SIMPLE_LOOP7_BODY:.+]], label %[[SIMPLE_LOOP7_END:[^,]+]] + for (long long i = -10; i < 10; i += 3) { +// CHECK: [[SIMPLE_LOOP7_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV7_0:%.+]] = load i64, i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul nsw i64 [[IV7_0]], 3 +// CHECK-NEXT: [[LC_IT_2:%.+]] = add nsw i64 -10, [[LC_IT_1]] +// CHECK-NEXT: store i64 [[LC_IT_2]], i64* [[LC:%[^,]+]],{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[LC_VAL:%.+]] = load i64, i64* [[LC]]{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[CONV:%.+]] = trunc i64 [[LC_VAL]] to i32 +// CHECK-NEXT: store i32 [[CONV]], i32* [[A_PRIV:%[^,]+]],{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] + A = i; +// CHECK: [[IV7_2:%.+]] = load i64, i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[ADD7_2:%.+]] = add nsw i64 [[IV7_2]], 1 +// CHECK-NEXT: store i64 [[ADD7_2]], i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] + } +// CHECK: [[SIMPLE_LOOP7_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: load i32, i32* +// CHECK: icmp ne i32 %{{.+}}, 0 +// CHECK: br i1 %{{.+}}, label +// CHECK: [[A_PRIV_VAL:%.+]] = load i32, i32* [[A_PRIV]], +// CHECK-NEXT: store i32 [[A_PRIV_VAL]], i32* %{{.+}}, +// CHECK-NEXT: br label +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + } + int R; + #pragma omp parallel + { + // CHECK: store i32 -1, i32* [[R:%[^,]+]], + R = -1; +// CHECK: store i32 1, i32* [[R_PRIV:%[^,]+]], + #pragma omp for simd reduction(*:R) +// CHECK: call void @__kmpc_for_static_init_8(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i64* [[LB:%[^,]+]], i64* [[UB:%[^,]+]], i64* [[STRIDE:%[^,]+]], i64 1, i64 1) +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: [[CMP:%.+]] = icmp sgt i64 [[UB_VAL]], 6 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i64 [ 6, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i64 [[UP]], i64* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i64, i64* [[LB]], +// CHECK: store i64 [[LB_VAL]], i64* [[OMP_IV8:%[^,]+]], + +// CHECK: br label %[[SIMD_LOOP8_COND:[^,]+]] +// CHECK: [[SIMD_LOOP8_COND]] +// CHECK-NEXT: [[IV8:%.+]] = load i64, i64* [[OMP_IV8]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID:[0-9]+]] +// CHECK-NEXT: [[UB_VAL:%.+]] = load i64, i64* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK-NEXT: [[CMP8:%.+]] = icmp sle i64 [[IV8]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP8]], label %[[SIMPLE_LOOP8_BODY:.+]], label %[[SIMPLE_LOOP8_END:[^,]+]] + for (long long i = -10; i < 10; i += 3) { +// CHECK: [[SIMPLE_LOOP8_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV8_0:%.+]] = load i64, i64* [[OMP_IV8]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul nsw i64 [[IV8_0]], 3 +// CHECK-NEXT: [[LC_IT_2:%.+]] = add nsw i64 -10, [[LC_IT_1]] +// CHECK-NEXT: store i64 [[LC_IT_2]], i64* [[LC:%[^,]+]],{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK-NEXT: [[LC_VAL:%.+]] = load i64, i64* [[LC]]{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK: store i32 %{{.+}}, i32* [[R_PRIV]],{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] + R *= i; +// CHECK: [[IV8_2:%.+]] = load i64, i64* [[OMP_IV8]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK-NEXT: [[ADD8_2:%.+]] = add nsw i64 [[IV8_2]], 1 +// CHECK-NEXT: store i64 [[ADD8_2]], i64* [[OMP_IV8]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] + } +// CHECK: [[SIMPLE_LOOP8_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call i32 @__kmpc_reduce( +// CHECK: [[R_PRIV_VAL:%.+]] = load i32, i32* [[R_PRIV]], +// CHECK: [[RED:%.+]] = mul nsw i32 %{{.+}}, [[R_PRIV_VAL]] +// CHECK-NEXT: store i32 [[RED]], i32* %{{.+}}, +// CHECK-NEXT: call void @__kmpc_end_reduce( +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + } +} + +template <class T, unsigned K> T tfoo(T a) { return a + K; } + +template <typename T, unsigned N> +int templ1(T a, T *z) { + #pragma omp for simd collapse(N) + for (int i = 0; i < N * 2; i++) { + for (long long j = 0; j < (N + N + N + N); j += 2) { + z[i + j] = a + tfoo<T, N>(i + j); + } + } + return 0; +} + +// Instatiation templ1<float,2> +// CHECK-LABEL: define {{.*i32}} @{{.*}}templ1{{.*}}(float {{.+}}, float* {{.+}}) +// CHECK: call void @__kmpc_for_static_init_8(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i64* [[LB:%[^,]+]], i64* [[UB:%[^,]+]], i64* [[STRIDE:%[^,]+]], i64 1, i64 1) +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: [[CMP:%.+]] = icmp sgt i64 [[UB_VAL]], 15 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i64 [ 15, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i64 [[UP]], i64* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i64, i64* [[LB]], +// CHECK: store i64 [[LB_VAL]], i64* [[T1_OMP_IV:%[^,]+]], + +// ... +// CHECK: [[IV:%.+]] = load i64, i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID:[0-9]+]] +// CHECK-NEXT: [[UB_VAL:%.+]] = load i64, i64* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: [[CMP1:%.+]] = icmp sle i64 [[IV]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP1]], label %[[T1_BODY:.+]], label %[[T1_END:[^,]+]] +// CHECK: [[T1_BODY]] +// Loop counters i and j updates: +// CHECK: [[IV1:%.+]] = load i64, i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: [[I_1:%.+]] = sdiv i64 [[IV1]], 4 +// CHECK-NEXT: [[I_1_MUL1:%.+]] = mul nsw i64 [[I_1]], 1 +// CHECK-NEXT: [[I_1_ADD0:%.+]] = add nsw i64 0, [[I_1_MUL1]] +// CHECK-NEXT: [[I_2:%.+]] = trunc i64 [[I_1_ADD0]] to i32 +// CHECK-NEXT: store i32 [[I_2]], i32* {{%.+}}{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK: [[IV2:%.+]] = load i64, i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: [[J_1:%.+]] = srem i64 [[IV2]], 4 +// CHECK-NEXT: [[J_2:%.+]] = mul nsw i64 [[J_1]], 2 +// CHECK-NEXT: [[J_2_ADD0:%.+]] = add nsw i64 0, [[J_2]] +// CHECK-NEXT: store i64 [[J_2_ADD0]], i64* {{%.+}}{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// simd.for.inc: +// CHECK: [[IV3:%.+]] = load i64, i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: [[INC:%.+]] = add nsw i64 [[IV3]], 1 +// CHECK-NEXT: store i64 [[INC]], i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: br label {{%.+}} +// CHECK: [[T1_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: ret i32 0 +// +void inst_templ1() { + float a; + float z[100]; + templ1<float,2> (a, z); +} + + +typedef int MyIdx; + +class IterDouble { + double *Ptr; +public: + IterDouble operator++ () const { + IterDouble n; + n.Ptr = Ptr + 1; + return n; + } + bool operator < (const IterDouble &that) const { + return Ptr < that.Ptr; + } + double & operator *() const { + return *Ptr; + } + MyIdx operator - (const IterDouble &that) const { + return (MyIdx) (Ptr - that.Ptr); + } + IterDouble operator + (int Delta) { + IterDouble re; + re.Ptr = Ptr + Delta; + return re; + } + + ///~IterDouble() {} +}; + +// CHECK-LABEL: define {{.*void}} @{{.*}}iter_simple{{.*}} +void iter_simple(IterDouble ia, IterDouble ib, IterDouble ic) { +// +// Calculate number of iterations before the loop body. +// CHECK: [[DIFF1:%.+]] = invoke {{.*}}i32 @{{.*}}IterDouble{{.*}} +// CHECK: [[DIFF2:%.+]] = sub nsw i32 [[DIFF1]], 1 +// CHECK-NEXT: [[DIFF3:%.+]] = add nsw i32 [[DIFF2]], 1 +// CHECK-NEXT: [[DIFF4:%.+]] = sdiv i32 [[DIFF3]], 1 +// CHECK-NEXT: [[DIFF5:%.+]] = sub nsw i32 [[DIFF4]], 1 +// CHECK-NEXT: store i32 [[DIFF5]], i32* [[OMP_LAST_IT:%[^,]+]]{{.+}} + #pragma omp for simd + +// CHECK: call void @__kmpc_for_static_init_4(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i32* [[LB:%[^,]+]], i32* [[UB:%[^,]+]], i32* [[STRIDE:%[^,]+]], i32 1, i32 1) +// CHECK-DAG: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK-DAG: [[OMP_LAST_IT_VAL:%.+]] = load i32, i32* [[OMP_LAST_IT]], +// CHECK: [[CMP:%.+]] = icmp sgt i32 [[UB_VAL]], [[OMP_LAST_IT_VAL]] +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: [[OMP_LAST_IT_VAL:%.+]] = load i32, i32* [[OMP_LAST_IT]], +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i32 [ [[OMP_LAST_IT_VAL]], %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i32 [[UP]], i32* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i32, i32* [[LB]], +// CHECK: store i32 [[LB_VAL]], i32* [[IT_OMP_IV:%[^,]+]], + +// CHECK: [[IV:%.+]] = load i32, i32* [[IT_OMP_IV]]{{.+}} !llvm.mem.parallel_loop_access ![[ITER_LOOP_ID:[0-9]+]] +// CHECK-NEXT: [[UB_VAL:%.+]] = load i32, i32* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP]], label %[[IT_BODY:[^,]+]], label %[[IT_END:[^,]+]] + for (IterDouble i = ia; i < ib; ++i) { +// CHECK: [[IT_BODY]] +// Start of body: calculate i from index: +// CHECK: [[IV1:%.+]] = load i32, i32* [[IT_OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// Call of operator+ (i, IV). +// CHECK: {{%.+}} = invoke {{.+}} @{{.*}}IterDouble{{.*}} +// ... loop body ... + *i = *ic * 0.5; +// Float multiply and save result. +// CHECK: [[MULR:%.+]] = fmul double {{%.+}}, 5.000000e-01 +// CHECK-NEXT: invoke {{.+}} @{{.*}}IterDouble{{.*}} +// CHECK: store double [[MULR:%.+]], double* [[RESULT_ADDR:%.+]], !llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] + ++ic; +// +// CHECK: [[IV2:%.+]] = load i32, i32* [[IT_OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// CHECK-NEXT: [[ADD2:%.+]] = add nsw i32 [[IV2]], 1 +// CHECK-NEXT: store i32 [[ADD2]], i32* [[IT_OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// br label %{{.*}}, !llvm.loop ![[ITER_LOOP_ID]] + } +// CHECK: [[IT_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: ret void +} + + +// CHECK-LABEL: define {{.*void}} @{{.*}}collapsed{{.*}} +void collapsed(float *a, float *b, float *c, float *d) { + int i; // outer loop counter + unsigned j; // middle loop couter, leads to unsigned icmp in loop header. + // k declared in the loop init below + short l; // inner loop counter +// CHECK: call void @__kmpc_for_static_init_4u(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i32* [[LB:%[^,]+]], i32* [[UB:%[^,]+]], i32* [[STRIDE:%[^,]+]], i32 1, i32 1) +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: [[CMP:%.+]] = icmp ugt i32 [[UB_VAL]], 119 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i32 [ 119, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i32 [[UP]], i32* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i32, i32* [[LB]], +// CHECK: store i32 [[LB_VAL]], i32* [[OMP_IV:%[^,]+]], +// + #pragma omp for simd collapse(4) + +// CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[CMP:%.+]] = icmp ule i32 [[IV]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP]], label %[[COLL1_BODY:[^,]+]], label %[[COLL1_END:[^,]+]] + for (i = 1; i < 3; i++) // 2 iterations + for (j = 2u; j < 5u; j++) //3 iterations + for (int k = 3; k <= 6; k++) // 4 iterations + for (l = 4; l < 9; ++l) // 5 iterations + { +// CHECK: [[COLL1_BODY]] +// Start of body: calculate i from index: +// CHECK: [[IV1:%.+]] = load i32, i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// Calculation of the loop counters values. +// CHECK: [[CALC_I_1:%.+]] = udiv i32 [[IV1]], 60 +// CHECK-NEXT: [[CALC_I_1_MUL1:%.+]] = mul i32 [[CALC_I_1]], 1 +// CHECK-NEXT: [[CALC_I_2:%.+]] = add i32 1, [[CALC_I_1_MUL1]] +// CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]] +// CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[CALC_J_1:%.+]] = udiv i32 [[IV1_2]], 20 +// CHECK-NEXT: [[CALC_J_2:%.+]] = urem i32 [[CALC_J_1]], 3 +// CHECK-NEXT: [[CALC_J_2_MUL1:%.+]] = mul i32 [[CALC_J_2]], 1 +// CHECK-NEXT: [[CALC_J_3:%.+]] = add i32 2, [[CALC_J_2_MUL1]] +// CHECK-NEXT: store i32 [[CALC_J_3]], i32* [[LC_J:.+]] +// CHECK: [[IV1_3:%.+]] = load i32, i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[CALC_K_1:%.+]] = udiv i32 [[IV1_3]], 5 +// CHECK-NEXT: [[CALC_K_2:%.+]] = urem i32 [[CALC_K_1]], 4 +// CHECK-NEXT: [[CALC_K_2_MUL1:%.+]] = mul i32 [[CALC_K_2]], 1 +// CHECK-NEXT: [[CALC_K_3:%.+]] = add i32 3, [[CALC_K_2_MUL1]] +// CHECK-NEXT: store i32 [[CALC_K_3]], i32* [[LC_K:.+]] +// CHECK: [[IV1_4:%.+]] = load i32, i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[CALC_L_1:%.+]] = urem i32 [[IV1_4]], 5 +// CHECK-NEXT: [[CALC_L_1_MUL1:%.+]] = mul i32 [[CALC_L_1]], 1 +// CHECK-NEXT: [[CALC_L_2:%.+]] = add i32 4, [[CALC_L_1_MUL1]] +// CHECK-NEXT: [[CALC_L_3:%.+]] = trunc i32 [[CALC_L_2]] to i16 +// CHECK-NEXT: store i16 [[CALC_L_3]], i16* [[LC_L:.+]] +// ... loop body ... +// End of body: store into a[i]: +// CHECK: store float [[RESULT:%.+]], float* [[RESULT_ADDR:%.+]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] + float res = b[j] * c[k]; + a[i] = res * d[l]; +// CHECK: [[IV2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[ADD2:%.+]] = add i32 [[IV2]], 1 +// CHECK-NEXT: store i32 [[ADD2]], i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// br label %{{[^,]+}}, !llvm.loop ![[COLL1_LOOP_ID]] +// CHECK: [[COLL1_END]] + } +// i,j,l are updated; k is not updated. +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK-NEXT: store i32 3, i32* [[I:%[^,]+]] +// CHECK-NEXT: store i32 5, i32* [[I:%[^,]+]] +// CHECK-NEXT: store i16 9, i16* [[I:%[^,]+]] +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: ret void +} + +extern char foo(); +extern double globalfloat; + +// CHECK-LABEL: define {{.*void}} @{{.*}}widened{{.*}} +void widened(float *a, float *b, float *c, float *d) { + int i; // outer loop counter + short j; // inner loop counter + globalfloat = 1.0; + int localint = 1; +// CHECK: store double {{.+}}, double* [[GLOBALFLOAT:@.+]] +// Counter is widened to 64 bits. +// CHECK: [[MUL:%.+]] = mul nsw i64 2, %{{.+}} +// CHECK-NEXT: [[SUB:%.+]] = sub nsw i64 [[MUL]], 1 +// CHECK-NEXT: store i64 [[SUB]], i64* [[OMP_LAST_IT:%[^,]+]], +// CHECK: call void @__kmpc_for_static_init_8(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i64* [[LB:%[^,]+]], i64* [[UB:%[^,]+]], i64* [[STRIDE:%[^,]+]], i64 1, i64 1) +// CHECK-DAG: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK-DAG: [[OMP_LAST_IT_VAL:%.+]] = load i64, i64* [[OMP_LAST_IT]], +// CHECK: [[CMP:%.+]] = icmp sgt i64 [[UB_VAL]], [[OMP_LAST_IT_VAL]] +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: [[OMP_LAST_IT_VAL:%.+]] = load i64, i64* [[OMP_LAST_IT]], +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i64 [ [[OMP_LAST_IT_VAL]], %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i64 [[UP]], i64* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i64, i64* [[LB]], +// CHECK: store i64 [[LB_VAL]], i64* [[OMP_IV:%[^,]+]], +// + #pragma omp for simd collapse(2) private(globalfloat, localint) + +// CHECK: [[IV:%.+]] = load i64, i64* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// CHECK-NEXT: [[CMP:%.+]] = icmp sle i64 [[IV]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP]], label %[[WIDE1_BODY:[^,]+]], label %[[WIDE1_END:[^,]+]] + for (i = 1; i < 3; i++) // 2 iterations + for (j = 0; j < foo(); j++) // foo() iterations + { +// CHECK: [[WIDE1_BODY]] +// Start of body: calculate i from index: +// CHECK: [[IV1:%.+]] = load i64, i64* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// Calculation of the loop counters values... +// CHECK: store i32 {{[^,]+}}, i32* [[LC_I:.+]] +// CHECK: [[IV1_2:%.+]] = load i64, i64* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// CHECK: store i16 {{[^,]+}}, i16* [[LC_J:.+]] +// ... loop body ... +// +// Here we expect store into private double var, not global +// CHECK-NOT: store double {{.+}}, double* [[GLOBALFLOAT]] + globalfloat = (float)j/i; + float res = b[j] * c[j]; +// Store into a[i]: +// CHECK: store float [[RESULT:%.+]], float* [[RESULT_ADDR:%.+]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] + a[i] = res * d[i]; +// Then there's a store into private var localint: +// CHECK: store i32 {{.+}}, i32* [[LOCALINT:%[^,]+]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] + localint = (int)j; +// CHECK: [[IV2:%.+]] = load i64, i64* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// CHECK-NEXT: [[ADD2:%.+]] = add nsw i64 [[IV2]], 1 +// CHECK-NEXT: store i64 [[ADD2]], i64* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// +// br label %{{[^,]+}}, !llvm.loop ![[WIDE1_LOOP_ID]] +// CHECK: [[WIDE1_END]] + } +// i,j are updated. +// CHECK: store i32 3, i32* [[I:%[^,]+]] +// CHECK: store i16 +// +// Here we expect store into original localint, not its privatized version. +// CHECK-NOT: store i32 {{.+}}, i32* [[LOCALINT]] + localint = (int)j; +// CHECK: ret void +} + +// TERM_DEBUG-LABEL: bar +int bar() {return 0;}; + +// TERM_DEBUG-LABEL: parallel_simd +void parallel_simd(float *a) { +#pragma omp parallel +#pragma omp for simd + // TERM_DEBUG-NOT: __kmpc_global_thread_num + // TERM_DEBUG: invoke i32 {{.*}}bar{{.*}}() + // TERM_DEBUG: unwind label %[[TERM_LPAD:.+]], + // TERM_DEBUG-NOT: __kmpc_global_thread_num + // TERM_DEBUG: [[TERM_LPAD]] + // TERM_DEBUG: call void @__clang_call_terminate + // TERM_DEBUG: unreachable + for (unsigned i = 131071; i <= 2147483647; i += 127) + a[i] += bar(); +} +// TERM_DEBUG: !{{[0-9]+}} = !DILocation(line: [[@LINE-11]], +#endif // HEADER + diff --git a/test/OpenMP/parallel_for_codegen.cpp b/test/OpenMP/parallel_for_codegen.cpp index 43bf83269655..6262e761e0da 100644 --- a/test/OpenMP/parallel_for_codegen.cpp +++ b/test/OpenMP/parallel_for_codegen.cpp @@ -2,6 +2,7 @@ // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG +// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -O1 -fopenmp -emit-llvm %s -o - | FileCheck %s --check-prefix=CLEANUP // // expected-no-diagnostics #ifndef HEADER @@ -376,6 +377,7 @@ void runtime(float *a, float *b, float *c, float *d) { int foo() {return 0;}; // TERM_DEBUG-LABEL: parallel_for +// CLEANUP: parallel_for void parallel_for(float *a) { #pragma omp parallel for schedule(static, 5) // TERM_DEBUG-NOT: __kmpc_global_thread_num @@ -388,13 +390,17 @@ void parallel_for(float *a) { // TERM_DEBUG: [[TERM_LPAD]] // TERM_DEBUG: call void @__clang_call_terminate // TERM_DEBUG: unreachable + // CLEANUP-NOT: __kmpc_global_thread_num + // CLEANUP: call void @__kmpc_for_static_init_4u({{.+}}) + // CLEANUP: call void @__kmpc_for_static_fini({{.+}}) + // CLEANUP: call {{.+}} @__kmpc_cancel_barrier({{.+}}) for (unsigned i = 131071; i <= 2147483647; i += 127) a[i] += foo(); } // Check source line corresponds to "#pragma omp parallel for schedule(static, 5)" above: // TERM_DEBUG-DAG: [[DBG_LOC_START]] = !DILocation(line: [[@LINE-4]], -// TERM_DEBUG-DAG: [[DBG_LOC_END]] = !DILocation(line: [[@LINE-16]], -// TERM_DEBUG-DAG: [[DBG_LOC_CANCEL]] = !DILocation(line: [[@LINE-17]], +// TERM_DEBUG-DAG: [[DBG_LOC_END]] = !DILocation(line: [[@LINE-20]], +// TERM_DEBUG-DAG: [[DBG_LOC_CANCEL]] = !DILocation(line: [[@LINE-21]], #endif // HEADER diff --git a/test/OpenMP/parallel_for_simd_codegen.cpp b/test/OpenMP/parallel_for_simd_codegen.cpp new file mode 100644 index 000000000000..3490b8fb1688 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_codegen.cpp @@ -0,0 +1,696 @@ +// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG +// +// expected-no-diagnostics +#ifndef HEADER +#define HEADER + +long long get_val() { return 0; } +double *g_ptr; + +// CHECK-LABEL: define {{.*void}} @{{.*}}simple{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}}) +void simple(float *a, float *b, float *c, float *d) { +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( +// CHECK: [[K0:%.+]] = call {{.*}}i64 @{{.*}}get_val +// CHECK-NEXT: store i64 [[K0]], i64* [[K_VAR:%[^,]+]] +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( +// CHECK: store i32 12, i32* [[LIN_VAR:%[^,]+]] +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( +// CHECK: store i32 -1, i32* [[A:%.+]], +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( +// CHECK: store i32 -1, i32* [[R:%[^,]+]], +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( + #pragma omp parallel for simd +// CHECK: call void @__kmpc_for_static_init_4(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i32* [[LB:%[^,]+]], i32* [[UB:%[^,]+]], i32* [[STRIDE:%[^,]+]], i32 1, i32 1) +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: [[CMP:%.+]] = icmp sgt i32 [[UB_VAL]], 5 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i32 [ 5, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i32 [[UP]], i32* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i32, i32* [[LB]], +// CHECK: store i32 [[LB_VAL]], i32* [[OMP_IV:%[^,]+]], + +// CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP]], label %[[SIMPLE_LOOP1_BODY:.+]], label %[[SIMPLE_LOOP1_END:[^,]+]] + for (int i = 3; i < 32; i += 5) { +// CHECK: [[SIMPLE_LOOP1_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV1_1:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// CHECK: [[CALC_I_1:%.+]] = mul nsw i32 [[IV1_1]], 5 +// CHECK-NEXT: [[CALC_I_2:%.+]] = add nsw i32 3, [[CALC_I_1]] +// CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// ... loop body ... +// End of body: store into a[i]: +// CHECK: store float [[RESULT:%.+]], float* {{%.+}}{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] + a[i] = b[i] * c[i] * d[i]; +// CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1 +// CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// br label %{{.+}}, !llvm.loop !{{.+}} + } +// CHECK: [[SIMPLE_LOOP1_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + + long long k = get_val(); + + #pragma omp parallel for simd linear(k : 3) schedule(dynamic) +// CHECK: [[K0LOAD:%.+]] = load i64, i64* [[K_VAR:%[^,]+]] +// CHECK-NEXT: store i64 [[K0LOAD]], i64* [[LIN0:%[^,]+]] + +// CHECK: call void @__kmpc_dispatch_init_4(%ident_t* {{.+}}, i32 %{{.+}}, i32 35, i32 0, i32 8, i32 1, i32 1) +// CHECK: [[NEXT:%.+]] = call i32 @__kmpc_dispatch_next_4(%ident_t* {{.+}}, i32 %{{.+}}, i32* %{{.+}}, i32* [[LB:%.+]], i32* [[UB:%.+]], i32* %{{.+}}) +// CHECK: [[COND:%.+]] = icmp ne i32 [[NEXT]], 0 +// CHECK: br i1 [[COND]], label %[[CONT:.+]], label %[[END:.+]] +// CHECK: [[CONT]] +// CHECK: [[LB_VAL:%.+]] = load i32, i32* [[LB]], +// CHECK: store i32 [[LB_VAL]], i32* [[OMP_IV2:%[^,]+]], + +// CHECK: [[IV2:%.+]] = load i32, i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// CHECK-NEXT: [[CMP2:%.+]] = icmp sle i32 [[IV2]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP2]], label %[[SIMPLE_LOOP2_BODY:.+]], label %[[SIMPLE_LOOP2_END:[^,]+]] + for (int i = 10; i > 1; i--) { +// CHECK: [[SIMPLE_LOOP2_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV2_0:%.+]] = load i32, i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// FIXME: It is interesting, why the following "mul 1" was not constant folded? +// CHECK-NEXT: [[IV2_1:%.+]] = mul nsw i32 [[IV2_0]], 1 +// CHECK-NEXT: [[LC_I_1:%.+]] = sub nsw i32 10, [[IV2_1]] +// CHECK-NEXT: store i32 [[LC_I_1]], i32* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// +// CHECK-NEXT: [[LIN0_1:%.+]] = load i64, i64* [[LIN0]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// CHECK-NEXT: [[IV2_2:%.+]] = load i32, i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// CHECK-NEXT: [[LIN_MUL1:%.+]] = mul nsw i32 [[IV2_2]], 3 +// CHECK-NEXT: [[LIN_EXT1:%.+]] = sext i32 [[LIN_MUL1]] to i64 +// CHECK-NEXT: [[LIN_ADD1:%.+]] = add nsw i64 [[LIN0_1]], [[LIN_EXT1]] +// Update of the privatized version of linear variable! +// CHECK-NEXT: store i64 [[LIN_ADD1]], i64* [[K_PRIVATIZED:%[^,]+]] + a[k]++; + k = k + 3; +// CHECK: [[IV2_2:%.+]] = load i32, i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// CHECK-NEXT: [[ADD2_2:%.+]] = add nsw i32 [[IV2_2]], 1 +// CHECK-NEXT: store i32 [[ADD2_2]], i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// br label {{.+}}, !llvm.loop ![[SIMPLE_LOOP2_ID]] + } +// CHECK: [[SIMPLE_LOOP2_END]] +// +// Update linear vars after loop, as the loop was operating on a private version. +// CHECK: [[LIN0_2:%.+]] = load i64, i64* [[LIN0]] +// CHECK-NEXT: [[LIN_ADD2:%.+]] = add nsw i64 [[LIN0_2]], 27 +// CHECK-NEXT: store i64 [[LIN_ADD2]], i64* %{{.+}} +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + + int lin = 12; + #pragma omp parallel for simd linear(lin : get_val()), linear(g_ptr) + +// Init linear private var. +// CHECK: [[LIN_VAR:%.+]] = load i32*, i32** % +// CHECK-NEXT: [[LIN_LOAD:%.+]] = load i32, i32* [[LIN_VAR]] +// CHECK-NEXT: store i32 [[LIN_LOAD]], i32* [[LIN_START:%[^,]+]] +// Remember linear step. +// CHECK: [[CALL_VAL:%.+]] = invoke +// CHECK: store i64 [[CALL_VAL]], i64* [[LIN_STEP:%[^,]+]] + +// CHECK: [[GLIN_VAR:%.+]] = load double**, double*** % +// CHECK-NEXT: [[GLIN_LOAD:%.+]] = load double*, double** [[GLIN_VAR]] +// CHECK-NEXT: store double* [[GLIN_LOAD]], double** [[GLIN_START:%[^,]+]] + +// CHECK: call void @__kmpc_for_static_init_8u(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i64* [[LB:%[^,]+]], i64* [[UB:%[^,]+]], i64* [[STRIDE:%[^,]+]], i64 1, i64 1) +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: [[CMP:%.+]] = icmp ugt i64 [[UB_VAL]], 3 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i64 [ 3, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i64 [[UP]], i64* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i64, i64* [[LB]], +// CHECK: store i64 [[LB_VAL]], i64* [[OMP_IV3:%[^,]+]], + +// CHECK: [[IV3:%.+]] = load i64, i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NEXT: [[CMP3:%.+]] = icmp ule i64 [[IV3]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP3]], label %[[SIMPLE_LOOP3_BODY:.+]], label %[[SIMPLE_LOOP3_END:[^,]+]] + for (unsigned long long it = 2000; it >= 600; it-=400) { +// CHECK: [[SIMPLE_LOOP3_BODY]] +// Start of body: calculate it from IV: +// CHECK: [[IV3_0:%.+]] = load i64, i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul i64 [[IV3_0]], 400 +// CHECK-NEXT: [[LC_IT_2:%.+]] = sub i64 2000, [[LC_IT_1]] +// CHECK-NEXT: store i64 [[LC_IT_2]], i64* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// +// Linear start and step are used to calculate current value of the linear variable. +// CHECK: [[LINSTART:.+]] = load i32, i32* [[LIN_START]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK: [[LINSTEP:.+]] = load i64, i64* [[LIN_STEP]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NOT: store i32 {{.+}}, i32* [[LIN_VAR]],{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK: [[GLINSTART:.+]] = load double*, double** [[GLIN_START]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NEXT: [[IV3_1:%.+]] = load i64, i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NEXT: [[MUL:%.+]] = mul i64 [[IV3_1]], 1 +// CHECK: [[GEP:%.+]] = getelementptr{{.*}}[[GLINSTART]] +// CHECK-NEXT: store double* [[GEP]], double** [[G_PTR_CUR:%[^,]+]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] + *g_ptr++ = 0.0; +// CHECK: [[GEP_VAL:%.+]] = load double{{.*}}[[G_PTR_CUR]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK: store double{{.*}}[[GEP_VAL]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] + a[it + lin]++; +// CHECK: [[FLT_INC:%.+]] = fadd float +// CHECK-NEXT: store float [[FLT_INC]],{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK: [[IV3_2:%.+]] = load i64, i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NEXT: [[ADD3_2:%.+]] = add i64 [[IV3_2]], 1 +// CHECK-NEXT: store i64 [[ADD3_2]], i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] + } +// CHECK: [[SIMPLE_LOOP3_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// +// Linear start and step are used to calculate final value of the linear variables. +// CHECK: [[LIN_VAR:%.+]] = load i32*, i32** % +// CHECK: [[LINSTART:.+]] = load i32, i32* [[LIN_START]] +// CHECK: [[LINSTEP:.+]] = load i64, i64* [[LIN_STEP]] +// CHECK: store i32 {{.+}}, i32* [[LIN_VAR]], +// CHECK: [[GLIN_VAR:%.+]] = load double**, double*** % +// CHECK: [[GLINSTART:.+]] = load double*, double** [[GLIN_START]] +// CHECK: store double* {{.*}}[[GLIN_VAR]] +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + + #pragma omp parallel for simd +// CHECK: call void @__kmpc_for_static_init_4(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i32* [[LB:%[^,]+]], i32* [[UB:%[^,]+]], i32* [[STRIDE:%[^,]+]], i32 1, i32 1) +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: [[CMP:%.+]] = icmp sgt i32 [[UB_VAL]], 3 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i32 [ 3, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i32 [[UP]], i32* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i32, i32* [[LB]], +// CHECK: store i32 [[LB_VAL]], i32* [[OMP_IV4:%[^,]+]], + +// CHECK: [[IV4:%.+]] = load i32, i32* [[OMP_IV4]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] +// CHECK-NEXT: [[CMP4:%.+]] = icmp sle i32 [[IV4]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP4]], label %[[SIMPLE_LOOP4_BODY:.+]], label %[[SIMPLE_LOOP4_END:[^,]+]] + for (short it = 6; it <= 20; it-=-4) { +// CHECK: [[SIMPLE_LOOP4_BODY]] +// Start of body: calculate it from IV: +// CHECK: [[IV4_0:%.+]] = load i32, i32* [[OMP_IV4]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul nsw i32 [[IV4_0]], 4 +// CHECK-NEXT: [[LC_IT_2:%.+]] = add nsw i32 6, [[LC_IT_1]] +// CHECK-NEXT: [[LC_IT_3:%.+]] = trunc i32 [[LC_IT_2]] to i16 +// CHECK-NEXT: store i16 [[LC_IT_3]], i16* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] + +// CHECK: [[IV4_2:%.+]] = load i32, i32* [[OMP_IV4]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] +// CHECK-NEXT: [[ADD4_2:%.+]] = add nsw i32 [[IV4_2]], 1 +// CHECK-NEXT: store i32 [[ADD4_2]], i32* [[OMP_IV4]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] + } +// CHECK: [[SIMPLE_LOOP4_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + + #pragma omp parallel for simd +// CHECK: call void @__kmpc_for_static_init_4(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i32* [[LB:%[^,]+]], i32* [[UB:%[^,]+]], i32* [[STRIDE:%[^,]+]], i32 1, i32 1) +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: [[CMP:%.+]] = icmp sgt i32 [[UB_VAL]], 25 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i32 [ 25, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i32 [[UP]], i32* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i32, i32* [[LB]], +// CHECK: store i32 [[LB_VAL]], i32* [[OMP_IV5:%[^,]+]], + +// CHECK: [[IV5:%.+]] = load i32, i32* [[OMP_IV5]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] +// CHECK-NEXT: [[CMP5:%.+]] = icmp sle i32 [[IV5]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP5]], label %[[SIMPLE_LOOP5_BODY:.+]], label %[[SIMPLE_LOOP5_END:[^,]+]] + for (unsigned char it = 'z'; it >= 'a'; it+=-1) { +// CHECK: [[SIMPLE_LOOP5_BODY]] +// Start of body: calculate it from IV: +// CHECK: [[IV5_0:%.+]] = load i32, i32* [[OMP_IV5]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] +// CHECK-NEXT: [[IV5_1:%.+]] = mul nsw i32 [[IV5_0]], 1 +// CHECK-NEXT: [[LC_IT_1:%.+]] = sub nsw i32 122, [[IV5_1]] +// CHECK-NEXT: [[LC_IT_2:%.+]] = trunc i32 [[LC_IT_1]] to i8 +// CHECK-NEXT: store i8 [[LC_IT_2]], i8* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] + +// CHECK: [[IV5_2:%.+]] = load i32, i32* [[OMP_IV5]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] +// CHECK-NEXT: [[ADD5_2:%.+]] = add nsw i32 [[IV5_2]], 1 +// CHECK-NEXT: store i32 [[ADD5_2]], i32* [[OMP_IV5]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] + } +// CHECK: [[SIMPLE_LOOP5_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + +// CHECK-NOT: mul i32 %{{.+}}, 10 + #pragma omp parallel for simd + for (unsigned i=100; i<10; i+=10) { + } + + int A; + { + A = -1; + #pragma omp parallel for simd lastprivate(A) +// CHECK: call void @__kmpc_for_static_init_8(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i64* [[LB:%[^,]+]], i64* [[UB:%[^,]+]], i64* [[STRIDE:%[^,]+]], i64 1, i64 1) +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: [[CMP:%.+]] = icmp sgt i64 [[UB_VAL]], 6 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i64 [ 6, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i64 [[UP]], i64* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i64, i64* [[LB]], +// CHECK: store i64 [[LB_VAL]], i64* [[OMP_IV7:%[^,]+]], + +// CHECK: br label %[[SIMD_LOOP7_COND:[^,]+]] +// CHECK: [[SIMD_LOOP7_COND]] +// CHECK-NEXT: [[IV7:%.+]] = load i64, i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID:[0-9]+]] +// CHECK-NEXT: [[UB_VAL:%.+]] = load i64, i64* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[CMP7:%.+]] = icmp sle i64 [[IV7]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP7]], label %[[SIMPLE_LOOP7_BODY:.+]], label %[[SIMPLE_LOOP7_END:[^,]+]] + for (long long i = -10; i < 10; i += 3) { +// CHECK: [[SIMPLE_LOOP7_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV7_0:%.+]] = load i64, i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul nsw i64 [[IV7_0]], 3 +// CHECK-NEXT: [[LC_IT_2:%.+]] = add nsw i64 -10, [[LC_IT_1]] +// CHECK-NEXT: store i64 [[LC_IT_2]], i64* [[LC:%[^,]+]],{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[LC_VAL:%.+]] = load i64, i64* [[LC]]{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[CONV:%.+]] = trunc i64 [[LC_VAL]] to i32 +// CHECK-NEXT: store i32 [[CONV]], i32* [[A_PRIV:%[^,]+]],{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] + A = i; +// CHECK: [[IV7_2:%.+]] = load i64, i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[ADD7_2:%.+]] = add nsw i64 [[IV7_2]], 1 +// CHECK-NEXT: store i64 [[ADD7_2]], i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] + } +// CHECK: [[SIMPLE_LOOP7_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: load i32, i32* +// CHECK: icmp ne i32 %{{.+}}, 0 +// CHECK: br i1 %{{.+}}, label +// CHECK: [[A_PRIV_VAL:%.+]] = load i32, i32* [[A_PRIV]], +// CHECK-NEXT: store i32 [[A_PRIV_VAL]], i32* %{{.+}}, +// CHECK-NEXT: br label +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + } + int R; + { + R = -1; +// CHECK: store i32 1, i32* [[R_PRIV:%[^,]+]], + #pragma omp parallel for simd reduction(*:R) +// CHECK: call void @__kmpc_for_static_init_8(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i64* [[LB:%[^,]+]], i64* [[UB:%[^,]+]], i64* [[STRIDE:%[^,]+]], i64 1, i64 1) +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: [[CMP:%.+]] = icmp sgt i64 [[UB_VAL]], 6 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i64 [ 6, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i64 [[UP]], i64* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i64, i64* [[LB]], +// CHECK: store i64 [[LB_VAL]], i64* [[OMP_IV8:%[^,]+]], + +// CHECK: br label %[[SIMD_LOOP8_COND:[^,]+]] +// CHECK: [[SIMD_LOOP8_COND]] +// CHECK-NEXT: [[IV8:%.+]] = load i64, i64* [[OMP_IV8]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID:[0-9]+]] +// CHECK-NEXT: [[UB_VAL:%.+]] = load i64, i64* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK-NEXT: [[CMP8:%.+]] = icmp sle i64 [[IV8]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP8]], label %[[SIMPLE_LOOP8_BODY:.+]], label %[[SIMPLE_LOOP8_END:[^,]+]] + for (long long i = -10; i < 10; i += 3) { +// CHECK: [[SIMPLE_LOOP8_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV8_0:%.+]] = load i64, i64* [[OMP_IV8]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul nsw i64 [[IV8_0]], 3 +// CHECK-NEXT: [[LC_IT_2:%.+]] = add nsw i64 -10, [[LC_IT_1]] +// CHECK-NEXT: store i64 [[LC_IT_2]], i64* [[LC:%[^,]+]],{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK-NEXT: [[LC_VAL:%.+]] = load i64, i64* [[LC]]{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK: store i32 %{{.+}}, i32* [[R_PRIV]],{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] + R *= i; +// CHECK: [[IV8_2:%.+]] = load i64, i64* [[OMP_IV8]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK-NEXT: [[ADD8_2:%.+]] = add nsw i64 [[IV8_2]], 1 +// CHECK-NEXT: store i64 [[ADD8_2]], i64* [[OMP_IV8]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] + } +// CHECK: [[SIMPLE_LOOP8_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call i32 @__kmpc_reduce_nowait( +// CHECK: [[R_PRIV_VAL:%.+]] = load i32, i32* [[R_PRIV]], +// CHECK: [[RED:%.+]] = mul nsw i32 %{{.+}}, [[R_PRIV_VAL]] +// CHECK-NEXT: store i32 [[RED]], i32* %{{.+}}, +// CHECK-NEXT: call void @__kmpc_end_reduce_nowait( +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) + } +} + +template <class T, unsigned K> T tfoo(T a) { return a + K; } + +template <typename T, unsigned N> +int templ1(T a, T *z) { + #pragma omp parallel for simd collapse(N) + for (int i = 0; i < N * 2; i++) { + for (long long j = 0; j < (N + N + N + N); j += 2) { + z[i + j] = a + tfoo<T, N>(i + j); + } + } + return 0; +} + +// Instatiation templ1<float,2> +// CHECK-LABEL: define {{.*i32}} @{{.*}}templ1{{.*}}(float {{.+}}, float* {{.+}}) +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( +void inst_templ1() { + float a; + float z[100]; + templ1<float,2> (a, z); +} + + +typedef int MyIdx; + +class IterDouble { + double *Ptr; +public: + IterDouble operator++ () const { + IterDouble n; + n.Ptr = Ptr + 1; + return n; + } + bool operator < (const IterDouble &that) const { + return Ptr < that.Ptr; + } + double & operator *() const { + return *Ptr; + } + MyIdx operator - (const IterDouble &that) const { + return (MyIdx) (Ptr - that.Ptr); + } + IterDouble operator + (int Delta) { + IterDouble re; + re.Ptr = Ptr + Delta; + return re; + } + + ///~IterDouble() {} +}; + +// CHECK-LABEL: define {{.*void}} @{{.*}}iter_simple{{.*}} +void iter_simple(IterDouble ia, IterDouble ib, IterDouble ic) { +// +// Calculate number of iterations before the loop body. +// CHECK: [[DIFF1:%.+]] = invoke {{.*}}i32 @{{.*}}IterDouble{{.*}} +// CHECK: [[DIFF2:%.+]] = sub nsw i32 [[DIFF1]], 1 +// CHECK-NEXT: [[DIFF3:%.+]] = add nsw i32 [[DIFF2]], 1 +// CHECK-NEXT: [[DIFF4:%.+]] = sdiv i32 [[DIFF3]], 1 +// CHECK-NEXT: [[DIFF5:%.+]] = sub nsw i32 [[DIFF4]], 1 +// CHECK-NEXT: store i32 [[DIFF5]], i32* [[OMP_LAST_IT:%[^,]+]]{{.+}} + #pragma omp parallel for simd + +// CHECK: call void @__kmpc_for_static_init_4(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i32* [[LB:%[^,]+]], i32* [[UB:%[^,]+]], i32* [[STRIDE:%[^,]+]], i32 1, i32 1) +// CHECK-DAG: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK-DAG: [[OMP_LAST_IT_VAL:%.+]] = load i32, i32* [[OMP_LAST_IT]], +// CHECK: [[CMP:%.+]] = icmp sgt i32 [[UB_VAL]], [[OMP_LAST_IT_VAL]] +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: [[OMP_LAST_IT_VAL:%.+]] = load i32, i32* [[OMP_LAST_IT]], +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i32 [ [[OMP_LAST_IT_VAL]], %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i32 [[UP]], i32* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i32, i32* [[LB]], +// CHECK: store i32 [[LB_VAL]], i32* [[IT_OMP_IV:%[^,]+]], + +// CHECK: [[IV:%.+]] = load i32, i32* [[IT_OMP_IV]]{{.+}} !llvm.mem.parallel_loop_access ![[ITER_LOOP_ID:[0-9]+]] +// CHECK-NEXT: [[UB_VAL:%.+]] = load i32, i32* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP]], label %[[IT_BODY:[^,]+]], label %[[IT_END:[^,]+]] + for (IterDouble i = ia; i < ib; ++i) { +// CHECK: [[IT_BODY]] +// Start of body: calculate i from index: +// CHECK: [[IV1:%.+]] = load i32, i32* [[IT_OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// Call of operator+ (i, IV). +// CHECK: {{%.+}} = invoke {{.+}} @{{.*}}IterDouble{{.*}} +// ... loop body ... + *i = *ic * 0.5; +// Float multiply and save result. +// CHECK: [[MULR:%.+]] = fmul double {{%.+}}, 5.000000e-01 +// CHECK-NEXT: invoke {{.+}} @{{.*}}IterDouble{{.*}} +// CHECK: store double [[MULR:%.+]], double* [[RESULT_ADDR:%.+]], !llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] + ++ic; +// +// CHECK: [[IV2:%.+]] = load i32, i32* [[IT_OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// CHECK-NEXT: [[ADD2:%.+]] = add nsw i32 [[IV2]], 1 +// CHECK-NEXT: store i32 [[ADD2]], i32* [[IT_OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// br label %{{.*}}, !llvm.loop ![[ITER_LOOP_ID]] + } +// CHECK: [[IT_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: ret void +} + + +// CHECK-LABEL: define {{.*void}} @{{.*}}collapsed{{.*}} +void collapsed(float *a, float *b, float *c, float *d) { + int i; // outer loop counter + unsigned j; // middle loop couter, leads to unsigned icmp in loop header. + // k declared in the loop init below + short l; // inner loop counter +// CHECK: call void @__kmpc_for_static_init_4u(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i32* [[LB:%[^,]+]], i32* [[UB:%[^,]+]], i32* [[STRIDE:%[^,]+]], i32 1, i32 1) +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: [[CMP:%.+]] = icmp ugt i32 [[UB_VAL]], 119 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i32 [ 119, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i32 [[UP]], i32* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i32, i32* [[LB]], +// CHECK: store i32 [[LB_VAL]], i32* [[OMP_IV:%[^,]+]], +// + #pragma omp parallel for simd collapse(4) + +// CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[CMP:%.+]] = icmp ule i32 [[IV]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP]], label %[[COLL1_BODY:[^,]+]], label %[[COLL1_END:[^,]+]] + for (i = 1; i < 3; i++) // 2 iterations + for (j = 2u; j < 5u; j++) //3 iterations + for (int k = 3; k <= 6; k++) // 4 iterations + for (l = 4; l < 9; ++l) // 5 iterations + { +// CHECK: [[COLL1_BODY]] +// Start of body: calculate i from index: +// CHECK: [[IV1:%.+]] = load i32, i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// Calculation of the loop counters values. +// CHECK: [[CALC_I_1:%.+]] = udiv i32 [[IV1]], 60 +// CHECK-NEXT: [[CALC_I_1_MUL1:%.+]] = mul i32 [[CALC_I_1]], 1 +// CHECK-NEXT: [[CALC_I_2:%.+]] = add i32 1, [[CALC_I_1_MUL1]] +// CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]] +// CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[CALC_J_1:%.+]] = udiv i32 [[IV1_2]], 20 +// CHECK-NEXT: [[CALC_J_2:%.+]] = urem i32 [[CALC_J_1]], 3 +// CHECK-NEXT: [[CALC_J_2_MUL1:%.+]] = mul i32 [[CALC_J_2]], 1 +// CHECK-NEXT: [[CALC_J_3:%.+]] = add i32 2, [[CALC_J_2_MUL1]] +// CHECK-NEXT: store i32 [[CALC_J_3]], i32* [[LC_J:.+]] +// CHECK: [[IV1_3:%.+]] = load i32, i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[CALC_K_1:%.+]] = udiv i32 [[IV1_3]], 5 +// CHECK-NEXT: [[CALC_K_2:%.+]] = urem i32 [[CALC_K_1]], 4 +// CHECK-NEXT: [[CALC_K_2_MUL1:%.+]] = mul i32 [[CALC_K_2]], 1 +// CHECK-NEXT: [[CALC_K_3:%.+]] = add i32 3, [[CALC_K_2_MUL1]] +// CHECK-NEXT: store i32 [[CALC_K_3]], i32* [[LC_K:.+]] +// CHECK: [[IV1_4:%.+]] = load i32, i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[CALC_L_1:%.+]] = urem i32 [[IV1_4]], 5 +// CHECK-NEXT: [[CALC_L_1_MUL1:%.+]] = mul i32 [[CALC_L_1]], 1 +// CHECK-NEXT: [[CALC_L_2:%.+]] = add i32 4, [[CALC_L_1_MUL1]] +// CHECK-NEXT: [[CALC_L_3:%.+]] = trunc i32 [[CALC_L_2]] to i16 +// CHECK-NEXT: store i16 [[CALC_L_3]], i16* [[LC_L:.+]] +// ... loop body ... +// End of body: store into a[i]: +// CHECK: store float [[RESULT:%.+]], float* [[RESULT_ADDR:%.+]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] + float res = b[j] * c[k]; + a[i] = res * d[l]; +// CHECK: [[IV2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[ADD2:%.+]] = add i32 [[IV2]], 1 +// CHECK-NEXT: store i32 [[ADD2]], i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// br label %{{[^,]+}}, !llvm.loop ![[COLL1_LOOP_ID]] +// CHECK: [[COLL1_END]] + } +// i,j,l are updated; k is not updated. +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: store i32 3, i32* [[I:%[^,]+]] +// CHECK: store i32 5, i32* [[I:%[^,]+]] +// CHECK: store i16 9, i16* [[I:%[^,]+]] +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: ret void +} + +extern char foo(); +extern double globalfloat; + +// CHECK-LABEL: define {{.*void}} @{{.*}}widened{{.*}} +void widened(float *a, float *b, float *c, float *d) { + int i; // outer loop counter + short j; // inner loop counter + globalfloat = 1.0; + int localint = 1; +// CHECK: store double {{.+}}, double* [[GLOBALFLOAT:@.+]] +// Counter is widened to 64 bits. +// CHECK: [[MUL:%.+]] = mul nsw i64 2, %{{.+}} +// CHECK-NEXT: [[SUB:%.+]] = sub nsw i64 [[MUL]], 1 +// CHECK-NEXT: store i64 [[SUB]], i64* [[OMP_LAST_IT:%[^,]+]], +// CHECK: call void @__kmpc_for_static_init_8(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i64* [[LB:%[^,]+]], i64* [[UB:%[^,]+]], i64* [[STRIDE:%[^,]+]], i64 1, i64 1) +// CHECK-DAG: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK-DAG: [[OMP_LAST_IT_VAL:%.+]] = load i64, i64* [[OMP_LAST_IT]], +// CHECK: [[CMP:%.+]] = icmp sgt i64 [[UB_VAL]], [[OMP_LAST_IT_VAL]] +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: [[OMP_LAST_IT_VAL:%.+]] = load i64, i64* [[OMP_LAST_IT]], +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i64 [ [[OMP_LAST_IT_VAL]], %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i64 [[UP]], i64* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i64, i64* [[LB]], +// CHECK: store i64 [[LB_VAL]], i64* [[OMP_IV:%[^,]+]], +// + #pragma omp parallel for simd collapse(2) private(globalfloat, localint) + +// CHECK: [[IV:%.+]] = load i64, i64* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID:[0-9]+]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// CHECK-NEXT: [[CMP:%.+]] = icmp sle i64 [[IV]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP]], label %[[WIDE1_BODY:[^,]+]], label %[[WIDE1_END:[^,]+]] + for (i = 1; i < 3; i++) // 2 iterations + for (j = 0; j < foo(); j++) // foo() iterations + { +// CHECK: [[WIDE1_BODY]] +// Start of body: calculate i from index: +// CHECK: [[IV1:%.+]] = load i64, i64* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// Calculation of the loop counters values... +// CHECK: store i32 {{[^,]+}}, i32* [[LC_I:.+]] +// CHECK: [[IV1_2:%.+]] = load i64, i64* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// CHECK: store i16 {{[^,]+}}, i16* [[LC_J:.+]] +// ... loop body ... +// +// Here we expect store into private double var, not global +// CHECK-NOT: store double {{.+}}, double* [[GLOBALFLOAT]] + globalfloat = (float)j/i; + float res = b[j] * c[j]; +// Store into a[i]: +// CHECK: store float [[RESULT:%.+]], float* [[RESULT_ADDR:%.+]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] + a[i] = res * d[i]; +// Then there's a store into private var localint: +// CHECK: store i32 {{.+}}, i32* [[LOCALINT:%[^,]+]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] + localint = (int)j; +// CHECK: [[IV2:%.+]] = load i64, i64* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// CHECK-NEXT: [[ADD2:%.+]] = add nsw i64 [[IV2]], 1 +// CHECK-NEXT: store i64 [[ADD2]], i64* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// +// br label %{{[^,]+}}, !llvm.loop ![[WIDE1_LOOP_ID]] +// CHECK: [[WIDE1_END]] + } +// i,j are updated. +// CHECK: store i32 3, i32* [[I:%[^,]+]] +// CHECK: store i16 +// +// Here we expect store into original localint, not its privatized version. +// CHECK-NOT: store i32 {{.+}}, i32* [[LOCALINT]] + localint = (int)j; +// CHECK: ret void +} + +// CHECK: call void @__kmpc_for_static_init_8(%ident_t* {{[^,]+}}, i32 %{{[^,]+}}, i32 34, i32* %{{[^,]+}}, i64* [[LB:%[^,]+]], i64* [[UB:%[^,]+]], i64* [[STRIDE:%[^,]+]], i64 1, i64 1) +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: [[CMP:%.+]] = icmp sgt i64 [[UB_VAL]], 15 +// CHECK: br i1 [[CMP]], label %[[TRUE:.+]], label %[[FALSE:[^,]+]] +// CHECK: [[TRUE]] +// CHECK: br label %[[SWITCH:[^,]+]] +// CHECK: [[FALSE]] +// CHECK: [[UB_VAL:%.+]] = load i64, i64* [[UB]], +// CHECK: br label %[[SWITCH]] +// CHECK: [[SWITCH]] +// CHECK: [[UP:%.+]] = phi i64 [ 15, %[[TRUE]] ], [ [[UB_VAL]], %[[FALSE]] ] +// CHECK: store i64 [[UP]], i64* [[UB]], +// CHECK: [[LB_VAL:%.+]] = load i64, i64* [[LB]], +// CHECK: store i64 [[LB_VAL]], i64* [[T1_OMP_IV:%[^,]+]], + +// ... +// CHECK: [[IV:%.+]] = load i64, i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID:[0-9]+]] +// CHECK-NEXT: [[UB_VAL:%.+]] = load i64, i64* [[UB]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: [[CMP1:%.+]] = icmp sle i64 [[IV]], [[UB_VAL]] +// CHECK-NEXT: br i1 [[CMP1]], label %[[T1_BODY:.+]], label %[[T1_END:[^,]+]] +// CHECK: [[T1_BODY]] +// Loop counters i and j updates: +// CHECK: [[IV1:%.+]] = load i64, i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: [[I_1:%.+]] = sdiv i64 [[IV1]], 4 +// CHECK-NEXT: [[I_1_MUL1:%.+]] = mul nsw i64 [[I_1]], 1 +// CHECK-NEXT: [[I_1_ADD0:%.+]] = add nsw i64 0, [[I_1_MUL1]] +// CHECK-NEXT: [[I_2:%.+]] = trunc i64 [[I_1_ADD0]] to i32 +// CHECK-NEXT: store i32 [[I_2]], i32* {{%.+}}{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK: [[IV2:%.+]] = load i64, i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: [[J_1:%.+]] = srem i64 [[IV2]], 4 +// CHECK-NEXT: [[J_2:%.+]] = mul nsw i64 [[J_1]], 2 +// CHECK-NEXT: [[J_2_ADD0:%.+]] = add nsw i64 0, [[J_2]] +// CHECK-NEXT: store i64 [[J_2_ADD0]], i64* {{%.+}}{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// simd.for.inc: +// CHECK: [[IV3:%.+]] = load i64, i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: [[INC:%.+]] = add nsw i64 [[IV3]], 1 +// CHECK-NEXT: store i64 [[INC]], i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: br label {{%.+}} +// CHECK: [[T1_END]] +// CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: ret void +// +// TERM_DEBUG-LABEL: bar +int bar() {return 0;}; + +// TERM_DEBUG-LABEL: parallel_simd +void parallel_simd(float *a) { +#pragma omp parallel for simd + // TERM_DEBUG-NOT: __kmpc_global_thread_num + // TERM_DEBUG: invoke i32 {{.*}}bar{{.*}}() + // TERM_DEBUG: unwind label %[[TERM_LPAD:.+]], + // TERM_DEBUG-NOT: __kmpc_global_thread_num + // TERM_DEBUG: [[TERM_LPAD]] + // TERM_DEBUG: call void @__clang_call_terminate + // TERM_DEBUG: unreachable + for (unsigned i = 131071; i <= 2147483647; i += 127) + a[i] += bar(); +} +// TERM_DEBUG: !{{[0-9]+}} = !DILocation(line: [[@LINE-11]], +#endif // HEADER + diff --git a/test/OpenMP/parallel_proc_bind_codegen.cpp b/test/OpenMP/parallel_proc_bind_codegen.cpp new file mode 100644 index 000000000000..2a8eaee127ce --- /dev/null +++ b/test/OpenMP/parallel_proc_bind_codegen.cpp @@ -0,0 +1,52 @@ +// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple %itanium_abi_triple -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple %itanium_abi_triple -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -x c++ -triple %itanium_abi_triple -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// expected-no-diagnostics +#ifndef HEADER +#define HEADER + +typedef __INTPTR_TYPE__ intptr_t; + +// CHECK-DAG: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* } +// CHECK-DAG: [[STR:@.+]] = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00" +// CHECK-DAG: [[DEF_LOC_2:@.+]] = private unnamed_addr constant [[IDENT_T_TY]] { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([23 x i8], [23 x i8]* [[STR]], i32 0, i32 0) } + +void foo(); + +struct S { + intptr_t a, b, c; + S(intptr_t a) : a(a) {} + operator char() { return a; } + ~S() {} +}; + +template <typename T> +T tmain() { +#pragma omp parallel proc_bind(master) + foo(); + return T(); +} + +int main() { +#pragma omp parallel proc_bind(spread) + foo(); +#pragma omp parallel proc_bind(close) + foo(); + return tmain<int>(); +} + +// CHECK-LABEL: @main +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEF_LOC_2]]) +// CHECK: call void @__kmpc_push_proc_bind([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 4) +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( +// CHECK: call void @__kmpc_push_proc_bind([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 3) +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( + +// CHECK-LABEL: @{{.+}}tmain +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEF_LOC_2]]) +// CHECK: call void @__kmpc_push_proc_bind([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 2) +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( +// CHECK: ret i32 0 +// CHECK-NEXT: } + +#endif diff --git a/test/OpenMP/simd_codegen.cpp b/test/OpenMP/simd_codegen.cpp index 586aaa5732f6..ae649d8359a8 100644 --- a/test/OpenMP/simd_codegen.cpp +++ b/test/OpenMP/simd_codegen.cpp @@ -41,9 +41,9 @@ void simple(float *a, float *b, float *c, float *d) { #pragma omp simd linear(k : 3) // CHECK: [[K0:%.+]] = call {{.*}}i64 @{{.*}}get_val // CHECK-NEXT: store i64 [[K0]], i64* [[K_VAR:%[^,]+]] +// CHECK: store i32 0, i32* [[OMP_IV2:%[^,]+]] // CHECK: [[K0LOAD:%.+]] = load i64, i64* [[K_VAR]] // CHECK-NEXT: store i64 [[K0LOAD]], i64* [[LIN0:%[^,]+]] -// CHECK: store i32 0, i32* [[OMP_IV2:%[^,]+]] // CHECK: [[IV2:%.+]] = load i32, i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID:[0-9]+]] // CHECK-NEXT: [[CMP2:%.+]] = icmp slt i32 [[IV2]], 9 @@ -84,17 +84,17 @@ void simple(float *a, float *b, float *c, float *d) { // Init linear private var. // CHECK: store i32 12, i32* [[LIN_VAR:%[^,]+]] -// CHECK: [[LIN_LOAD:%.+]] = load i32, i32* [[LIN_VAR]] -// CHECK-NEXT: store i32 [[LIN_LOAD]], i32* [[LIN_START:%[^,]+]] -// CHECK: [[GLIN_LOAD:%.+]] = load double*, double** [[GLIN_VAR:@[^,]+]] -// CHECK-NEXT: store double* [[GLIN_LOAD]], double** [[GLIN_START:%[^,]+]] - // CHECK: store i64 0, i64* [[OMP_IV3:%[^,]+]] +// CHECK: [[LIN_LOAD:%.+]] = load i32, i32* [[LIN_VAR]] +// CHECK-NEXT: store i32 [[LIN_LOAD]], i32* [[LIN_START:%[^,]+]] // Remember linear step. // CHECK: [[CALL_VAL:%.+]] = invoke // CHECK: store i64 [[CALL_VAL]], i64* [[LIN_STEP:%[^,]+]] +// CHECK: [[GLIN_LOAD:%.+]] = load double*, double** [[GLIN_VAR:@[^,]+]] +// CHECK-NEXT: store double* [[GLIN_LOAD]], double** [[GLIN_START:%[^,]+]] + // CHECK: [[IV3:%.+]] = load i64, i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID:[0-9]+]] // CHECK-NEXT: [[CMP3:%.+]] = icmp ult i64 [[IV3]], 4 // CHECK-NEXT: br i1 [[CMP3]], label %[[SIMPLE_LOOP3_BODY:.+]], label %[[SIMPLE_LOOP3_END:[^,]+]] @@ -182,15 +182,14 @@ void simple(float *a, float *b, float *c, float *d) { } int A; + // CHECK: store i32 -1, i32* [[A:%.+]], + A = -1; #pragma omp simd lastprivate(A) -// Clause 'lastprivate' implementation is not completed yet. -// Test checks that one iteration is separated in presence of lastprivate. -// // CHECK: store i64 0, i64* [[OMP_IV7:%[^,]+]] // CHECK: br label %[[SIMD_LOOP7_COND:[^,]+]] // CHECK: [[SIMD_LOOP7_COND]] // CHECK-NEXT: [[IV7:%.+]] = load i64, i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID:[0-9]+]] -// CHECK-NEXT: [[CMP7:%.+]] = icmp slt i64 [[IV7]], 6 +// CHECK-NEXT: [[CMP7:%.+]] = icmp slt i64 [[IV7]], 7 // CHECK-NEXT: br i1 [[CMP7]], label %[[SIMPLE_LOOP7_BODY:.+]], label %[[SIMPLE_LOOP7_END:[^,]+]] for (long long i = -10; i < 10; i += 3) { // CHECK: [[SIMPLE_LOOP7_BODY]] @@ -198,23 +197,49 @@ void simple(float *a, float *b, float *c, float *d) { // CHECK: [[IV7_0:%.+]] = load i64, i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] // CHECK-NEXT: [[LC_IT_1:%.+]] = mul nsw i64 [[IV7_0]], 3 // CHECK-NEXT: [[LC_IT_2:%.+]] = add nsw i64 -10, [[LC_IT_1]] -// CHECK-NEXT: store i64 [[LC_IT_2]], i64* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: store i64 [[LC_IT_2]], i64* [[LC:%[^,]+]],{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[LC_VAL:%.+]] = load i64, i64* [[LC]]{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[CONV:%.+]] = trunc i64 [[LC_VAL]] to i32 +// CHECK-NEXT: store i32 [[CONV]], i32* [[A_PRIV:%[^,]+]],{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] A = i; // CHECK: [[IV7_2:%.+]] = load i64, i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] // CHECK-NEXT: [[ADD7_2:%.+]] = add nsw i64 [[IV7_2]], 1 // CHECK-NEXT: store i64 [[ADD7_2]], i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] } // CHECK: [[SIMPLE_LOOP7_END]] -// Separated last iteration. -// CHECK: [[IV7_4:%.+]] = load i64, i64* [[OMP_IV7]] -// CHECK-NEXT: [[LC_FIN_1:%.+]] = mul nsw i64 [[IV7_4]], 3 -// CHECK-NEXT: [[LC_FIN_2:%.+]] = add nsw i64 -10, [[LC_FIN_1]] -// CHECK-NEXT: store i64 [[LC_FIN_2]], i64* [[ADDR_I:%[^,]+]] -// CHECK: [[LOAD_I:%.+]] = load i64, i64* [[ADDR_I]] -// CHECK-NEXT: [[CONV_I:%.+]] = trunc i64 [[LOAD_I]] to i32 -// - -// CHECK: ret void +// CHECK-NEXT: [[A_PRIV_VAL:%.+]] = load i32, i32* [[A_PRIV]], +// CHECK-NEXT: store i32 [[A_PRIV_VAL]], i32* [[A]], + int R; + // CHECK: store i32 -1, i32* [[R:%[^,]+]], + R = -1; +// CHECK: store i64 0, i64* [[OMP_IV8:%[^,]+]], +// CHECK: store i32 1, i32* [[R_PRIV:%[^,]+]], + #pragma omp simd reduction(*:R) +// CHECK: br label %[[SIMD_LOOP8_COND:[^,]+]] +// CHECK: [[SIMD_LOOP8_COND]] +// CHECK-NEXT: [[IV8:%.+]] = load i64, i64* [[OMP_IV8]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID:[0-9]+]] +// CHECK-NEXT: [[CMP8:%.+]] = icmp slt i64 [[IV8]], 7 +// CHECK-NEXT: br i1 [[CMP8]], label %[[SIMPLE_LOOP8_BODY:.+]], label %[[SIMPLE_LOOP8_END:[^,]+]] + for (long long i = -10; i < 10; i += 3) { +// CHECK: [[SIMPLE_LOOP8_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV8_0:%.+]] = load i64, i64* [[OMP_IV8]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul nsw i64 [[IV8_0]], 3 +// CHECK-NEXT: [[LC_IT_2:%.+]] = add nsw i64 -10, [[LC_IT_1]] +// CHECK-NEXT: store i64 [[LC_IT_2]], i64* [[LC:%[^,]+]],{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK-NEXT: [[LC_VAL:%.+]] = load i64, i64* [[LC]]{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK: store i32 %{{.+}}, i32* [[R_PRIV]],{{.+}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] + R *= i; +// CHECK: [[IV8_2:%.+]] = load i64, i64* [[OMP_IV8]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] +// CHECK-NEXT: [[ADD8_2:%.+]] = add nsw i64 [[IV8_2]], 1 +// CHECK-NEXT: store i64 [[ADD8_2]], i64* [[OMP_IV8]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP8_ID]] + } +// CHECK: [[SIMPLE_LOOP8_END]] +// CHECK-DAG: [[R_VAL:%.+]] = load i32, i32* [[R]], +// CHECK-DAG: [[R_PRIV_VAL:%.+]] = load i32, i32* [[R_PRIV]], +// CHECK: [[RED:%.+]] = mul nsw i32 [[R_VAL]], [[R_PRIV_VAL]] +// CHECK-NEXT: store i32 [[RED]], i32* [[R]], +// CHECK-NEXT: ret void } template <class T, unsigned K> T tfoo(T a) { return a + K; } diff --git a/test/OpenMP/taskgroup_ast_print.cpp b/test/OpenMP/taskgroup_ast_print.cpp new file mode 100644 index 000000000000..683141e686ec --- /dev/null +++ b/test/OpenMP/taskgroup_ast_print.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s +// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +void foo() {} + +int main (int argc, char **argv) { + int b = argc, c, d, e, f, g; + static int a; +// CHECK: static int a; +#pragma omp taskgroup + a=2; +// CHECK-NEXT: #pragma omp taskgroup +// CHECK-NEXT: a = 2; +// CHECK-NEXT: ++a; + ++a; +#pragma omp taskgroup + foo(); +// CHECK-NEXT: #pragma omp taskgroup +// CHECK-NEXT: foo(); +// CHECK-NEXT: return 0; + return 0; +} + +#endif diff --git a/test/OpenMP/taskgroup_codegen.cpp b/test/OpenMP/taskgroup_codegen.cpp new file mode 100644 index 000000000000..a6aec1f5b8c7 --- /dev/null +++ b/test/OpenMP/taskgroup_codegen.cpp @@ -0,0 +1,56 @@ +// RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +// CHECK: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* } + +// CHECK: define void [[FOO:@.+]]() + +void foo() {} + +// CHECK-LABEL: @main +// TERM_DEBUG-LABEL: @main +int main() { +// CHECK: [[A_ADDR:%.+]] = alloca i8 + char a; + +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:@.+]]) +// CHECK: call void @__kmpc_taskgroup([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +// CHECK-NEXT: store i8 2, i8* [[A_ADDR]] +// CHECK-NEXT: call void @__kmpc_end_taskgroup([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +#pragma omp taskgroup + a = 2; +// CHECK: call void @__kmpc_taskgroup([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +// CHECK-NEXT: invoke void [[FOO]]() +// CHECK: call void @__kmpc_end_taskgroup([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +#pragma omp taskgroup + foo(); +// CHECK-NOT: call void @__kmpc_taskgroup +// CHECK-NOT: call void @__kmpc_end_taskgroup + return a; +} + +// CHECK-LABEL: parallel_taskgroup +// TERM_DEBUG-LABEL: parallel_taskgroup +void parallel_taskgroup() { +#pragma omp parallel +#pragma omp taskgroup + // TERM_DEBUG-NOT: __kmpc_global_thread_num + // TERM_DEBUG: call void @__kmpc_taskgroup({{.+}}), !dbg [[DBG_LOC_START:![0-9]+]] + // TERM_DEBUG: invoke void {{.*}}foo{{.*}}() + // TERM_DEBUG: unwind label %[[TERM_LPAD:.+]], + // TERM_DEBUG-NOT: __kmpc_global_thread_num + // TERM_DEBUG: call void @__kmpc_end_taskgroup({{.+}}), !dbg [[DBG_LOC_END:![0-9]+]] + // TERM_DEBUG: [[TERM_LPAD]] + // TERM_DEBUG: call void @__clang_call_terminate + // TERM_DEBUG: unreachable + foo(); +} +// TERM_DEBUG-DAG: [[DBG_LOC_START]] = !DILocation(line: [[@LINE-12]], +// TERM_DEBUG-DAG: [[DBG_LOC_END]] = !DILocation(line: [[@LINE-3]], +#endif diff --git a/test/OpenMP/taskgroup_messages.cpp b/test/OpenMP/taskgroup_messages.cpp new file mode 100644 index 000000000000..e893da4be3fa --- /dev/null +++ b/test/OpenMP/taskgroup_messages.cpp @@ -0,0 +1,67 @@ +// RUN: %clang_cc1 -verify -fopenmp %s + +int foo(); + +int main() { + #pragma omp taskgroup + ; + #pragma omp taskgroup unknown // expected-warning {{extra tokens at the end of '#pragma omp taskgroup' are ignored}} + foo(); + { + #pragma omp taskgroup + } // expected-error {{expected statement}} + #pragma omp taskgroup + #pragma omp taskgroup + for (int i = 0; i < 10; ++i) { + foo(); + #pragma omp parallel + #pragma omp for + for (int j = 0; j < 10; j++) { + foo(); + #pragma omp taskgroup + foo(); + } + } + #pragma omp taskgroup + #pragma omp taskgroup + for (int i = 0; i < 10; ++i) { + foo(); + #pragma omp parallel + #pragma omp for + for (int j = 0; j < 10; j++) { + #pragma omp taskgroup + foo(); + } + } + #pragma omp taskgroup + #pragma omp taskgroup + for (int i = 0; i < 10; ++i) { + foo(); + #pragma omp parallel + #pragma omp for + for (int j = 0; j < 10; j++) { + #pragma omp taskgroup + foo(); + } + } + + return 0; +} + +int foo() { + L1: + foo(); + #pragma omp taskgroup + { + foo(); + goto L1; // expected-error {{use of undeclared label 'L1'}} + } + goto L2; // expected-error {{use of undeclared label 'L2'}} + #pragma omp taskgroup + { + L2: + foo(); + } + + return 0; +} diff --git a/test/PCH/designated-init.c.h b/test/PCH/designated-init.c.h index 63b1f790ea44..18216279c2e9 100644 --- a/test/PCH/designated-init.c.h +++ b/test/PCH/designated-init.c.h @@ -40,3 +40,25 @@ static void *FooTable[256] = { }, } }; + +struct P1 { + struct Q1 { + char a[6]; + char b[6]; + } q; +}; + +struct P1 l1 = { + (struct Q1){ "foo", "bar" }, + .q.b = { "boo" }, + .q.b = { [1] = 'x' } +}; + +extern struct Q1 *foo(); +static struct P1 test_foo() { + struct P1 l = { *foo(), + .q.b = { "boo" }, + .q.b = { [1] = 'x' } + }; + return l; +} diff --git a/test/PCH/modified-module-dependency.m b/test/PCH/modified-module-dependency.m index 3db8f3d9c75b..39fddb039bad 100644 --- a/test/PCH/modified-module-dependency.m +++ b/test/PCH/modified-module-dependency.m @@ -5,13 +5,13 @@ // RUN: cp %S/modified-module-dependency.module.map %t-dir/module.map // Precompile prefix.pch. -// RUN: %clang_cc1 -x objective-c -I %t-dir -fmodules -fmodules-cache-path=%t-dir/cache -fdisable-module-hash -emit-pch %t-dir/prefix.h -o %t-dir/prefix.pch +// RUN: %clang_cc1 -x objective-c -I %t-dir -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-dir/cache -fdisable-module-hash -emit-pch %t-dir/prefix.h -o %t-dir/prefix.pch // Modify the dependency. // RUN: echo ' ' >> %t-dir/test.h // Run and check the diagnostics. -// RUN: not %clang_cc1 -x objective-c -I %t-dir -include-pch %t-dir/prefix.pch -fmodules -fmodules-cache-path=%t-dir/cache -fdisable-module-hash -fsyntax-only %s 2> %t-dir/log +// RUN: not %clang_cc1 -x objective-c -I %t-dir -include-pch %t-dir/prefix.pch -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-dir/cache -fdisable-module-hash -fsyntax-only %s 2> %t-dir/log // RUN: FileCheck %s < %t-dir/log // CHECK: file '[[TEST_H:.*[/\\]test\.h]]' has been modified since the precompiled header '[[PREFIX_PCH:.*/prefix\.pch]]' was built diff --git a/test/PCH/module-hash-difference.m b/test/PCH/module-hash-difference.m index 073540eb540c..fc542b0e8d1a 100644 --- a/test/PCH/module-hash-difference.m +++ b/test/PCH/module-hash-difference.m @@ -1,7 +1,7 @@ // RUN: rm -rf %t.mcp // RUN: rm -rf %t.err -// RUN: %clang_cc1 -emit-pch -o %t.pch %s -I %S/Inputs/modules -fmodules -fmodules-cache-path=%t.mcp -// RUN: not %clang_cc1 -fsyntax-only -include-pch %t.pch %s -I %S/Inputs/modules -fmodules -fmodules-cache-path=%t.mcp -fdisable-module-hash 2> %t.err +// RUN: %clang_cc1 -emit-pch -o %t.pch %s -I %S/Inputs/modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp +// RUN: not %clang_cc1 -fsyntax-only -include-pch %t.pch %s -I %S/Inputs/modules -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -fdisable-module-hash 2> %t.err // RUN: FileCheck -input-file=%t.err %s // CHECK: error: PCH was compiled with module cache path {{.*}}, but the path is currently {{.*}} diff --git a/test/Parser/MicrosoftExtensions.c b/test/Parser/MicrosoftExtensions.c index 40a9510d6e24..389cf6dfc03c 100644 --- a/test/Parser/MicrosoftExtensions.c +++ b/test/Parser/MicrosoftExtensions.c @@ -52,6 +52,11 @@ void deprecated_enum_test(void) { [returnvalue:SA_Post( attr=1)] int foo1([SA_Post(attr=1)] void *param); +[unbalanced(attribute) /* expected-note {{to match this '['}} */ +void f(void); /* expected-error {{expected ']'}} */ + +[] __interface I {}; /* expected-error {{Microsoft attribute block cannot be empty}} */ + void ms_intrinsics(int a) { __noop(); __assume(a); diff --git a/test/Parser/nullability.c b/test/Parser/nullability.c new file mode 100644 index 000000000000..f2b6abf73dcf --- /dev/null +++ b/test/Parser/nullability.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c99 -Wno-nullability-declspec -pedantic %s -verify + +__nonnull int *ptr; // expected-warning{{type nullability specifier '__nonnull' is a Clang extension}} + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wnullability-extension" +__nonnull int *ptr2; // no-warning +#pragma clang diagnostic pop + +#if __has_feature(nullability) +# error Nullability should not be supported in C under -pedantic -std=c99 +#endif + +#if !__has_extension(nullability) +# error Nullability should always be supported as an extension +#endif diff --git a/test/Parser/pragma-loop-safety.cpp b/test/Parser/pragma-loop-safety.cpp new file mode 100644 index 000000000000..cc98c775e595 --- /dev/null +++ b/test/Parser/pragma-loop-safety.cpp @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -std=c++11 -verify %s + +// Note that this puts the expected lines before the directives to work around +// limitations in the -verify mode. + +void test(int *List, int Length) { + int i = 0; + +#pragma clang loop vectorize(assume_safety) +#pragma clang loop interleave(assume_safety) + while (i + 1 < Length) { + List[i] = i; + } + +/* expected-error {{expected ')'}} */ #pragma clang loop vectorize(assume_safety +/* expected-error {{expected ')'}} */ #pragma clang loop interleave(assume_safety + +/* expected-error {{invalid argument; expected 'full' or 'disable'}} */ #pragma clang loop unroll(assume_safety) + +/* expected-error {{invalid argument; expected 'enable', 'assume_safety' or 'disable'}} */ #pragma clang loop vectorize(badidentifier) +/* expected-error {{invalid argument; expected 'enable', 'assume_safety' or 'disable'}} */ #pragma clang loop interleave(badidentifier) +/* expected-error {{invalid argument; expected 'full' or 'disable'}} */ #pragma clang loop unroll(badidentifier) + while (i-7 < Length) { + List[i] = i; + } + +/* expected-error {{duplicate directives 'vectorize(assume_safety)' and 'vectorize(enable)'}} */ #pragma clang loop vectorize(enable) +#pragma clang loop vectorize(assume_safety) +/* expected-error {{duplicate directives 'interleave(assume_safety)' and 'interleave(enable)'}} */ #pragma clang loop interleave(enable) +#pragma clang loop interleave(assume_safety) + while (i-9 < Length) { + List[i] = i; + } +} diff --git a/test/Parser/pragma-loop.cpp b/test/Parser/pragma-loop.cpp index a0213ac50d5a..60820584a9c8 100644 --- a/test/Parser/pragma-loop.cpp +++ b/test/Parser/pragma-loop.cpp @@ -130,7 +130,7 @@ void test(int *List, int Length) { /* expected-error {{expected ')'}} */ #pragma clang loop interleave_count(4 /* expected-error {{expected ')'}} */ #pragma clang loop unroll_count(4 -/* expected-error {{missing argument; expected 'enable' or 'disable'}} */ #pragma clang loop vectorize() +/* expected-error {{missing argument; expected 'enable', 'assume_safety' or 'disable'}} */ #pragma clang loop vectorize() /* expected-error {{missing argument; expected an integer value}} */ #pragma clang loop interleave_count() /* expected-error {{missing argument; expected 'full' or 'disable'}} */ #pragma clang loop unroll() @@ -184,8 +184,8 @@ const int VV = 4; List[i] = i; } -/* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ #pragma clang loop vectorize(badidentifier) -/* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ #pragma clang loop interleave(badidentifier) +/* expected-error {{invalid argument; expected 'enable', 'assume_safety' or 'disable'}} */ #pragma clang loop vectorize(badidentifier) +/* expected-error {{invalid argument; expected 'enable', 'assume_safety' or 'disable'}} */ #pragma clang loop interleave(badidentifier) /* expected-error {{invalid argument; expected 'full' or 'disable'}} */ #pragma clang loop unroll(badidentifier) while (i-7 < Length) { List[i] = i; @@ -194,7 +194,7 @@ const int VV = 4; // PR20069 - Loop pragma arguments that are not identifiers or numeric // constants crash FE. /* expected-error {{expected ')'}} */ #pragma clang loop vectorize(() -/* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ #pragma clang loop interleave(*) +/* expected-error {{invalid argument; expected 'enable', 'assume_safety' or 'disable'}} */ #pragma clang loop interleave(*) /* expected-error {{invalid argument; expected 'full' or 'disable'}} */ #pragma clang loop unroll(=) /* expected-error {{type name requires a specifier or qualifier}} expected-error {{expected expression}} */ #pragma clang loop vectorize_width(^) /* expected-error {{expected expression}} expected-error {{expected expression}} */ #pragma clang loop interleave_count(/) diff --git a/test/Preprocessor/aarch64-target-features.c b/test/Preprocessor/aarch64-target-features.c index 85c0f246840b..eea72b3df35b 100644 --- a/test/Preprocessor/aarch64-target-features.c +++ b/test/Preprocessor/aarch64-target-features.c @@ -92,6 +92,12 @@ // RUN: %clang -target aarch64 -mcpu=generic+crc -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-MCPU-2 %s // RUN: %clang -target aarch64 -mcpu=generic+nocrc+crc -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-MCPU-2 %s // RUN: %clang -target aarch64 -mcpu=cortex-a53+nosimd -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-MCPU-3 %s +// ================== Check whether -mcpu accepts mixed-case features. +// RUN: %clang -target aarch64 -mcpu=cyclone+NOCRYPTO -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-MCPU-1 %s +// RUN: %clang -target aarch64 -mcpu=cyclone+CRYPTO+nocrypto -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-MCPU-1 %s +// RUN: %clang -target aarch64 -mcpu=generic+Crc -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-MCPU-2 %s +// RUN: %clang -target aarch64 -mcpu=GENERIC+nocrc+CRC -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-MCPU-2 %s +// RUN: %clang -target aarch64 -mcpu=cortex-a53+noSIMD -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-MCPU-3 %s // CHECK-MCPU-1: "-cc1"{{.*}} "-triple" "aarch64{{.*}}" "-target-feature" "+neon" "-target-feature" "+crc" "-target-feature" "-crypto" "-target-feature" "+zcm" "-target-feature" "+zcz" // CHECK-MCPU-2: "-cc1"{{.*}} "-triple" "aarch64{{.*}}" "-target-feature" "+neon" "-target-feature" "+crc" // CHECK-MCPU-3: "-cc1"{{.*}} "-triple" "aarch64{{.*}}" "-target-feature" "-neon" @@ -113,6 +119,10 @@ // RUN: %clang -target aarch64 -march=armv8.1a+crypto -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V81A-FEATURE-1 %s // RUN: %clang -target aarch64 -march=armv8.1a+nocrypto -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V81A-FEATURE-2 %s // RUN: %clang -target aarch64 -march=armv8.1a+nosimd -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V81A-FEATURE-3 %s +// ================== Check whether -march accepts mixed-case features. +// RUN: %clang -target aarch64 -march=ARMV8.1A+CRYPTO -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V81A-FEATURE-1 %s +// RUN: %clang -target aarch64 -march=Armv8.1a+NOcrypto -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V81A-FEATURE-2 %s +// RUN: %clang -target aarch64 -march=armv8.1a+noSIMD -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V81A-FEATURE-3 %s // CHECK-V81A-FEATURE-1: "-cc1"{{.*}} "-triple" "aarch64{{.*}}" "-target-feature" "+neon" "-target-feature" "+v8.1a" "-target-feature" "+crypto" // CHECK-V81A-FEATURE-2: "-cc1"{{.*}} "-triple" "aarch64{{.*}}" "-target-feature" "+neon" "-target-feature" "+v8.1a" "-target-feature" "-crypto" // CHECK-V81A-FEATURE-3: "-cc1"{{.*}} "-triple" "aarch64{{.*}}" "-target-feature" "+v8.1a" "-target-feature" "-neon" diff --git a/test/Preprocessor/openmp-macro-expansion.c b/test/Preprocessor/openmp-macro-expansion.c new file mode 100644 index 000000000000..a83512b5920a --- /dev/null +++ b/test/Preprocessor/openmp-macro-expansion.c @@ -0,0 +1,31 @@ +// RUN: %clang_cc1 -fopenmp -E -o - %s 2>&1 | FileCheck %s + +// This is to make sure the pragma name is not expanded! +#define omp (0xDEADBEEF) + +#define N 2 +#define M 1 +#define E N> + +#define map_to_be_expanded(x) map(tofrom:x) +#define sched_to_be_expanded(x,s) schedule(x,s) +#define reda_to_be_expanded(x) reduction(+:x) +#define redb_to_be_expanded(x,op) reduction(op:x) + +void foo(int *a, int *b) { + //CHECK: omp target map(a[0:2]) map(tofrom:b[0:2*1]) + #pragma omp target map(a[0:N]) map_to_be_expanded(b[0:2*M]) + { + int reda; + int redb; + //CHECK: omp parallel for schedule(static,2> >1) reduction(+:reda) reduction(*:redb) + #pragma omp parallel for sched_to_be_expanded(static, E>1) \ + reda_to_be_expanded(reda) redb_to_be_expanded(redb,*) + for (int i = 0; i < N; ++i) { + reda += a[i]; + redb += b[i]; + } + a[0] = reda; + b[0] = redb; + } +} diff --git a/test/Preprocessor/pp-modules.c b/test/Preprocessor/pp-modules.c index 213a5fd23c8d..09f3eee193f4 100644 --- a/test/Preprocessor/pp-modules.c +++ b/test/Preprocessor/pp-modules.c @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x objective-c %s -F %S/../Modules/Inputs -E -o - | FileCheck %s +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -x objective-c %s -F %S/../Modules/Inputs -E -o - | FileCheck %s // CHECK: int bar(); int bar(); diff --git a/test/Sema/aarch64-special-register.c b/test/Sema/aarch64-special-register.c new file mode 100644 index 000000000000..40d4033967f8 --- /dev/null +++ b/test/Sema/aarch64-special-register.c @@ -0,0 +1,77 @@ +// RUN: %clang_cc1 -ffreestanding -fsyntax-only -verify -triple aarch64 %s + +void string_literal(unsigned v) { + __builtin_arm_wsr(0, v); // expected-error {{expression is not a string literal}} +} + +void wsr_1(unsigned v) { + __builtin_arm_wsr("sysreg", v); +} + +void wsrp_1(void *v) { + __builtin_arm_wsrp("sysreg", v); +} + +void wsr64_1(unsigned long v) { + __builtin_arm_wsr64("sysreg", v); //expected-error {{invalid special register for builtin}} +} + +unsigned rsr_1() { + return __builtin_arm_rsr("sysreg"); +} + +void *rsrp_1() { + return __builtin_arm_rsrp("sysreg"); +} + +unsigned long rsr64_1() { + return __builtin_arm_rsr64("sysreg"); //expected-error {{invalid special register for builtin}} +} + +void wsr_2(unsigned v) { + __builtin_arm_wsr("0:1:2:3:4", v); +} + +void wsrp_2(void *v) { + __builtin_arm_wsrp("0:1:2:3:4", v); +} + +void wsr64_2(unsigned long v) { + __builtin_arm_wsr64("0:1:2:3:4", v); +} + +unsigned rsr_2() { + return __builtin_arm_rsr("0:1:2:3:4"); +} + +void *rsrp_2() { + return __builtin_arm_rsrp("0:1:2:3:4"); +} + +unsigned long rsr64_2() { + return __builtin_arm_rsr64("0:1:2:3:4"); +} + +void wsr_3(unsigned v) { + __builtin_arm_wsr("0:1:2", v); //expected-error {{invalid special register for builtin}} +} + +void wsrp_3(void *v) { + __builtin_arm_wsrp("0:1:2", v); //expected-error {{invalid special register for builtin}} +} + +void wsr64_3(unsigned long v) { + __builtin_arm_wsr64("0:1:2", v); //expected-error {{invalid special register for builtin}} +} + +unsigned rsr_3() { + return __builtin_arm_rsr("0:1:2"); //expected-error {{invalid special register for builtin}} +} + +void *rsrp_3() { + return __builtin_arm_rsrp("0:1:2"); //expected-error {{invalid special register for builtin}} +} + +unsigned long rsr64_3() { + return __builtin_arm_rsr64("0:1:2"); //expected-error {{invalid special register for builtin}} +} diff --git a/test/Sema/arm-special-register.c b/test/Sema/arm-special-register.c new file mode 100644 index 000000000000..3ded628c137d --- /dev/null +++ b/test/Sema/arm-special-register.c @@ -0,0 +1,89 @@ +// RUN: %clang_cc1 -ffreestanding -fsyntax-only -verify -triple arm %s + +void string_literal(unsigned v) { + __builtin_arm_wsr(0, v); // expected-error {{expression is not a string literal}} +} + +void wsr_1(unsigned v) { + __builtin_arm_wsr("sysreg", v); +} + +void wsrp_1(void *v) { + __builtin_arm_wsrp("sysreg", v); +} + +void wsr64_1(unsigned long v) { + __builtin_arm_wsr64("sysreg", v); //expected-error {{invalid special register for builtin}} +} + +unsigned rsr_1() { + return __builtin_arm_rsr("sysreg"); +} + +void *rsrp_1() { + return __builtin_arm_rsrp("sysreg"); +} + +unsigned long rsr64_1() { + return __builtin_arm_rsr64("sysreg"); //expected-error {{invalid special register for builtin}} +} + +void wsr_2(unsigned v) { + __builtin_arm_wsr("cp0:1:c2:c3:4", v); +} + +void wsrp_2(void *v) { + __builtin_arm_wsrp("cp0:1:c2:c3:4", v); +} + +void wsr64_2(unsigned long v) { + __builtin_arm_wsr64("cp0:1:c2:c3:4", v); //expected-error {{invalid special register for builtin}} +} + +unsigned rsr_2() { + return __builtin_arm_rsr("cp0:1:c2:c3:4"); +} + +void *rsrp_2() { + return __builtin_arm_rsrp("cp0:1:c2:c3:4"); +} + +unsigned long rsr64_2() { + return __builtin_arm_rsr64("cp0:1:c2:c3:4"); //expected-error {{invalid special register for builtin}} +} + +void wsr_3(unsigned v) { + __builtin_arm_wsr("cp0:1:c2", v); //expected-error {{invalid special register for builtin}} +} + +void wsrp_3(void *v) { + __builtin_arm_wsrp("cp0:1:c2", v); //expected-error {{invalid special register for builtin}} +} + +void wsr64_3(unsigned long v) { + __builtin_arm_wsr64("cp0:1:c2", v); +} + +unsigned rsr_3() { + return __builtin_arm_rsr("cp0:1:c2"); //expected-error {{invalid special register for builtin}} +} + +void *rsrp_3() { + return __builtin_arm_rsrp("cp0:1:c2"); //expected-error {{invalid special register for builtin}} +} + +unsigned long rsr64_3() { + return __builtin_arm_rsr64("cp0:1:c2"); +} + +unsigned rsr_4() { + return __builtin_arm_rsr("0:1:2:3:4"); //expected-error {{invalid special register for builtin}} +} + +void *rsrp_4() { + return __builtin_arm_rsrp("0:1:2:3:4"); //expected-error {{invalid special register for builtin}} +} + +unsigned long rsr64_4() { + return __builtin_arm_rsr64("0:1:2"); //expected-error {{invalid special register for builtin}} +} diff --git a/test/Sema/attr-mode-vector-types.c b/test/Sema/attr-mode-vector-types.c new file mode 100644 index 000000000000..3893922a6a6d --- /dev/null +++ b/test/Sema/attr-mode-vector-types.c @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-unknown-linux-gnu %s + +// Correct cases. +typedef int __attribute__((mode(byte))) __attribute__((vector_size(256))) vec_t1; +typedef int __attribute__((mode(QI))) __attribute__((vector_size(256))) vec_t2; +typedef int __attribute__((mode(SI))) __attribute__((vector_size(256))) vec_t3; +typedef int __attribute__((mode(DI))) __attribute__((vector_size(256)))vec_t4; +typedef float __attribute__((mode(SF))) __attribute__((vector_size(256))) vec_t5; +typedef float __attribute__((mode(DF))) __attribute__((vector_size(256))) vec_t6; +typedef float __attribute__((mode(XF))) __attribute__((vector_size(256))) vec_t7; + +// Incorrect cases. +typedef float __attribute__((mode(QC))) __attribute__((vector_size(256))) vec_t8; +// expected-error@-1{{unsupported machine mode 'QC'}} +// expected-error@-2{{type of machine mode does not match type of base type}} +typedef _Complex float __attribute__((mode(HC))) __attribute__((vector_size(256))) vec_t9; +// expected-error@-1{{unsupported machine mode 'HC'}} +// expected-error@-2{{invalid vector element type '_Complex float'}} +typedef int __attribute__((mode(SC))) __attribute__((vector_size(256))) vec_t10; +// expected-error@-1{{type of machine mode does not match type of base type}} +// expected-error@-2{{type of machine mode does not support base vector types}} +typedef float __attribute__((mode(DC))) __attribute__((vector_size(256))) vec_t11; +// expected-error@-1{{type of machine mode does not match type of base type}} +// expected-error@-2{{type of machine mode does not support base vector types}} +typedef _Complex float __attribute__((mode(XC))) __attribute__((vector_size(256))) vec_t12; +// expected-error@-1{{invalid vector element type '_Complex float'}} diff --git a/test/Sema/attr-target.c b/test/Sema/attr-target.c new file mode 100644 index 000000000000..6c6b461904d1 --- /dev/null +++ b/test/Sema/attr-target.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -verify %s + +int __attribute__((target("avx,sse4.2,arch=ivybridge"))) foo() { return 4; } +int __attribute__((target())) bar() { return 4; } //expected-error {{'target' attribute takes one argument}} +int __attribute__((target("tune=sandybridge"))) baz() { return 4; } //expected-warning {{Ignoring unsupported 'tune=' in the target attribute string}} +int __attribute__((target("fpmath=387"))) walrus() { return 4; } //expected-warning {{Ignoring unsupported 'fpmath=' in the target attribute string}} + + diff --git a/test/Sema/designated-initializers.c b/test/Sema/designated-initializers.c index 6630da67c5bd..a4582deb171e 100644 --- a/test/Sema/designated-initializers.c +++ b/test/Sema/designated-initializers.c @@ -45,8 +45,8 @@ struct point array[10] = { struct point array2[10] = { [10].x = 2.0, // expected-error{{array designator index (10) exceeds array bounds (10)}} - [4 ... 5].y = 2.0, - [4 ... 6] = { .x = 3, .y = 4.0 } + [4 ... 5].y = 2.0, // expected-note 2 {{previous initialization is here}} + [4 ... 6] = { .x = 3, .y = 4.0 } // expected-warning 2 {{subobject initialization overrides initialization of other fields within its enclosing subobject}} }; struct point array3[10] = { @@ -129,11 +129,11 @@ int get8() { ++counter; return 8; } void test() { struct X xs[] = { - [0] = (struct X){1, 2}, // expected-note{{previous initialization is here}} + [0] = (struct X){1, 2}, // expected-note 2 {{previous initialization is here}} [0].c = 3, // expected-warning{{subobject initialization overrides initialization of other fields within its enclosing subobject}} (struct X) {4, 5, 6}, // expected-note{{previous initialization is here}} [1].b = get8(), // expected-warning{{subobject initialization overrides initialization of other fields within its enclosing subobject}} - [0].b = 8 + [0].b = 8 // expected-warning{{subobject initialization overrides initialization of other fields within its enclosing subobject}} }; } @@ -332,12 +332,22 @@ struct overwrite_string_struct { int M; } overwrite_string[] = { { { "foo" }, 1 }, // expected-note {{previous initialization is here}} - [0].L[2] = 'x' // expected-warning{{initializer overrides prior initialization of this subobject}} + [0].L[2] = 'x' // expected-warning{{subobject initialization overrides initialization of other fields}} }; struct overwrite_string_struct2 { char L[6]; int M; } overwrite_string2[] = { - { { "foo" }, 1 }, - [0].L[4] = 'x' // no-warning + { { "foo" }, 1 }, // expected-note{{previous initialization is here}} + [0].L[4] = 'x' // expected-warning{{subobject initialization overrides initialization of other fields}} }; +struct overwrite_string_struct +overwrite_string3[] = { + "foo", 1, // expected-note{{previous initialization is here}} + [0].L[4] = 'x' // expected-warning{{subobject initialization overrides initialization of other fields}} +}; +struct overwrite_string_struct +overwrite_string4[] = { + { { 'f', 'o', 'o' }, 1 }, + [0].L[4] = 'x' // no-warning +}; diff --git a/test/Sema/non-null-warning.c b/test/Sema/non-null-warning.c new file mode 100644 index 000000000000..6cd98e298e2c --- /dev/null +++ b/test/Sema/non-null-warning.c @@ -0,0 +1,42 @@ +// RUN: %clang_cc1 -fsyntax-only -Wnonnull -Wnullability %s -verify +// rdar://19160762 + +#if __has_feature(nullability) +#else +# error nullability feature should be defined +#endif + + +int * __nullable foo(int * __nonnull x); + +int *__nonnull ret_nonnull(); + +int *foo(int *x) { + return 0; +} + +int * __nullable foo1(int * __nonnull x); // expected-note {{previous declaration is here}} + +int *foo1(int * __nullable x) { // expected-warning {{nullability specifier '__nullable' conflicts with existing specifier '__nonnull'}} + return 0; +} + +int * __nullable foo2(int * __nonnull x); + +int *foo2(int * __nonnull x) { + return 0; +} + +int * __nullable foo3(int * __nullable x); // expected-note {{previous declaration is here}} + +int *foo3(int * __nonnull x) { // expected-warning {{nullability specifier '__nonnull' conflicts with existing specifier '__nullable'}} + return 0; +} + +int * ret_nonnull() { + return 0; // expected-warning {{null returned from function that requires a non-null return value}} +} + +int main () { + foo(0); // expected-warning {{null passed to a callee that requires a non-null argument}} +} diff --git a/test/Sema/nullability.c b/test/Sema/nullability.c new file mode 100644 index 000000000000..6144b7e8e9e8 --- /dev/null +++ b/test/Sema/nullability.c @@ -0,0 +1,113 @@ +// RUN: %clang_cc1 -fsyntax-only -fblocks -Wnullable-to-nonnull-conversion -Wno-nullability-declspec %s -verify + +#if __has_feature(nullability) +#else +# error nullability feature should be defined +#endif + +typedef int * int_ptr; + +// Parse nullability type specifiers. +typedef int * __nonnull nonnull_int_ptr; // expected-note{{'__nonnull' specified here}} +typedef int * __nullable nullable_int_ptr; +typedef int * __null_unspecified null_unspecified_int_ptr; + +// Redundant nullability type specifiers. +typedef int * __nonnull __nonnull redundant_1; // expected-warning{{duplicate nullability specifier '__nonnull'}} + +// Conflicting nullability type specifiers. +typedef int * __nonnull __nullable conflicting_1; // expected-error{{nullability specifier '__nonnull' conflicts with existing specifier '__nullable'}} +typedef int * __null_unspecified __nonnull conflicting_2; // expected-error{{nullability specifier '__null_unspecified' conflicts with existing specifier '__nonnull'}} + +// Redundant nullability specifiers via a typedef are okay. +typedef nonnull_int_ptr __nonnull redundant_okay_1; + +// Conflicting nullability specifiers via a typedef are not. +typedef nonnull_int_ptr __nullable conflicting_2; // expected-error{{nullability specifier '__nullable' conflicts with existing specifier '__nonnull'}} +typedef nonnull_int_ptr nonnull_int_ptr_typedef; +typedef nonnull_int_ptr_typedef __nullable conflicting_2; // expected-error{{nullability specifier '__nullable' conflicts with existing specifier '__nonnull'}} +typedef nonnull_int_ptr_typedef nonnull_int_ptr_typedef_typedef; +typedef nonnull_int_ptr_typedef_typedef __null_unspecified conflicting_3; // expected-error{{nullability specifier '__null_unspecified' conflicts with existing specifier '__nonnull'}} + +// Nullability applies to all pointer types. +typedef int (* __nonnull function_pointer_type_1)(int, int); +typedef int (^ __nonnull block_type_1)(int, int); + +// Nullability must be on a pointer type. +typedef int __nonnull int_type_1; // expected-error{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'int'}} + +// Nullability can move out to a pointer/block pointer declarator +// (with a suppressed warning). +typedef __nonnull int * nonnull_int_ptr_2; +typedef int __nullable * nullable_int_ptr_2; +typedef __nonnull int (* function_pointer_type_2)(int, int); +typedef __nonnull int (^ block_type_2)(int, int); +typedef __nonnull int * * __nullable nonnull_int_ptr_ptr_1; +typedef __nonnull int *(^ block_type_3)(int, int); +typedef __nonnull int *(* function_pointer_type_3)(int, int); +typedef __nonnull int_ptr (^ block_type_4)(int, int); +typedef __nonnull int_ptr (* function_pointer_type_4)(int, int); + +void acceptFunctionPtr(__nonnull int *(*)(void)); +void acceptBlockPtr(__nonnull int *(^)(void)); + +void testBlockFunctionPtrNullability() { + float *fp; + fp = (function_pointer_type_3)0; // expected-warning{{from 'function_pointer_type_3' (aka 'int * __nonnull (*)(int, int)')}} + fp = (block_type_3)0; // expected-error{{from incompatible type 'block_type_3' (aka 'int * __nonnull (^)(int, int)')}} + fp = (function_pointer_type_4)0; // expected-warning{{from 'function_pointer_type_4' (aka 'int_ptr __nonnull (*)(int, int)')}} + fp = (block_type_4)0; // expected-error{{from incompatible type 'block_type_4' (aka 'int_ptr __nonnull (^)(int, int)')}} + + acceptFunctionPtr(0); // no-warning + acceptBlockPtr(0); // no-warning +} + +// Moving nullability where it creates a conflict. +typedef __nonnull int * __nullable * conflict_int_ptr_ptr_2; // expected-error{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'int'}} + +// Nullability is not part of the canonical type. +typedef int * __nonnull ambiguous_int_ptr; +typedef int * ambiguous_int_ptr; +typedef int * __nullable ambiguous_int_ptr; + +// Printing of nullability. +float f; +int * __nonnull ip_1 = &f; // expected-warning{{incompatible pointer types initializing 'int * __nonnull' with an expression of type 'float *'}} + +// Check printing of nullability specifiers. +void printing_nullability(void) { + int * __nonnull iptr; + float *fptr = iptr; // expected-warning{{incompatible pointer types initializing 'float *' with an expression of type 'int * __nonnull'}} + + int * * __nonnull iptrptr; + float **fptrptr = iptrptr; // expected-warning{{incompatible pointer types initializing 'float **' with an expression of type 'int ** __nonnull'}} + + int * __nullable * __nonnull iptrptr2; + float * *fptrptr2 = iptrptr2; // expected-warning{{incompatible pointer types initializing 'float **' with an expression of type 'int * __nullable * __nonnull'}} +} + +// Check passing null to a __nonnull argument. +void accepts_nonnull_1(__nonnull int *ptr); +void (*accepts_nonnull_2)(__nonnull int *ptr); +void (^accepts_nonnull_3)(__nonnull int *ptr); + +void test_accepts_nonnull_null_pointer_literal() { + accepts_nonnull_1(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + accepts_nonnull_2(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + accepts_nonnull_3(0); // expected-warning{{null passed to a callee that requires a non-null argument}} +} + +// Check returning nil from a __nonnull-returning function. +__nonnull int *returns_int_ptr(int x) { + if (x) { + return 0; // expected-warning{{null returned from function that requires a non-null return value}} + } + + return (__nonnull int *)0; +} + +// Check nullable-to-nonnull conversions. +void nullable_to_nonnull(__nullable int *ptr) { + int *a = ptr; // okay + __nonnull int *b = ptr; // expected-warning{{implicit conversion from nullable pointer 'int * __nullable' to non-nullable pointer type 'int * __nonnull'}} +} diff --git a/test/Sema/stmtexprs.c b/test/Sema/stmtexprs.c new file mode 100644 index 000000000000..8594aae18688 --- /dev/null +++ b/test/Sema/stmtexprs.c @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -Wno-gnu-statement-expression + +int stmtexpr_fn(); +void stmtexprs(int i) { + __builtin_assume( ({ 1; }) ); // no warning about "side effects" + __builtin_assume( ({ if (i) { (void)0; }; 42; }) ); // no warning about "side effects" + // expected-warning@+1 {{the argument to '__builtin_assume' has side effects that will be discarded}} + __builtin_assume( ({ if (i) ({ stmtexpr_fn(); }); 1; }) ); +} diff --git a/test/Sema/warn-unused-function.c b/test/Sema/warn-unused-function.c index 013b925f89d8..6d813669d6c9 100644 --- a/test/Sema/warn-unused-function.c +++ b/test/Sema/warn-unused-function.c @@ -1,6 +1,6 @@ // RUN: %clang_cc1 -fsyntax-only -Wused-but-marked-unused -Wunused-function -Wunneeded-internal-declaration -verify %s // RUN: %clang_cc1 -fsyntax-only -verify -Wunused %s -// RUN: %clang_cc1 -fsyntax-only -verify -Wall %s +// RUN: %clang_cc1 -fsyntax-only -verify -Wall -Wno-infinite-recursion %s void foo() {} static void f2() {} diff --git a/test/SemaCXX/decltype.cpp b/test/SemaCXX/decltype.cpp index f1900b2b830f..2956f9a228e0 100644 --- a/test/SemaCXX/decltype.cpp +++ b/test/SemaCXX/decltype.cpp @@ -76,6 +76,31 @@ namespace PR18876 { decltype(f(), 0) *e; // expected-error {{attempt to use a deleted function}} } +namespace D5789 { + struct P1 { char x[6]; } g1 = { "foo" }; + struct LP1 { struct P1 p1; }; + + // expected-warning@+3 {{subobject initialization overrides}} + // expected-note@+2 {{previous initialization}} + // expected-note@+1 {{previous definition}} + template<class T> void foo(decltype(T(LP1{ .p1 = g1, .p1.x[1] = 'x' }))) {} + + // expected-warning@+3 {{subobject initialization overrides}} + // expected-note@+2 {{previous initialization}} + template<class T> + void foo(decltype(T(LP1{ .p1 = g1, .p1.x[1] = 'r' }))) {} // okay + + // expected-warning@+3 {{subobject initialization overrides}} + // expected-note@+2 {{previous initialization}} + template<class T> + void foo(decltype(T(LP1{ .p1 = { "foo" }, .p1.x[1] = 'x'}))) {} // okay + + // expected-warning@+3 {{subobject initialization overrides}} + // expected-note@+2 {{previous initialization}} + // expected-error@+1 {{redefinition of 'foo'}} + template<class T> void foo(decltype(T(LP1{ .p1 = g1, .p1.x[1] = 'x' }))) {} +} + template<typename> class conditional { }; diff --git a/test/SemaCXX/incomplete-call.cpp b/test/SemaCXX/incomplete-call.cpp index 69eb03a3eda7..6f5169ee8aa0 100644 --- a/test/SemaCXX/incomplete-call.cpp +++ b/test/SemaCXX/incomplete-call.cpp @@ -47,3 +47,15 @@ struct C; // expected-note{{forward declaration}} void test_incomplete_object_call(C& c) { c(); // expected-error{{incomplete type in call to object of type}} } + +namespace pr18542 { + struct X { + int count; + template<typename CharT> class basic_istream; + template<typename CharT> + void basic_istream<CharT>::read() { // expected-error{{out-of-line definition of 'read' from class 'basic_istream<CharT>' without definition}} + count = 0; + } + }; +} + diff --git a/test/SemaCXX/nullability-declspec.cpp b/test/SemaCXX/nullability-declspec.cpp new file mode 100644 index 000000000000..ef1a171c4ddb --- /dev/null +++ b/test/SemaCXX/nullability-declspec.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fblocks -Werror=nullability-declspec -verify %s + +struct X { }; + +__nullable int *ip1; // expected-error{{nullability specifier '__nullable' cannot be applied to non-pointer type 'int'; did you mean to apply the specifier to the pointer?}} +__nullable int (*fp1)(int); // expected-error{{nullability specifier '__nullable' cannot be applied to non-pointer type 'int'; did you mean to apply the specifier to the function pointer?}} +__nonnull int (^bp1)(int); // expected-error{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'int'; did you mean to apply the specifier to the block pointer?}} +__nonnull int X::*pmd1; // expected-error{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'int'; did you mean to apply the specifier to the member pointer?}} +__nonnull int (X::*pmf1)(int); // expected-error{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'int'; did you mean to apply the specifier to the member function pointer?}} diff --git a/test/SemaCXX/nullability.cpp b/test/SemaCXX/nullability.cpp new file mode 100644 index 000000000000..f0aa13be8fa3 --- /dev/null +++ b/test/SemaCXX/nullability.cpp @@ -0,0 +1,64 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wno-nullability-declspec %s -verify + +typedef decltype(nullptr) nullptr_t; + +class X { +}; + +// Nullability applies to all pointer types. +typedef int (X::* __nonnull member_function_type_1)(int); +typedef int X::* __nonnull member_data_type_1; +typedef nullptr_t __nonnull nonnull_nullptr_t; // expected-error{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'nullptr_t'}} + +// Nullability can move into member pointers (this is suppressing a warning). +typedef __nonnull int (X::* member_function_type_2)(int); +typedef int (X::* __nonnull member_function_type_3)(int); +typedef __nonnull int X::* member_data_type_2; + +// Adding non-null via a template. +template<typename T> +struct AddNonNull { + typedef __nonnull T type; // expected-error{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'int'}} + // expected-error@-1{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'nullptr_t'}} +}; + +typedef AddNonNull<int *>::type nonnull_int_ptr_1; +typedef AddNonNull<int * __nullable>::type nonnull_int_ptr_2; // FIXME: check that it was overridden +typedef AddNonNull<nullptr_t>::type nonnull_int_ptr_3; // expected-note{{in instantiation of template class}} + +typedef AddNonNull<int>::type nonnull_non_pointer_1; // expected-note{{in instantiation of template class 'AddNonNull<int>' requested here}} + +// Non-null checking within a template. +template<typename T> +struct AddNonNull2 { + typedef __nonnull AddNonNull<T> invalid1; // expected-error{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'AddNonNull<T>'}} + typedef __nonnull AddNonNull2 invalid2; // expected-error{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'AddNonNull2<T>'}} + typedef __nonnull AddNonNull2<T> invalid3; // expected-error{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'AddNonNull2<T>'}} + typedef __nonnull typename AddNonNull<T>::type okay1; + + // Don't move past a dependent type even if we know that nullability + // cannot apply to that specific dependent type. + typedef __nonnull AddNonNull<T> (*invalid4); // expected-error{{nullability specifier '__nonnull' cannot be applied to non-pointer type 'AddNonNull<T>'}} +}; + +// Check passing null to a __nonnull argument. +void (*accepts_nonnull_1)(__nonnull int *ptr); +void (*& accepts_nonnull_2)(__nonnull int *ptr) = accepts_nonnull_1; +void (X::* accepts_nonnull_3)(__nonnull int *ptr); +void accepts_nonnull_4(__nonnull int *ptr); +void (&accepts_nonnull_5)(__nonnull int *ptr) = accepts_nonnull_4; + +void test_accepts_nonnull_null_pointer_literal(X *x) { + accepts_nonnull_1(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + accepts_nonnull_2(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + (x->*accepts_nonnull_3)(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + accepts_nonnull_4(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + accepts_nonnull_5(0); // expected-warning{{null passed to a callee that requires a non-null argument}} +} + +template<void FP(__nonnull int*)> +void test_accepts_nonnull_null_pointer_literal_template() { + FP(0); // expected-warning{{null passed to a callee that requires a non-null argument}} +} + +template void test_accepts_nonnull_null_pointer_literal_template<&accepts_nonnull_4>(); // expected-note{{instantiation of function template specialization}} diff --git a/test/SemaObjC/arc-property-decl-attrs.m b/test/SemaObjC/arc-property-decl-attrs.m index 283772c2279c..2d469177723a 100644 --- a/test/SemaObjC/arc-property-decl-attrs.m +++ b/test/SemaObjC/arc-property-decl-attrs.m @@ -79,3 +79,29 @@ @property (readwrite) id frr; @end +// rdar://20152386 +// rdar://20383235 + +@interface NSObject @end + +#pragma clang assume_nonnull begin +@interface I: NSObject +@property(nonatomic, weak) id delegate; // Do not warn, nullable is inferred. +@property(nonatomic, weak, readonly) id ROdelegate; // Do not warn, nullable is inferred. +@property(nonatomic, weak, nonnull) id NonNulldelete; // expected-error {{property attributes 'nonnull' and 'weak' are mutually exclusive}} +@property(nonatomic, weak, nullable) id Nullabledelete; // do not warn + +// strong cases. +@property(nonatomic, strong) id stdelegate; // Do not warn +@property(nonatomic, readonly) id stROdelegate; // Do not warn +@property(nonatomic, strong, nonnull) id stNonNulldelete; // Do not warn +@property(nonatomic, nullable) id stNullabledelete; // do not warn +@end +#pragma clang assume_nonnull end + +@interface J: NSObject +@property(nonatomic, weak) id ddd; // Do not warn, nullable is inferred. +@property(nonatomic, weak, nonnull) id delegate; // expected-error {{property attributes 'nonnull' and 'weak' are mutually exclusive}} +@property(nonatomic, weak, nonnull, readonly) id ROdelegate; // expected-error {{property attributes 'nonnull' and 'weak' are mutually exclusive}} +@end + diff --git a/test/SemaObjC/arc-unavailable-for-weakref.m b/test/SemaObjC/arc-unavailable-for-weakref.m index 82748027435e..53ceaa15c28c 100644 --- a/test/SemaObjC/arc-unavailable-for-weakref.m +++ b/test/SemaObjC/arc-unavailable-for-weakref.m @@ -56,7 +56,7 @@ __attribute__((objc_arc_weak_reference_unavailable)) @interface I { } -@property (weak) NSFont *font; // expected-error {{synthesizing __weak instance variable of type 'NSFont *', which does not support weak references}} +@property (weak) NSFont *font; // expected-error {{synthesizing __weak instance variable of type 'NSFont * __nullable', which does not support weak references}} @end @implementation I // expected-note {{when implemented by class I}} @@ -65,7 +65,7 @@ __attribute__((objc_arc_weak_reference_unavailable)) // rdar://13676793 @protocol MyProtocol -@property (weak) NSFont *font; // expected-error {{synthesizing __weak instance variable of type 'NSFont *', which does not support weak references}} +@property (weak) NSFont *font; // expected-error {{synthesizing __weak instance variable of type 'NSFont * __nullable', which does not support weak references}} @end @interface I1 <MyProtocol> @@ -76,7 +76,7 @@ __attribute__((objc_arc_weak_reference_unavailable)) @end @interface Super -@property (weak) NSFont *font; // expected-error {{synthesizing __weak instance variable of type 'NSFont *', which does not support weak references}} +@property (weak) NSFont *font; // expected-error {{synthesizing __weak instance variable of type 'NSFont * __nullable', which does not support weak references}} @end diff --git a/test/SemaObjC/attr-cf_returns.m b/test/SemaObjC/attr-cf_returns.m new file mode 100644 index 000000000000..560d40dc2817 --- /dev/null +++ b/test/SemaObjC/attr-cf_returns.m @@ -0,0 +1,49 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -fobjc-arc -fblocks %s + +#if __has_feature(attribute_cf_returns_on_parameters) +# error "okay!" +// expected-error@-1 {{okay!}} +#else +# error "uh-oh" +#endif + +#define CF_RETURNS_RETAINED __attribute__((cf_returns_retained)) +#define CF_RETURNS_NOT_RETAINED __attribute__((cf_returns_not_retained)) + +int x CF_RETURNS_RETAINED; // expected-warning{{'cf_returns_retained' attribute only applies to functions, methods, and parameters}} +int y CF_RETURNS_NOT_RETAINED; // expected-warning{{'cf_returns_not_retained' attribute only applies to functions, methods, and parameters}} + +typedef struct __CFFoo *CFFooRef; + +int invalid1() CF_RETURNS_RETAINED; // expected-warning{{'cf_returns_retained' attribute only applies to functions that return a pointer}} +void invalid2() CF_RETURNS_RETAINED; // expected-warning{{'cf_returns_retained' attribute only applies to functions that return a pointer}} + +CFFooRef valid1() CF_RETURNS_RETAINED; +id valid2() CF_RETURNS_RETAINED; + +@interface Test +- (int)invalid1 CF_RETURNS_RETAINED; // expected-warning{{'cf_returns_retained' attribute only applies to methods that return a pointer}} +- (void)invalid2 CF_RETURNS_RETAINED; // expected-warning{{'cf_returns_retained' attribute only applies to methods that return a pointer}} + +- (CFFooRef)valid1 CF_RETURNS_RETAINED; +- (id)valid2 CF_RETURNS_RETAINED; + +@property int invalidProp1 CF_RETURNS_RETAINED; // expected-warning{{'cf_returns_retained' attribute only applies to properties that return a pointer}} +@property void invalidProp2 CF_RETURNS_RETAINED; // expected-warning{{'cf_returns_retained' attribute only applies to properties that return a pointer}} + +@property CFFooRef valid1 CF_RETURNS_RETAINED; +@property id valid2 CF_RETURNS_RETAINED; +@end + +void invalidParam(int a CF_RETURNS_RETAINED, // expected-warning{{'cf_returns_retained' attribute only applies to pointer-to-CF-pointer parameters}} + int *b CF_RETURNS_RETAINED, // expected-warning{{'cf_returns_retained' attribute only applies to pointer-to-CF-pointer parameters}} + id c CF_RETURNS_RETAINED, // expected-warning{{'cf_returns_retained' attribute only applies to pointer-to-CF-pointer parameters}} + void *d CF_RETURNS_RETAINED, // expected-warning{{'cf_returns_retained' attribute only applies to pointer-to-CF-pointer parameters}} + CFFooRef e CF_RETURNS_RETAINED); // expected-warning{{'cf_returns_retained' attribute only applies to pointer-to-CF-pointer parameters}} + +void validParam(id *a CF_RETURNS_RETAINED, + CFFooRef *b CF_RETURNS_RETAINED, + void **c CF_RETURNS_RETAINED); +void validParam2(id *a CF_RETURNS_NOT_RETAINED, + CFFooRef *b CF_RETURNS_NOT_RETAINED, + void **c CF_RETURNS_NOT_RETAINED); diff --git a/test/SemaObjC/nullability-arc.m b/test/SemaObjC/nullability-arc.m new file mode 100644 index 000000000000..917a808386dc --- /dev/null +++ b/test/SemaObjC/nullability-arc.m @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -fobjc-arc -fsyntax-only -Woverriding-method-mismatch %s -verify + +__attribute__((objc_root_class)) +@interface NSFoo +@end + +// ARC qualifiers stacked with nullability. +void accepts_arc_qualified(NSFoo * __unsafe_unretained __nonnull obj) { + accepts_arc_qualified(0); // expected-warning{{null passed to a callee that requires a non-null argument}} +} diff --git a/test/SemaObjC/nullability.m b/test/SemaObjC/nullability.m new file mode 100644 index 000000000000..ca8c2fcd321e --- /dev/null +++ b/test/SemaObjC/nullability.m @@ -0,0 +1,232 @@ +// RUN: %clang_cc1 -fsyntax-only -fblocks -Woverriding-method-mismatch -Wno-nullability-declspec %s -verify + +__attribute__((objc_root_class)) +@interface NSFoo +- (void)methodTakingIntPtr:(__nonnull int *)ptr; +- (__nonnull int *)methodReturningIntPtr; +@end + +// Nullability applies to all pointer types. +typedef NSFoo * __nonnull nonnull_NSFoo_ptr; +typedef id __nonnull nonnull_id; +typedef SEL __nonnull nonnull_SEL; + +// Nullability can move into Objective-C pointer types. +typedef __nonnull NSFoo * nonnull_NSFoo_ptr_2; + +// Conflicts from nullability moving into Objective-C pointer type. +typedef __nonnull NSFoo * __nullable conflict_NSFoo_ptr_2; // expected-error{{'__nonnull' cannot be applied to non-pointer type 'NSFoo'}} + +void testBlocksPrinting(NSFoo * __nullable (^bp)(int)) { + int *ip = bp; // expected-error{{'NSFoo * __nullable (^)(int)'}} +} + +// Check returning nil from a __nonnull-returning method. +@implementation NSFoo +- (void)methodTakingIntPtr:(__nonnull int *)ptr { } +- (__nonnull int *)methodReturningIntPtr { + return 0; // no warning +} +@end + +// Context-sensitive keywords and property attributes for nullability. +__attribute__((objc_root_class)) +@interface NSBar +- (nonnull NSFoo *)methodWithFoo:(nonnull NSFoo *)foo; + +- (nonnull NSFoo **)invalidMethod1; // expected-error{{nullability keyword 'nonnull' cannot be applied to multi-level pointer type 'NSFoo **'}} +// expected-note@-1{{use nullability type specifier '__nonnull' to affect the innermost pointer type of 'NSFoo **'}} +- (nonnull NSFoo * __nullable)conflictingMethod1; // expected-error{{nullability specifier '__nullable' conflicts with existing specifier '__nonnull'}} +- (nonnull NSFoo * __nonnull)redundantMethod1; // expected-warning{{duplicate nullability specifier '__nonnull'}} + +@property(nonnull,retain) NSFoo *property1; +@property(nullable,assign) NSFoo ** invalidProperty1; // expected-error{{nullability keyword 'nullable' cannot be applied to multi-level pointer type 'NSFoo **'}} +// expected-note@-1{{use nullability type specifier '__nullable' to affect the innermost pointer type of 'NSFoo **'}} +@property(null_unspecified,retain) NSFoo * __nullable conflictingProperty1; // expected-error{{nullability specifier '__nullable' conflicts with existing specifier '__null_unspecified'}} +@property(retain,nonnull) NSFoo * __nonnull redundantProperty1; // expected-warning{{duplicate nullability specifier '__nonnull'}} + +@property(null_unspecified,retain,nullable) NSFoo *conflictingProperty3; // expected-error{{nullability specifier 'nullable' conflicts with existing specifier 'null_unspecified'}} +@property(nullable,retain,nullable) NSFoo *redundantProperty3; // expected-warning{{duplicate nullability specifier 'nullable'}} +@end + +@interface NSBar () +@property(nonnull,retain) NSFoo *property2; +@property(nullable,assign) NSFoo ** invalidProperty2; // expected-error{{nullability keyword 'nullable' cannot be applied to multi-level pointer type 'NSFoo **'}} +// expected-note@-1{{use nullability type specifier '__nullable' to affect the innermost pointer type of 'NSFoo **'}} +@property(null_unspecified,retain) NSFoo * __nullable conflictingProperty2; // expected-error{{nullability specifier '__nullable' conflicts with existing specifier '__null_unspecified'}} +@property(retain,nonnull) NSFoo * __nonnull redundantProperty2; // expected-warning{{duplicate nullability specifier '__nonnull'}} +@end + +void test_accepts_nonnull_null_pointer_literal(NSFoo *foo, __nonnull NSBar *bar) { + [foo methodTakingIntPtr: 0]; // expected-warning{{null passed to a callee that requires a non-null argument}} + [bar methodWithFoo: 0]; // expected-warning{{null passed to a callee that requires a non-null argument}} + bar.property1 = 0; // expected-warning{{null passed to a callee that requires a non-null argument}} + bar.property2 = 0; // expected-warning{{null passed to a callee that requires a non-null argument}} + [bar setProperty1: 0]; // expected-warning{{null passed to a callee that requires a non-null argument}} + [bar setProperty2: 0]; // expected-warning{{null passed to a callee that requires a non-null argument}} + int *ptr = bar.property1; // expected-warning{{incompatible pointer types initializing 'int *' with an expression of type 'NSFoo * __nonnull'}} +} + +// Check returning nil from a nonnull-returning method. +@implementation NSBar +- (nonnull NSFoo *)methodWithFoo:(nonnull NSFoo *)foo { + return 0; // no warning +} + +- (NSFoo **)invalidMethod1 { + return 0; +} + +- (NSFoo *)conflictingMethod1 { + return 0; // no warning +} +- (NSFoo *)redundantMethod1 { + int *ip = 0; + return ip; // expected-warning{{result type 'NSFoo * __nonnull'}} +} +@end + +__attribute__((objc_root_class)) +@interface NSMerge +- (nonnull NSFoo *)methodA:(nonnull NSFoo*)foo; +- (nonnull NSFoo *)methodB:(nonnull NSFoo*)foo; +- (NSFoo *)methodC:(NSFoo*)foo; +@end + +@implementation NSMerge +- (NSFoo *)methodA:(NSFoo*)foo { + int *ptr = foo; // expected-warning{{incompatible pointer types initializing 'int *' with an expression of type 'NSFoo * __nonnull'}} + return ptr; // expected-warning{{result type 'NSFoo * __nonnull'}} +} + +- (nullable NSFoo *)methodB:(null_unspecified NSFoo*)foo { // expected-error{{nullability specifier 'nullable' conflicts with existing specifier 'nonnull'}} \ + // expected-error{{nullability specifier 'null_unspecified' conflicts with existing specifier 'nonnull'}} + return 0; +} + +- (nonnull NSFoo *)methodC:(nullable NSFoo*)foo { + int *ip = 0; + return ip; // expected-warning{{result type 'NSFoo * __nonnull'}} +} +@end + +// Checking merging of nullability when sending a message. +@interface NSMergeReceiver +- (id)returnsNone; +- (nonnull id)returnsNonNull; +- (nullable id)returnsNullable; +- (null_unspecified id)returnsNullUnspecified; +@end + +void test_receiver_merge(NSMergeReceiver *none, + __nonnull NSMergeReceiver *nonnull, + __nullable NSMergeReceiver *nullable, + __null_unspecified NSMergeReceiver *null_unspecified) { + int *ptr; + + ptr = [nullable returnsNullable]; // expected-warning{{'id __nullable'}} + ptr = [nullable returnsNullUnspecified]; // expected-warning{{'id __nullable'}} + ptr = [nullable returnsNonNull]; // expected-warning{{'id __nullable'}} + ptr = [nullable returnsNone]; // expected-warning{{'id __nullable'}} + + ptr = [null_unspecified returnsNullable]; // expected-warning{{'id __nullable'}} + ptr = [null_unspecified returnsNullUnspecified]; // expected-warning{{'id __null_unspecified'}} + ptr = [null_unspecified returnsNonNull]; // expected-warning{{'id __null_unspecified'}} + ptr = [null_unspecified returnsNone]; // expected-warning{{'id'}} + + ptr = [nonnull returnsNullable]; // expected-warning{{'id __nullable'}} + ptr = [nonnull returnsNullUnspecified]; // expected-warning{{'id __null_unspecified'}} + ptr = [nonnull returnsNonNull]; // expected-warning{{'id __nonnull'}} + ptr = [nonnull returnsNone]; // expected-warning{{'id'}} + + ptr = [none returnsNullable]; // expected-warning{{'id __nullable'}} + ptr = [none returnsNullUnspecified]; // expected-warning{{'id'}} + ptr = [none returnsNonNull]; // expected-warning{{'id'}} + ptr = [none returnsNone]; // expected-warning{{'id'}} + +} + +// instancetype +@protocol Initializable +- (instancetype)initWithBlah:(id)blah; +@end + +__attribute__((objc_root_class)) +@interface InitializableClass <Initializable> +- (nonnull instancetype)initWithBlah:(nonnull id)blah; +- (nullable instancetype)returnMe; ++ (nullable instancetype)returnInstanceOfMe; + +- (nonnull instancetype __nullable)initWithBlah2:(nonnull id)blah; // expected-error {{nullability specifier '__nullable' conflicts with existing specifier '__nonnull'}} +- (instancetype __nullable)returnMe2; ++ (__nonnull instancetype)returnInstanceOfMe2; +@end + +void test_instancetype(InitializableClass * __nonnull ic, id __nonnull object) { + int *ip = [ic returnMe]; // expected-warning{{incompatible pointer types initializing 'int *' with an expression of type 'InitializableClass * __nullable'}} + ip = [InitializableClass returnMe]; // expected-warning{{incompatible pointer types assigning to 'int *' from 'id __nullable'}} + ip = [InitializableClass returnInstanceOfMe]; // expected-warning{{incompatible pointer types assigning to 'int *' from 'InitializableClass * __nullable'}} + ip = [object returnMe]; // expected-warning{{incompatible pointer types assigning to 'int *' from 'id __nullable'}} + + ip = [ic returnMe2]; // expected-warning{{incompatible pointer types assigning to 'int *' from 'InitializableClass * __nullable'}} + ip = [InitializableClass returnInstanceOfMe2]; // expected-warning{{incompatible pointer types assigning to 'int *' from 'InitializableClass * __nonnull'}} +} + +// Check null_resettable getters/setters. +__attribute__((objc_root_class)) +@interface NSResettable +@property(null_resettable,retain) NSResettable *resettable1; // expected-note{{passing argument to parameter 'resettable1' here}} +@property(null_resettable,retain,nonatomic) NSResettable *resettable2; +@property(null_resettable,retain,nonatomic) NSResettable *resettable3; +@property(null_resettable,retain,nonatomic) NSResettable *resettable4; +@property(null_resettable,retain,nonatomic) NSResettable *resettable5; +@property(null_resettable,retain,nonatomic) NSResettable *resettable6; +@end + +void test_null_resettable(NSResettable *r, int *ip) { + [r setResettable1:ip]; // expected-warning{{incompatible pointer types sending 'int *' to parameter of type 'NSResettable * __nullable'}} + r.resettable1 = ip; // expected-warning{{incompatible pointer types assigning to 'NSResettable * __nullable' from 'int *'}} +} + +@implementation NSResettable // expected-warning{{synthesized setter 'setResettable4:' for null_resettable property 'resettable4' does not handle nil}} +- (NSResettable *)resettable1 { + int *ip = 0; + return ip; // expected-warning{{result type 'NSResettable * __nonnull'}} +} + +- (void)setResettable1:(NSResettable *)param { +} + +@synthesize resettable2; // no warning; not synthesized +@synthesize resettable3; // expected-warning{{synthesized setter 'setResettable3:' for null_resettable property 'resettable3' does not handle nil}} + +- (void)setResettable2:(NSResettable *)param { +} + +@dynamic resettable5; + +- (NSResettable *)resettable6 { + return 0; // no warning +} +@end + +// rdar://problem/19814852 +@interface MultiProp +@property (nullable, copy) id a, b, c; +@property (nullable, copy) MultiProp *d, *(^e)(int); +@end + +void testMultiProp(MultiProp *foo) { + int *ip; + ip = foo.a; // expected-warning{{from 'id __nullable'}} + ip = foo.d; // expected-warning{{from 'MultiProp * __nullable'}} + ip = foo.e; // expected-error{{incompatible type 'MultiProp *(^ __nullable)(int)'}} +} + +void testBlockLiterals() { + (void)(^id(void) { return 0; }); + (void)(^id __nullable (void) { return 0; }); + (void)(^ __nullable id(void) { return 0; }); + + int *x = (^ __nullable id(void) { return 0; })(); // expected-warning{{incompatible pointer types initializing 'int *' with an expression of type 'id __nullable'}} +} diff --git a/test/SemaObjC/nullable-weak-property.m b/test/SemaObjC/nullable-weak-property.m new file mode 100644 index 000000000000..617ff4ee5c62 --- /dev/null +++ b/test/SemaObjC/nullable-weak-property.m @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -fobjc-arc -fobjc-runtime-has-weak -Wnullable-to-nonnull-conversion %s -verify + + +// rdar://19985330 +@interface NSObject @end + +@class NSFoo; +void foo (NSFoo * __nonnull); + +@interface NSBar : NSObject +@property(weak) NSFoo *property1; +@end + +@implementation NSBar +- (void) Meth { + foo (self.property1); // expected-warning {{implicit conversion from nullable pointer 'NSFoo * __nullable' to non-nullable pointer type 'NSFoo * __nonnull'}} +} +@end diff --git a/test/SemaObjC/override-nullability.m b/test/SemaObjC/override-nullability.m new file mode 100644 index 000000000000..8e29f9152750 --- /dev/null +++ b/test/SemaObjC/override-nullability.m @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fobjc-arc -fobjc-runtime-has-weak -Wnonnull %s -verify +//rdar://19211059 + +@interface NSObject @end + +@interface Base : NSObject +- (nonnull id)bad:(nullable id)obj; // expected-note 2 {{previous declaration is here}} +- (nullable id)notAsBad:(nonnull id)obj; +@end + +@interface Sub : Base +- (nullable id)bad:(nonnull id)obj; // expected-warning {{conflicting nullability specifier on return types, 'nullable' conflicts with existing specifier 'nonnull'}} \ + // expected-warning {{conflicting nullability specifier on parameter types, 'nonnull' conflicts with existing specifier 'nullable'}} +- (nonnull id)notAsBad:(nullable id)obj; +@end diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-1.h b/test/SemaObjCXX/Inputs/nullability-consistency-1.h new file mode 100644 index 000000000000..4d6bf79f9a46 --- /dev/null +++ b/test/SemaObjCXX/Inputs/nullability-consistency-1.h @@ -0,0 +1,17 @@ +void f1(int *ptr); // expected-warning{{pointer is missing a nullability type specifier}} + +void f2(int * __nonnull); + +#include "nullability-consistency-2.h" + +void f3(int *ptr) { // expected-warning{{pointer is missing a nullability type specifier}} + int *other = ptr; // shouldn't warn +} + +class X { + void mf(int *ptr); // expected-warning{{pointer is missing a nullability type specifier}} + int X:: *memptr; // expected-warning{{member pointer is missing a nullability type specifier}} +}; + + + diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-2.h b/test/SemaObjCXX/Inputs/nullability-consistency-2.h new file mode 100644 index 000000000000..8efdfa8394e1 --- /dev/null +++ b/test/SemaObjCXX/Inputs/nullability-consistency-2.h @@ -0,0 +1,16 @@ +void g1(int * __nonnull); + +void g2(int (^block)(int, int)); // expected-warning{{block pointer is missing a nullability type specifier}} + +void g3(const + id // expected-warning{{missing a nullability type specifier}} + volatile + * // expected-warning{{missing a nullability type specifier}} + ); + +@interface SomeClass +@property (retain,nonnull) id property1; +@property (retain,nullable) SomeClass *property2; +- (nullable SomeClass *)method1; +- (void)method2:(nonnull SomeClass *)param; +@end diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-3.h b/test/SemaObjCXX/Inputs/nullability-consistency-3.h new file mode 100644 index 000000000000..a0c0d381bb8e --- /dev/null +++ b/test/SemaObjCXX/Inputs/nullability-consistency-3.h @@ -0,0 +1 @@ +void double_declarator1(int *__nonnull *); // expected-warning{{pointer is missing a nullability type specifier (__nonnull, __nullable, or __null_unspecified)}} diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-4.h b/test/SemaObjCXX/Inputs/nullability-consistency-4.h new file mode 100644 index 000000000000..984280c17ebe --- /dev/null +++ b/test/SemaObjCXX/Inputs/nullability-consistency-4.h @@ -0,0 +1 @@ +void double_declarator1(int * * __nonnull); // expected-warning{{pointer is missing a nullability type specifier (__nonnull, __nullable, or __null_unspecified)}} diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-5.h b/test/SemaObjCXX/Inputs/nullability-consistency-5.h new file mode 100644 index 000000000000..3a685af614ef --- /dev/null +++ b/test/SemaObjCXX/Inputs/nullability-consistency-5.h @@ -0,0 +1,14 @@ +#define SUPPRESS_NULLABILITY_WARNING(Type) \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Wnullability-completeness\"") \ + Type \ + _Pragma("clang diagnostic pop") + +void suppress1(SUPPRESS_NULLABILITY_WARNING(int *) ptr); // no warning + +void shouldwarn5(int *ptr); //expected-warning{{missing a nullability type specifier}} + +void trigger5(int * __nonnull); + +void suppress2(SUPPRESS_NULLABILITY_WARNING(int *) ptr); // no warning + diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-6.h b/test/SemaObjCXX/Inputs/nullability-consistency-6.h new file mode 100644 index 000000000000..cb712e94c661 --- /dev/null +++ b/test/SemaObjCXX/Inputs/nullability-consistency-6.h @@ -0,0 +1,8 @@ +int *ptr; // expected-warning {{missing a nullability type specifier}} + +#pragma clang assume_nonnull begin + +extern void **blah; // expected-warning 2{{missing a nullability type specifier}} + +#pragma clang assume_nonnull end + diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-7.h b/test/SemaObjCXX/Inputs/nullability-consistency-7.h new file mode 100644 index 000000000000..ddbdfada7991 --- /dev/null +++ b/test/SemaObjCXX/Inputs/nullability-consistency-7.h @@ -0,0 +1,40 @@ +#ifndef SOMEKIT_H +#define SOMEKIT_H + +__attribute__((objc_root_class)) +#ifndef NS_ASSUME_NONNULL_BEGIN +#if __has_feature(assume_nonnull) +#define NS_ASSUME_NONNULL_BEGIN _Pragma("clang assume_nonnull begin") +#define NS_ASSUME_NONNULL_END _Pragma("clang assume_nonnull end") +#else +#define NS_ASSUME_NONNULL_BEGIN +#define NS_ASSUME_NONNULL_END +#endif +#endif + +NS_ASSUME_NONNULL_BEGIN + +@interface A +-(null_unspecified A*)transform:(null_unspecified A*)input __attribute__((unavailable("anything but this"))); +-(A*)transform:(A*)input integer:(int)integer; + +@property (null_unspecified, nonatomic, readonly, retain) A* someA; +@property (null_unspecified, nonatomic, retain) A* someOtherA; + +@property (nonatomic) int intValue __attribute__((unavailable("wouldn't work anyway"))); +@end + +NS_ASSUME_NONNULL_END + + +__attribute__((unavailable("just don't"))) +@interface B : A +@end + +@interface C : A +- (instancetype)init; // expected-warning{{pointer is missing a nullability type specifier}} +- (instancetype)initWithA:( A*)a __attribute__((objc_designated_initializer)); // expected-warning 2{{pointer is missing a nullability type specifier}} +@end + +#endif + diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-8.h b/test/SemaObjCXX/Inputs/nullability-consistency-8.h new file mode 100644 index 000000000000..890bb4db5465 --- /dev/null +++ b/test/SemaObjCXX/Inputs/nullability-consistency-8.h @@ -0,0 +1,27 @@ +typedef int* __nonnull mynonnull; + +__attribute__((objc_root_class)) +@interface typedefClass +- (void) func1:(mynonnull)i; +@end + +void func2(mynonnull i); + +void func3(int *); // expected-warning{{pointer is missing a nullability type specifier}} + +#define CF_RETURNS_NOT_RETAINED __attribute__((cf_returns_not_retained)) +typedef void *CFTypeRef; +void cf1(CFTypeRef * p CF_RETURNS_NOT_RETAINED); // expected-warning {{pointer is missing a nullability type specifier}} + +void cf2(CFTypeRef * __nullable p CF_RETURNS_NOT_RETAINED); +void cf3(CFTypeRef * __nonnull p CF_RETURNS_NOT_RETAINED); + +void cf4(CFTypeRef __nullable * __nullable p CF_RETURNS_NOT_RETAINED); +void cf5(CFTypeRef __nonnull * __nullable p CF_RETURNS_NOT_RETAINED); + +void cf6(CFTypeRef * __nullable CF_RETURNS_NOT_RETAINED p); +void cf7(CF_RETURNS_NOT_RETAINED CFTypeRef * __nonnull p); + +typedef CFTypeRef __nullable *CFTypeRefPtr; +void cfp1(CFTypeRefPtr p CF_RETURNS_NOT_RETAINED); // expected-warning {{pointer is missing a nullability type specifier}} +void cfp2(CFTypeRefPtr __nonnull p CF_RETURNS_NOT_RETAINED); diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-system/nullability-consistency-system.h b/test/SemaObjCXX/Inputs/nullability-consistency-system/nullability-consistency-system.h new file mode 100644 index 000000000000..6dbca1663d5a --- /dev/null +++ b/test/SemaObjCXX/Inputs/nullability-consistency-system/nullability-consistency-system.h @@ -0,0 +1,8 @@ +// Simply marking this as "#pragma clang system_header" didn't tickle the bug, rdar://problem/21134250. + +void system1(int *ptr); +#if WARN_IN_SYSTEM_HEADERS +// expected-warning@-2{{pointer is missing a nullability type specifier}} +#endif + +void system2(int * __nonnull); diff --git a/test/SemaObjCXX/Inputs/nullability-pragmas-1.h b/test/SemaObjCXX/Inputs/nullability-pragmas-1.h new file mode 100644 index 000000000000..950111692419 --- /dev/null +++ b/test/SemaObjCXX/Inputs/nullability-pragmas-1.h @@ -0,0 +1,101 @@ +__attribute__((objc_root_class)) +@interface NSError +@end + +__attribute__((objc_root_class)) +@interface A +@end + +struct X { }; + +void f1(int *x); // expected-warning{{pointer is missing a nullability type specifier}} + +typedef struct __attribute__((objc_bridge(NSError))) __CFError *CFErrorRef; +typedef NSError *NSErrorPtr; +typedef NSError **NSErrorPtrPtr; +typedef CFErrorRef *CFErrorRefPtr; +typedef int *int_ptr; +typedef A *A_ptr; +typedef int (^block_ptr)(int, int); + +#pragma clang assume_nonnull begin + +void f2(int *x); +void f3(A* obj); +void f4(int (^block)(int, int)); +void f5(int_ptr x); +void f6(A_ptr obj); +void f7(int * __nullable x); +void f8(A * __nullable obj); +void f9(int X::* mem_ptr); +void f10(int (X::*mem_func)(int, int)); +void f11(int X::* __nullable mem_ptr); +void f12(int (X::* __nullable mem_func)(int, int)); + +int_ptr f13(void); +A *f14(void); + +int * __null_unspecified f15(void); +A * __null_unspecified f16(void); +void f17(CFErrorRef *error); // expected-note{{no known conversion from 'A * __nonnull' to 'CFErrorRef __nullable * __nullable' (aka '__CFError **') for 1st argument}} +void f18(A **); // expected-warning 2{{pointer is missing a nullability type specifier}} +void f19(CFErrorRefPtr error); // expected-warning{{pointer is missing a nullability type specifier}} + +void g1(int (^)(int, int)); +void g2(int (^ *bp)(int, int)); // expected-warning{{block pointer is missing a nullability type specifier}} +// expected-warning@-1{{pointer is missing a nullability type specifier}} +void g3(block_ptr *bp); // expected-warning{{block pointer is missing a nullability type specifier}} +// expected-warning@-1{{pointer is missing a nullability type specifier}} +void g4(int (*fp)(int, int)); +void g5(int (**fp)(int, int)); // expected-warning 2{{pointer is missing a nullability type specifier}} + +@interface A(Pragmas1) ++ (instancetype)aWithA:(A *)a; +- (A *)method1:(A_ptr)ptr; +- (null_unspecified A *)method2; +- (void)method3:(NSError **)error; // expected-note{{passing argument to parameter 'error' here}} +- (void)method4:(NSErrorPtr *)error; // expected-note{{passing argument to parameter 'error' here}} +- (void)method5:(NSErrorPtrPtr)error; +// expected-warning@-1{{pointer is missing a nullability type specifier}} + +@property A *aProp; +@property NSError **anError; // expected-warning 2{{pointer is missing a nullability type specifier}} +@end + +int *global_int_ptr; + +// typedefs not inferred __nonnull +typedef int *int_ptr_2; + +typedef int * // expected-warning{{pointer is missing a nullability type specifier}} + *int_ptr_ptr; + +static inline void f30(void) { + float *fp = global_int_ptr; // expected-error{{cannot initialize a variable of type 'float *' with an lvalue of type 'int * __nonnull'}} + + int_ptr_2 ip2; + float *fp2 = ip2; // expected-error{{cannot initialize a variable of type 'float *' with an lvalue of type 'int_ptr_2' (aka 'int *')}} + + int_ptr_ptr ipp; + float *fp3 = ipp; // expected-error{{lvalue of type 'int_ptr_ptr' (aka 'int **')}} +} + +@interface AA : A { +@public + id ivar1; + __nonnull id ivar2; +} +@end + +#pragma clang assume_nonnull end + +void f20(A *a); // expected-warning{{pointer is missing a nullability type specifier}} +void f21(int_ptr x); // expected-warning{{pointer is missing a nullability type specifier}} +void f22(A_ptr y); // expected-warning{{pointer is missing a nullability type specifier}} +void f23(int_ptr __nullable x); +void f24(A_ptr __nullable y); +void f25(int_ptr_2 x); // expected-warning{{pointer is missing a nullability type specifier}} + +@interface A(OutsidePragmas1) ++ (instancetype)aWithInt:(int)value; // expected-warning{{pointer is missing a nullability type specifier}} +@end diff --git a/test/SemaObjCXX/Inputs/nullability-pragmas-2.h b/test/SemaObjCXX/Inputs/nullability-pragmas-2.h new file mode 100644 index 000000000000..da3d21de6962 --- /dev/null +++ b/test/SemaObjCXX/Inputs/nullability-pragmas-2.h @@ -0,0 +1,12 @@ +#pragma clang assume_nonnull start // expected-error{{expected 'begin' or 'end'}} + +#pragma clang assume_nonnull begin // expected-note{{#pragma entered here}} + +#include "nullability-pragmas-3.h" // expected-error{{cannot #include files inside '#pragma clang assume_nonnull'}} + +#pragma clang assume_nonnull begin // expected-note{{#pragma entered here}} +#pragma clang assume_nonnull begin // expected-error{{already inside '#pragma clang assume_nonnull'}} +#pragma clang assume_nonnull end + +#pragma clang assume_nonnull begin // expected-error{{'#pragma clang assume_nonnull' was not ended within this file}} + diff --git a/test/SemaObjCXX/Inputs/nullability-pragmas-3.h b/test/SemaObjCXX/Inputs/nullability-pragmas-3.h new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/SemaObjCXX/Inputs/nullability-pragmas-3.h diff --git a/test/SemaObjCXX/nullability-consistency.mm b/test/SemaObjCXX/nullability-consistency.mm new file mode 100644 index 000000000000..acb972da0b85 --- /dev/null +++ b/test/SemaObjCXX/nullability-consistency.mm @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -fblocks -I %S/Inputs -isystem %S/Inputs/nullability-consistency-system %s -verify +// RUN: %clang_cc1 -fsyntax-only -fblocks -I %S/Inputs -isystem %S/Inputs/nullability-consistency-system %s -Wsystem-headers -DWARN_IN_SYSTEM_HEADERS -verify + +#include "nullability-consistency-1.h" +#include "nullability-consistency-3.h" +#include "nullability-consistency-4.h" +#include "nullability-consistency-5.h" +#include "nullability-consistency-5.h" +#include "nullability-consistency-6.h" +#include "nullability-consistency-7.h" +#include "nullability-consistency-8.h" +#include "nullability-consistency-system.h" + +void h1(int *ptr) { } // don't warn + +void h2(int * __nonnull) { } diff --git a/test/SemaObjCXX/nullability-pragmas.mm b/test/SemaObjCXX/nullability-pragmas.mm new file mode 100644 index 000000000000..0c61a30b333f --- /dev/null +++ b/test/SemaObjCXX/nullability-pragmas.mm @@ -0,0 +1,41 @@ +// RUN: %clang_cc1 -fsyntax-only -fblocks -I %S/Inputs %s -verify + +#include "nullability-pragmas-1.h" +#include "nullability-pragmas-2.h" + +#if !__has_feature(assume_nonnull) +# error assume_nonnull feature is not set +#endif + +void test_pragmas_1(A * __nonnull a, AA * __nonnull aa) { + f1(0); // okay: no nullability annotations + f2(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + f3(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + f4(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + f5(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + f6(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + f7(0); // okay + f8(0); // okay + f9(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + f10(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + f11(0); // okay + f12(0); // okay + [a method1:0]; // expected-warning{{null passed to a callee that requires a non-null argument}} + + f17(a); // expected-error{{no matching function for call to 'f17'}} + [a method3: a]; // expected-error{{cannot initialize a parameter of type 'NSError * __nullable * __nullable' with an lvalue of type 'A * __nonnull'}} + [a method4: a]; // expected-error{{cannot initialize a parameter of type 'NSErrorPtr __nullable * __nullable' (aka 'NSError **') with an lvalue of type 'A * __nonnull'}} + + float *ptr; + ptr = f13(); // expected-error{{assigning to 'float *' from incompatible type 'int_ptr __nonnull' (aka 'int *')}} + ptr = f14(); // expected-error{{assigning to 'float *' from incompatible type 'A * __nonnull'}} + ptr = [a method1:a]; // expected-error{{assigning to 'float *' from incompatible type 'A * __nonnull'}} + ptr = a.aProp; // expected-error{{assigning to 'float *' from incompatible type 'A * __nonnull'}} + ptr = global_int_ptr; // expected-error{{assigning to 'float *' from incompatible type 'int * __nonnull'}} + ptr = f15(); // expected-error{{assigning to 'float *' from incompatible type 'int * __null_unspecified'}} + ptr = f16(); // expected-error{{assigning to 'float *' from incompatible type 'A * __null_unspecified'}} + ptr = [a method2]; // expected-error{{assigning to 'float *' from incompatible type 'A * __null_unspecified'}} + + ptr = aa->ivar1; // expected-error{{from incompatible type 'id'}} + ptr = aa->ivar2; // expected-error{{from incompatible type 'id __nonnull'}} +} diff --git a/test/SemaTemplate/ms-lookup-template-base-classes.cpp b/test/SemaTemplate/ms-lookup-template-base-classes.cpp index 62451081c3bc..9fa59e626ee7 100644 --- a/test/SemaTemplate/ms-lookup-template-base-classes.cpp +++ b/test/SemaTemplate/ms-lookup-template-base-classes.cpp @@ -547,3 +547,29 @@ struct E : D<T> XXX x; // expected-error {{unknown type name}} }; } + +namespace PR23810 { +void f(int); +struct Base { + void f(); // expected-note{{must qualify identifier to find this declaration in dependent base class}} +}; +template <typename T> struct Template : T { + void member() { + f(); // expected-warning {{found via unqualified lookup into dependent bases}} + } +}; +void test() { + Template<Base> x; + x.member(); // expected-note{{requested here}} +}; +} + +namespace PR23823 { +// Don't delay lookup in SFINAE context. +template <typename T> decltype(g(T())) check(); // expected-note{{candidate template ignored: substitution failure [with T = int]: use of undeclared identifier 'g'}} +decltype(check<int>()) x; // expected-error{{no matching function for call to 'check'}} + +void h(); +template <typename T> decltype(h(T())) check2(); // expected-note{{candidate template ignored: substitution failure [with T = int]: no matching function for call to 'h'}} +decltype(check2<int>()) y; // expected-error{{no matching function for call to 'check2'}} +} diff --git a/test/VFS/incomplete-umbrella.m b/test/VFS/incomplete-umbrella.m index 4e138cc0f338..ee663376fa56 100644 --- a/test/VFS/incomplete-umbrella.m +++ b/test/VFS/incomplete-umbrella.m @@ -2,7 +2,7 @@ // RUN: mkdir -p %t/Incomplete.framework/Headers // RUN: echo '// IncompleteReal.h' > %t/Incomplete.framework/Headers/IncompleteReal.h // RUN: sed -e "s:INPUT_DIR:%S/Inputs:g" -e "s:OUT_DIR:%t:g" %S/Inputs/vfsoverlay.yaml > %t.yaml -// RUN: not %clang_cc1 -Werror -fmodules -fmodules-cache-path=%t \ +// RUN: not %clang_cc1 -Werror -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \ // RUN: -ivfsoverlay %t.yaml -F %t -fsyntax-only %s 2>&1 | FileCheck %s // REQUIRES: shell diff --git a/test/VFS/module-import.m b/test/VFS/module-import.m index d2adcfedfaa8..a0bfa4c1a256 100644 --- a/test/VFS/module-import.m +++ b/test/VFS/module-import.m @@ -1,6 +1,6 @@ // RUN: rm -rf %t // RUN: sed -e "s:INPUT_DIR:%S/Inputs:g" -e "s:OUT_DIR:%t:g" %S/Inputs/vfsoverlay.yaml > %t.yaml -// RUN: %clang_cc1 -Werror -fmodules -fmodules-cache-path=%t -ivfsoverlay %t.yaml -I %t -fsyntax-only %s +// RUN: %clang_cc1 -Werror -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ivfsoverlay %t.yaml -I %t -fsyntax-only %s // REQUIRES: shell @import not_real; @@ -18,10 +18,10 @@ void foo() { // Override the module map (vfsoverlay2 on top) // RUN: sed -e "s:INPUT_DIR:%S/Inputs:g" -e "s:OUT_DIR:%t:g" %S/Inputs/vfsoverlay2.yaml > %t2.yaml -// RUN: %clang_cc1 -Werror -fmodules -fmodules-cache-path=%t -ivfsoverlay %t.yaml -ivfsoverlay %t2.yaml -I %t -fsyntax-only %s +// RUN: %clang_cc1 -Werror -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ivfsoverlay %t.yaml -ivfsoverlay %t2.yaml -I %t -fsyntax-only %s // vfsoverlay2 not present -// RUN: not %clang_cc1 -Werror -fmodules -fmodules-cache-path=%t -ivfsoverlay %t.yaml -I %t -fsyntax-only %s -DIMPORT2 2>&1 | FileCheck -check-prefix=CHECK-VFS2 %s +// RUN: not %clang_cc1 -Werror -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ivfsoverlay %t.yaml -I %t -fsyntax-only %s -DIMPORT2 2>&1 | FileCheck -check-prefix=CHECK-VFS2 %s // vfsoverlay2 on the bottom -// RUN: not %clang_cc1 -Werror -fmodules -fmodules-cache-path=%t -ivfsoverlay %t2.yaml -ivfsoverlay %t.yaml -I %t -fsyntax-only %s -DIMPORT2 2>&1 | FileCheck -check-prefix=CHECK-VFS2 %s +// RUN: not %clang_cc1 -Werror -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ivfsoverlay %t2.yaml -ivfsoverlay %t.yaml -I %t -fsyntax-only %s -DIMPORT2 2>&1 | FileCheck -check-prefix=CHECK-VFS2 %s diff --git a/test/VFS/real-path-found-first.m b/test/VFS/real-path-found-first.m index f494c6eb1534..3b37a644bcbd 100644 --- a/test/VFS/real-path-found-first.m +++ b/test/VFS/real-path-found-first.m @@ -11,32 +11,32 @@ // RUN: sed -e "s:INPUT_DIR:%S/Inputs:g" -e "s:OUT_DIR:%t:g" %S/Inputs/vfsoverlay.yaml > %t.yaml // Build -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t-cache -F %t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \ // RUN: -ivfsoverlay %t.yaml -fsyntax-only %s -verify -Wauto-import \ // RUN: -Werror=non-modular-include-in-framework-module // Rebuild // RUN: echo ' ' >> %t/SomeFramework.framework/Modules/module.modulemap -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t-cache -F %t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \ // RUN: -ivfsoverlay %t.yaml -fsyntax-only %s -verify -Wauto-import \ // RUN: -Werror=non-modular-include-in-framework-module // Load from PCH -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t-cache -F %t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \ // RUN: -ivfsoverlay %t.yaml -emit-pch %s -o %t.pch \ // RUN: -Werror=non-modular-include-in-framework-module \ // RUN: -fmodules-ignore-macro=WITH_PREFIX -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t-cache -F %t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \ // RUN: -ivfsoverlay %t.yaml -include-pch %t.pch -fsyntax-only %s \ // RUN: -Werror=non-modular-include-in-framework-module -DWITH_PREFIX \ // RUN: -fmodules-ignore-macro=WITH_PREFIX // While indexing -// RUN: c-index-test -index-file %s -fmodules -fmodules-cache-path=%t-cache -F %t \ +// RUN: c-index-test -index-file %s -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \ // RUN: -ivfsoverlay %t.yaml -fsyntax-only -Wauto-import \ // RUN: -Werror=non-modular-include-in-framework-module | FileCheck %s // RUN: echo ' ' >> %t/SomeFramework.framework/Modules/module.modulemap -// RUN: c-index-test -index-file %s -fmodules -fmodules-cache-path=%t-cache -F %t \ +// RUN: c-index-test -index-file %s -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \ // RUN: -ivfsoverlay %t.yaml -fsyntax-only -Wauto-import \ // RUN: -Werror=non-modular-include-in-framework-module | FileCheck %s // CHECK: warning: treating @@ -48,22 +48,22 @@ // RUN: echo "'name': '%t/SomeFramework.framework/Modules/module.modulemap'," >> %t2.yaml // RUN: echo "'type': 'file', 'external-contents': '%t/hide_module.map' } ] }" >> %t2.yaml -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t-cache -F %t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \ // RUN: -ivfsoverlay %t.yaml -ivfsoverlay %t2.yaml -fsyntax-only %s -verify \ // RUN: -Wauto-import -Werror=non-modular-include-in-framework-module // RUN: echo ' ' >> %t/hide_module.map -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t-cache -F %t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \ // RUN: -ivfsoverlay %t.yaml -ivfsoverlay %t2.yaml -fsyntax-only %s -verify \ // RUN: -Wauto-import -Werror=non-modular-include-in-framework-module // Within a module build // RUN: echo '@import import_some_frame;' | \ -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t-cache -F %t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \ // RUN: -ivfsoverlay %t.yaml -ivfsoverlay %t2.yaml -fsyntax-only - \ // RUN: -Werror=non-modular-include-in-framework-module -x objective-c -I %t // RUN: echo ' ' >> %t/hide_module.map // RUN: echo '@import import_some_frame;' | \ -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t-cache -F %t \ +// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \ // RUN: -ivfsoverlay %t.yaml -ivfsoverlay %t2.yaml -fsyntax-only - \ // RUN: -Werror=non-modular-include-in-framework-module -x objective-c -I %t diff --git a/test/VFS/umbrella-mismatch.m b/test/VFS/umbrella-mismatch.m index 741b0e693088..fc5180241619 100644 --- a/test/VFS/umbrella-mismatch.m +++ b/test/VFS/umbrella-mismatch.m @@ -1,7 +1,7 @@ // RUN: rm -rf %t // RUN: sed -e "s;INPUT_DIR;%/S/Inputs;g" -e "s;OUT_DIR;%/S/Inputs;g" %S/Inputs/vfsoverlay.yaml > %t.yaml -// RUN: %clang_cc1 -Werror -fmodules -fmodules-cache-path=%t -ivfsoverlay %t.yaml -F %S/Inputs -fsyntax-only %s -verify -// RUN: %clang_cc1 -Werror -fmodules -fmodules-cache-path=%t -F %S/Inputs -fsyntax-only %s -verify +// RUN: %clang_cc1 -Werror -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ivfsoverlay %t.yaml -F %S/Inputs -fsyntax-only %s -verify +// RUN: %clang_cc1 -Werror -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -F %S/Inputs -fsyntax-only %s -verify // expected-no-diagnostics @import UsesFoo; diff --git a/tools/arcmt-test/arcmt-test.cpp b/tools/arcmt-test/arcmt-test.cpp index 7be4ed6e2a21..c269e017f759 100644 --- a/tools/arcmt-test/arcmt-test.cpp +++ b/tools/arcmt-test/arcmt-test.cpp @@ -7,6 +7,7 @@ // //===----------------------------------------------------------------------===// +#include "clang/Frontend/PCHContainerOperations.h" #include "clang/ARCMigrate/ARCMT.h" #include "clang/Frontend/ASTUnit.h" #include "clang/Frontend/TextDiagnosticPrinter.h" @@ -130,7 +131,8 @@ static bool checkForMigration(StringRef resourcesPath, if (!CI.getLangOpts()->ObjC1) return false; - arcmt::checkForManualIssues(CI, CI.getFrontendOpts().Inputs[0], + arcmt::checkForManualIssues(CI, CI.getFrontendOpts().Inputs[0], + std::make_shared<RawPCHContainerOperations>(), Diags->getClient()); return Diags->getClient()->getNumErrors() > 0; } @@ -169,7 +171,8 @@ static bool performTransformations(StringRef resourcesPath, if (!origCI.getLangOpts()->ObjC1) return false; - MigrationProcess migration(origCI, DiagClient); + MigrationProcess migration( + origCI, std::make_shared<RawPCHContainerOperations>(), DiagClient); std::vector<TransformFn> transforms = arcmt::getAllTransformations(origCI.getLangOpts()->getGC(), diff --git a/tools/c-index-test/c-index-test.c b/tools/c-index-test/c-index-test.c index 56f39c2e12cb..980f341824fa 100644 --- a/tools/c-index-test/c-index-test.c +++ b/tools/c-index-test/c-index-test.c @@ -2101,7 +2101,7 @@ int perform_code_completion(int argc, const char **argv, int timing_only) { clang_defaultReparseOptions(TU)); if (Err != CXError_Success) { - fprintf(stderr, "Unable to reparse translation init!\n"); + fprintf(stderr, "Unable to reparse translation unit!\n"); describeLibclangFailure(Err); clang_disposeTranslationUnit(TU); return 1; diff --git a/tools/clang-format/git-clang-format b/tools/clang-format/git-clang-format index 6a0db27fa9f6..0c45762ea515 100755 --- a/tools/clang-format/git-clang-format +++ b/tools/clang-format/git-clang-format @@ -78,6 +78,7 @@ def main(): # Other languages that clang-format supports 'proto', 'protodevel', # Protocol Buffers 'js', # JavaScript + 'ts', # TypeScript ]) p = argparse.ArgumentParser( diff --git a/tools/driver/cc1_main.cpp b/tools/driver/cc1_main.cpp index fa1a10e96356..972bf5bf3e10 100644 --- a/tools/driver/cc1_main.cpp +++ b/tools/driver/cc1_main.cpp @@ -14,6 +14,7 @@ //===----------------------------------------------------------------------===// #include "llvm/Option/Arg.h" +#include "clang/Frontend/PCHContainerOperations.h" #include "clang/Driver/DriverDiagnostic.h" #include "clang/Driver/Options.h" #include "clang/Frontend/CompilerInstance.h" @@ -64,7 +65,8 @@ void initializePollyPasses(llvm::PassRegistry &Registry); #endif int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) { - std::unique_ptr<CompilerInstance> Clang(new CompilerInstance()); + std::unique_ptr<CompilerInstance> Clang( + new CompilerInstance(std::make_shared<RawPCHContainerOperations>())); IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); // Initialize targets first, so that --version shows registered targets. diff --git a/tools/driver/cc1as_main.cpp b/tools/driver/cc1as_main.cpp index f73d07bd0be9..f7ac17f14301 100644 --- a/tools/driver/cc1as_main.cpp +++ b/tools/driver/cc1as_main.cpp @@ -323,8 +323,8 @@ static bool ExecuteAssembler(AssemblerInvocation &Opts, MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr); // FIXME: Assembler behavior can change with -static. - MOFI->InitMCObjectFileInfo(Opts.Triple, - Reloc::Default, CodeModel::Default, Ctx); + MOFI->InitMCObjectFileInfo(Triple(Opts.Triple), Reloc::Default, + CodeModel::Default, Ctx); if (Opts.SaveTemporaryLabels) Ctx.setAllowTemporaryLabels(false); if (Opts.GenDwarfForAssembly) diff --git a/tools/driver/driver.cpp b/tools/driver/driver.cpp index e1f9367b0f5c..ff81b8ac401c 100644 --- a/tools/driver/driver.cpp +++ b/tools/driver/driver.cpp @@ -43,6 +43,7 @@ #include "llvm/Support/Program.h" #include "llvm/Support/Regex.h" #include "llvm/Support/Signals.h" +#include "llvm/Support/StringSaver.h" #include "llvm/Support/TargetRegistry.h" #include "llvm/Support/TargetSelect.h" #include "llvm/Support/Timer.h" @@ -290,18 +291,6 @@ static void ParseProgName(SmallVectorImpl<const char *> &ArgVector, } } -namespace { - class StringSetSaver : public llvm::cl::StringSaver { - public: - StringSetSaver(std::set<std::string> &Storage) : Storage(Storage) {} - const char *SaveString(const char *Str) override { - return GetStableCStr(Storage, Str); - } - private: - std::set<std::string> &Storage; - }; -} - static void SetBackdoorDriverOutputsFromEnvVars(Driver &TheDriver) { // Handle CC_PRINT_OPTIONS and CC_PRINT_OPTIONS_FILE. TheDriver.CCPrintOptions = !!::getenv("CC_PRINT_OPTIONS"); @@ -391,8 +380,8 @@ int main(int argc_, const char **argv_) { return 1; } - std::set<std::string> SavedStrings; - StringSetSaver Saver(SavedStrings); + llvm::BumpPtrAllocator A; + llvm::BumpPtrStringSaver Saver(A); // Determines whether we want nullptr markers in argv to indicate response // files end-of-lines. We only use this for the /LINK driver argument. @@ -426,6 +415,7 @@ int main(int argc_, const char **argv_) { } } + std::set<std::string> SavedStrings; // Handle CCC_OVERRIDE_OPTIONS, used for editing a command line behind the // scenes. if (const char *OverrideStr = ::getenv("CCC_OVERRIDE_OPTIONS")) { diff --git a/tools/libclang/ARCMigrate.cpp b/tools/libclang/ARCMigrate.cpp index b0b869ba900b..b597383dfd2b 100644 --- a/tools/libclang/ARCMigrate.cpp +++ b/tools/libclang/ARCMigrate.cpp @@ -101,9 +101,7 @@ CXRemapping clang_getRemappingsFromFileList(const char **filePaths, } TextDiagnosticBuffer diagBuffer; - SmallVector<StringRef, 32> Files; - for (unsigned i = 0; i != numFiles; ++i) - Files.push_back(filePaths[i]); + SmallVector<StringRef, 32> Files(filePaths, filePaths + numFiles); bool err = arcmt::getFileRemappingsFromFileList(remap->Vec, Files, &diagBuffer); diff --git a/tools/libclang/CIndex.cpp b/tools/libclang/CIndex.cpp index 05287bd856e8..2216ec61afa7 100644 --- a/tools/libclang/CIndex.cpp +++ b/tools/libclang/CIndex.cpp @@ -1879,6 +1879,7 @@ public: void VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D); void VisitOMPBarrierDirective(const OMPBarrierDirective *D); void VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D); + void VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *D); void VisitOMPFlushDirective(const OMPFlushDirective *D); void VisitOMPOrderedDirective(const OMPOrderedDirective *D); void VisitOMPAtomicDirective(const OMPAtomicDirective *D); @@ -2478,6 +2479,11 @@ void EnqueueVisitor::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D) { VisitOMPExecutableDirective(D); } +void EnqueueVisitor::VisitOMPTaskgroupDirective( + const OMPTaskgroupDirective *D) { + VisitOMPExecutableDirective(D); +} + void EnqueueVisitor::VisitOMPFlushDirective(const OMPFlushDirective *D) { VisitOMPExecutableDirective(D); } @@ -2883,7 +2889,8 @@ enum CXErrorCode clang_createTranslationUnit2(CXIndex CIdx, IntrusiveRefCntPtr<DiagnosticsEngine> Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions()); std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile( - ast_filename, Diags, FileSystemOpts, CXXIdx->getOnlyLocalDecls(), None, + ast_filename, CXXIdx->getPCHContainerOperations(), Diags, FileSystemOpts, + CXXIdx->getOnlyLocalDecls(), None, /*CaptureDiagnostics=*/true, /*AllowPCHWithCompilerErrors=*/true, /*UserFilesAreVolatile=*/true); @@ -3021,7 +3028,8 @@ static void clang_parseTranslationUnit_Impl(void *UserData) { unsigned NumErrors = Diags->getClient()->getNumErrors(); std::unique_ptr<ASTUnit> ErrUnit; std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine( - Args->data(), Args->data() + Args->size(), Diags, + Args->data(), Args->data() + Args->size(), + CXXIdx->getPCHContainerOperations(), Diags, CXXIdx->getClangResourcesPath(), CXXIdx->getOnlyLocalDecls(), /*CaptureDiagnostics=*/true, *RemappedFiles.get(), /*RemappedFilesKeepOriginalName=*/true, PrecompilePreamble, TUKind, @@ -3262,7 +3270,8 @@ static void clang_reparseTranslationUnit_Impl(void *UserData) { RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release())); } - if (!CXXUnit->Reparse(*RemappedFiles.get())) + if (!CXXUnit->Reparse(CXXIdx->getPCHContainerOperations(), + *RemappedFiles.get())) RTUI->result = CXError_Success; else if (isASTReadError(CXXUnit)) RTUI->result = CXError_ASTReadError; @@ -4260,6 +4269,8 @@ CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) { return cxstring::createRef("OMPBarrierDirective"); case CXCursor_OMPTaskwaitDirective: return cxstring::createRef("OMPTaskwaitDirective"); + case CXCursor_OMPTaskgroupDirective: + return cxstring::createRef("OMPTaskgroupDirective"); case CXCursor_OMPFlushDirective: return cxstring::createRef("OMPFlushDirective"); case CXCursor_OMPOrderedDirective: diff --git a/tools/libclang/CIndexCodeCompletion.cpp b/tools/libclang/CIndexCodeCompletion.cpp index ca167e8b2e70..a7b8e292047b 100644 --- a/tools/libclang/CIndexCodeCompletion.cpp +++ b/tools/libclang/CIndexCodeCompletion.cpp @@ -715,14 +715,12 @@ static void clang_codeCompleteAt_Impl(void *UserData) { // Perform completion. AST->CodeComplete(complete_filename, complete_line, complete_column, - RemappedFiles, - (options & CXCodeComplete_IncludeMacros), + RemappedFiles, (options & CXCodeComplete_IncludeMacros), (options & CXCodeComplete_IncludeCodePatterns), - IncludeBriefComments, - Capture, - *Results->Diag, Results->LangOpts, *Results->SourceMgr, - *Results->FileMgr, Results->Diagnostics, - Results->TemporaryBuffers); + IncludeBriefComments, Capture, + CXXIdx->getPCHContainerOperations(), *Results->Diag, + Results->LangOpts, *Results->SourceMgr, *Results->FileMgr, + Results->Diagnostics, Results->TemporaryBuffers); Results->DiagnosticsWrappers.resize(Results->Diagnostics.size()); diff --git a/tools/libclang/CIndexer.h b/tools/libclang/CIndexer.h index cb7c62e4b565..8a306cde67ca 100644 --- a/tools/libclang/CIndexer.h +++ b/tools/libclang/CIndexer.h @@ -16,6 +16,8 @@ #define LLVM_CLANG_TOOLS_LIBCLANG_CINDEXER_H #include "clang-c/Index.h" +#include "clang/Frontend/PCHContainerOperations.h" +#include "clang/Lex/ModuleLoader.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/Path.h" #include <vector> @@ -38,11 +40,14 @@ class CIndexer { unsigned Options; // CXGlobalOptFlags. std::string ResourcesPath; + std::shared_ptr<PCHContainerOperations> PCHContainerOps; public: - CIndexer() : OnlyLocalDecls(false), DisplayDiagnostics(false), - Options(CXGlobalOpt_None) { } - + CIndexer(std::shared_ptr<PCHContainerOperations> PCHContainerOps = + std::make_shared<RawPCHContainerOperations>()) + : OnlyLocalDecls(false), DisplayDiagnostics(false), + Options(CXGlobalOpt_None), PCHContainerOps(PCHContainerOps) {} + /// \brief Whether we only want to see "local" declarations (that did not /// come from a previous precompiled header). If false, we want to see all /// declarations. @@ -54,6 +59,10 @@ public: DisplayDiagnostics = Display; } + std::shared_ptr<PCHContainerOperations> getPCHContainerOperations() const { + return PCHContainerOps; + } + unsigned getCXGlobalOptFlags() const { return Options; } void setCXGlobalOptFlags(unsigned options) { Options = options; } diff --git a/tools/libclang/CXCursor.cpp b/tools/libclang/CXCursor.cpp index b0446fd0da9e..b8bb28ed8530 100644 --- a/tools/libclang/CXCursor.cpp +++ b/tools/libclang/CXCursor.cpp @@ -235,11 +235,13 @@ CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent, case Stmt::CXXUuidofExprClass: case Stmt::ChooseExprClass: case Stmt::DesignatedInitExprClass: + case Stmt::DesignatedInitUpdateExprClass: case Stmt::ExprWithCleanupsClass: case Stmt::ExpressionTraitExprClass: case Stmt::ExtVectorElementExprClass: case Stmt::ImplicitCastExprClass: case Stmt::ImplicitValueInitExprClass: + case Stmt::NoInitExprClass: case Stmt::MaterializeTemporaryExprClass: case Stmt::ObjCIndirectCopyRestoreExprClass: case Stmt::OffsetOfExprClass: @@ -568,6 +570,9 @@ CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent, case Stmt::OMPTaskwaitDirectiveClass: K = CXCursor_OMPTaskwaitDirective; break; + case Stmt::OMPTaskgroupDirectiveClass: + K = CXCursor_OMPTaskgroupDirective; + break; case Stmt::OMPFlushDirectiveClass: K = CXCursor_OMPFlushDirective; break; diff --git a/tools/libclang/Indexing.cpp b/tools/libclang/Indexing.cpp index 0ede684a18e4..e35640029e62 100644 --- a/tools/libclang/Indexing.cpp +++ b/tools/libclang/Indexing.cpp @@ -590,8 +590,7 @@ static void clang_indexSourceFile_Impl(void *UserData) { if (index_options & CXIndexOpt_SuppressWarnings) CInvok->getDiagnosticOpts().IgnoreWarnings = true; - ASTUnit *Unit = ASTUnit::create(CInvok.get(), Diags, - CaptureDiagnostics, + ASTUnit *Unit = ASTUnit::create(CInvok.get(), Diags, CaptureDiagnostics, /*UserFilesAreVolatile=*/true); if (!Unit) { ITUI->result = CXError_InvalidArguments; @@ -644,17 +643,13 @@ static void clang_indexSourceFile_Impl(void *UserData) { PPOpts.DetailedRecord = false; DiagnosticErrorTrap DiagTrap(*Diags); - bool Success = ASTUnit::LoadFromCompilerInvocationAction(CInvok.get(), Diags, - IndexAction.get(), - Unit, - Persistent, - CXXIdx->getClangResourcesPath(), - OnlyLocalDecls, - CaptureDiagnostics, - PrecompilePreamble, - CacheCodeCompletionResults, - /*IncludeBriefCommentsInCodeCompletion=*/false, - /*UserFilesAreVolatile=*/true); + bool Success = ASTUnit::LoadFromCompilerInvocationAction( + CInvok.get(), CXXIdx->getPCHContainerOperations(), Diags, + IndexAction.get(), Unit, Persistent, CXXIdx->getClangResourcesPath(), + OnlyLocalDecls, CaptureDiagnostics, PrecompilePreamble, + CacheCodeCompletionResults, + /*IncludeBriefCommentsInCodeCompletion=*/false, + /*UserFilesAreVolatile=*/true); if (DiagTrap.hasErrorOccurred() && CXXIdx->getDisplayDiagnostics()) printDiagsToStderr(Unit); diff --git a/tools/scan-build/ccc-analyzer b/tools/scan-build/ccc-analyzer index 4549b29a806e..ffe6859672cf 100755 --- a/tools/scan-build/ccc-analyzer +++ b/tools/scan-build/ccc-analyzer @@ -135,8 +135,8 @@ sub ProcessClangFailure { my ($PPH, $PPFile) = tempfile( $prefix . "_XXXXXX", SUFFIX => GetPPExt($Lang), DIR => $Dir); - system $Clang, @$Args, "-E", "-o", $PPFile; close ($PPH); + system $Clang, @$Args, "-E", "-o", $PPFile; # Create the info file. open (OUT, ">", "$PPFile.info.txt") or die "Cannot open $PPFile.info.txt\n"; @@ -756,5 +756,3 @@ if ($Action eq 'compile' or $Action eq 'link') { } } } - -exit($Status >> 8); diff --git a/tools/scan-build/scan-build b/tools/scan-build/scan-build index d52d8f5f655c..ac8e22e8cc72 100755 --- a/tools/scan-build/scan-build +++ b/tools/scan-build/scan-build @@ -766,7 +766,7 @@ ENDTEXT my $x = shift @fname; print OUT $x; if ($#fname >= 0) { - print OUT "<span class=\"W\"> </span>/"; + print OUT "/"; } } } diff --git a/unittests/ASTMatchers/ASTMatchersTest.h b/unittests/ASTMatchers/ASTMatchersTest.h index e555e6318d58..17b69dac45a1 100644 --- a/unittests/ASTMatchers/ASTMatchersTest.h +++ b/unittests/ASTMatchers/ASTMatchersTest.h @@ -80,6 +80,7 @@ testing::AssertionResult matchesConditionally( Args.push_back("-frtti"); Args.push_back("-fexceptions"); if (!runToolOnCodeWithArgs(Factory->create(), Code, Args, Filename, + std::make_shared<RawPCHContainerOperations>(), VirtualMappedFiles)) { return testing::AssertionFailure() << "Parsing error in \"" << Code << "\""; } diff --git a/unittests/Format/CMakeLists.txt b/unittests/Format/CMakeLists.txt index 4a7ab794187b..6d48cf871335 100644 --- a/unittests/Format/CMakeLists.txt +++ b/unittests/Format/CMakeLists.txt @@ -7,6 +7,7 @@ add_clang_unittest(FormatTests FormatTestJava.cpp FormatTestJS.cpp FormatTestProto.cpp + FormatTestSelective.cpp ) target_link_libraries(FormatTests diff --git a/unittests/Format/FormatTest.cpp b/unittests/Format/FormatTest.cpp index c4aa712ba1d5..ed2658b3c143 100644 --- a/unittests/Format/FormatTest.cpp +++ b/unittests/Format/FormatTest.cpp @@ -16,6 +16,7 @@ namespace clang { namespace format { +namespace { FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } @@ -27,12 +28,12 @@ protected: IC_DoNotCheck }; - std::string format(llvm::StringRef Code, unsigned Offset, unsigned Length, - const FormatStyle &Style, + std::string format(llvm::StringRef Code, + const FormatStyle &Style = getLLVMStyle(), IncompleteCheck CheckIncomplete = IC_ExpectComplete) { DEBUG(llvm::errs() << "---\n"); DEBUG(llvm::errs() << Code << "\n\n"); - std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length)); + std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); bool IncompleteFormat = false; tooling::Replacements Replaces = reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat); @@ -47,12 +48,6 @@ protected: return Result; } - std::string format(llvm::StringRef Code, - const FormatStyle &Style = getLLVMStyle(), - IncompleteCheck CheckIncomplete = IC_ExpectComplete) { - return format(Code, 0, Code.size(), Style, CheckIncomplete); - } - FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { FormatStyle Style = getLLVMStyle(); Style.ColumnLimit = ColumnLimit; @@ -151,54 +146,13 @@ TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { " f();\n" "}")); EXPECT_EQ(0, ReplacementCount); -} - -TEST_F(FormatTest, RemovesTrailingWhitespaceOfFormattedLine) { - EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0, getLLVMStyle())); - EXPECT_EQ("int a;", format("int a; ")); - EXPECT_EQ("int a;\n", format("int a; \n \n \n ")); - EXPECT_EQ("int a;\nint b; ", - format("int a; \nint b; ", 0, 0, getLLVMStyle())); -} - -TEST_F(FormatTest, FormatsCorrectRegionForLeadingWhitespace) { - EXPECT_EQ("int b;\nint a;", - format("int b;\n int a;", 7, 0, getLLVMStyle())); - EXPECT_EQ("int b;\n int a;", - format("int b;\n int a;", 6, 0, getLLVMStyle())); - - EXPECT_EQ("#define A \\\n" - " int a; \\\n" - " int b;", - format("#define A \\\n" - " int a; \\\n" - " int b;", - 26, 0, getLLVMStyleWithColumns(12))); - EXPECT_EQ("#define A \\\n" - " int a; \\\n" - " int b;", - format("#define A \\\n" - " int a; \\\n" - " int b;", - 25, 0, getLLVMStyleWithColumns(12))); -} - -TEST_F(FormatTest, FormatLineWhenInvokedOnTrailingNewline) { - EXPECT_EQ("int b;\n\nint a;", - format("int b;\n\nint a;", 8, 0, getLLVMStyle())); - EXPECT_EQ("int b;\n\nint a;", - format("int b;\n\nint a;", 7, 0, getLLVMStyle())); - - // This might not strictly be correct, but is likely good in all practical - // cases. - EXPECT_EQ("int b;\nint a;", format("int b;int a;", 7, 0, getLLVMStyle())); -} - -TEST_F(FormatTest, RemovesWhitespaceWhenTriggeredOnEmptyLine) { - EXPECT_EQ("int a;\n\n int b;", - format("int a;\n \n\n int b;", 8, 0, getLLVMStyle())); - EXPECT_EQ("int a;\n\n int b;", - format("int a;\n \n\n int b;", 9, 0, getLLVMStyle())); + EXPECT_EQ("/*\r\n" + "\r\n" + "*/\r\n", + format("/*\r\n" + "\r\n" + "*/\r\n")); + EXPECT_EQ(0, ReplacementCount); } TEST_F(FormatTest, RemovesEmptyLines) { @@ -316,19 +270,6 @@ TEST_F(FormatTest, RemovesEmptyLines) { "} // namespace")); } -TEST_F(FormatTest, ReformatsMovedLines) { - EXPECT_EQ( - "template <typename T> T *getFETokenInfo() const {\n" - " return static_cast<T *>(FETokenInfo);\n" - "}\n" - " int a; // <- Should not be formatted", - format( - "template<typename T>\n" - "T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); }\n" - " int a; // <- Should not be formatted", - 9, 5, getLLVMStyle())); -} - TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { verifyFormat("x = (a) and (b);"); verifyFormat("x = (a) or (b);"); @@ -377,10 +318,6 @@ TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { "}", AllowsMergedIf); - EXPECT_EQ("if (a) return;", format("if(a)\nreturn;", 7, 1, AllowsMergedIf)); - EXPECT_EQ("if (a) return; // comment", - format("if(a)\nreturn; // comment", 20, 1, AllowsMergedIf)); - AllowsMergedIf.ColumnLimit = 14; verifyFormat("if (a) return;", AllowsMergedIf); verifyFormat("if (aaaaaaaaa)\n" @@ -616,6 +553,18 @@ TEST_F(FormatTest, ForEachLoops) { " BOOST_FOREACH (Item *item, itemlist) {}\n" " UNKNOWN_FORACH(Item * item, itemlist) {}\n" "}"); + + // As function-like macros. + verifyFormat("#define foreach(x, y)\n" + "#define Q_FOREACH(x, y)\n" + "#define BOOST_FOREACH(x, y)\n" + "#define UNKNOWN_FOREACH(x, y)\n"); + + // Not as function-like macros. + verifyFormat("#define foreach (x, y)\n" + "#define Q_FOREACH (x, y)\n" + "#define BOOST_FOREACH (x, y)\n" + "#define UNKNOWN_FOREACH (x, y)\n"); } TEST_F(FormatTest, FormatsWhileLoop) { @@ -1121,65 +1070,6 @@ TEST_F(FormatTest, KeepsParameterWithTrailingCommentsOnTheirOwnLine) { " c); // comment")); } -TEST_F(FormatTest, CanFormatCommentsLocally) { - EXPECT_EQ("int a; // comment\n" - "int b; // comment", - format("int a; // comment\n" - "int b; // comment", - 0, 0, getLLVMStyle())); - EXPECT_EQ("int a; // comment\n" - " // line 2\n" - "int b;", - format("int a; // comment\n" - " // line 2\n" - "int b;", - 28, 0, getLLVMStyle())); - EXPECT_EQ("int aaaaaa; // comment\n" - "int b;\n" - "int c; // unrelated comment", - format("int aaaaaa; // comment\n" - "int b;\n" - "int c; // unrelated comment", - 31, 0, getLLVMStyle())); - - EXPECT_EQ("int a; // This\n" - " // is\n" - " // a", - format("int a; // This\n" - " // is\n" - " // a", - 0, 0, getLLVMStyle())); - EXPECT_EQ("int a; // This\n" - " // is\n" - " // a\n" - "// This is b\n" - "int b;", - format("int a; // This\n" - " // is\n" - " // a\n" - "// This is b\n" - "int b;", - 0, 0, getLLVMStyle())); - EXPECT_EQ("int a; // This\n" - " // is\n" - " // a\n" - "\n" - " // This is unrelated", - format("int a; // This\n" - " // is\n" - " // a\n" - "\n" - " // This is unrelated", - 0, 0, getLLVMStyle())); - EXPECT_EQ("int a;\n" - "// This is\n" - "// not formatted. ", - format("int a;\n" - "// This is\n" - "// not formatted. ", - 0, 0, getLLVMStyle())); -} - TEST_F(FormatTest, RemovesTrailingWhitespaceOfComments) { EXPECT_EQ("// comment", format("// comment ")); EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment", @@ -2106,7 +1996,6 @@ TEST_F(FormatTest, FormatsEnum) { verifyFormat("enum X E {} d;"); verifyFormat("enum __attribute__((...)) E {} d;"); verifyFormat("enum __declspec__((...)) E {} d;"); - verifyFormat("enum X f() {\n a();\n return 42;\n}"); verifyFormat("enum {\n" " Bar = Foo<int, int>::value\n" "};", @@ -2135,6 +2024,23 @@ TEST_F(FormatTest, FormatsEnum) { " TWO\n" "};\n" "int i;"); + // Not enums. + verifyFormat("enum X f() {\n" + " a();\n" + " return 42;\n" + "}"); + verifyFormat("enum X Type::f() {\n" + " a();\n" + " return 42;\n" + "}"); + verifyFormat("enum ::X f() {\n" + " a();\n" + " return 42;\n" + "}"); + verifyFormat("enum ns::X f() {\n" + " a();\n" + " return 42;\n" + "}"); } TEST_F(FormatTest, FormatsEnumsWithErrors) { @@ -2699,31 +2605,6 @@ TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } -TEST_F(FormatTest, AlwaysFormatsEntireMacroDefinitions) { - EXPECT_EQ("int i;\n" - "#define A \\\n" - " int i; \\\n" - " int j\n" - "int k;", - format("int i;\n" - "#define A \\\n" - " int i ; \\\n" - " int j\n" - "int k;", - 8, 0, getGoogleStyle())); // 8: position of "#define". - EXPECT_EQ("int i;\n" - "#define A \\\n" - " int i; \\\n" - " int j\n" - "int k;", - format("int i;\n" - "#define A \\\n" - " int i ; \\\n" - " int j\n" - "int k;", - 45, 0, getGoogleStyle())); // 45: position of "j". -} - TEST_F(FormatTest, MacroDefinitionInsideStatement) { EXPECT_EQ("int x,\n" "#define A\n" @@ -2799,7 +2680,8 @@ TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { "#define b \\\n" " } \\\n" " a\n" - "a", getLLVMStyleWithColumns(15)); + "a", + getLLVMStyleWithColumns(15)); verifyFormat("#define A \\\n" " { \\\n" " {\n" @@ -3027,8 +2909,7 @@ TEST_F(FormatTest, EscapedNewlines) { EXPECT_EQ( "#define A \\\n int i; \\\n int j;", format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11))); - EXPECT_EQ( - "#define A\n\nint i;", format("#define A \\\n\n int i;")); + EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); EXPECT_EQ("/* \\ \\ \\\n*/", format("\\\n/* \\ \\ \\\n*/")); EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); @@ -3205,30 +3086,6 @@ TEST_F(FormatTest, LayoutBlockInsideParens) { " if (a)\n" " f();\n" "});"); - EXPECT_EQ("int longlongname; // comment\n" - "int x = f({\n" - " int x; // comment\n" - " int y; // comment\n" - "});", - format("int longlongname; // comment\n" - "int x = f({\n" - " int x; // comment\n" - " int y; // comment\n" - "});", - 65, 0, getLLVMStyle())); - EXPECT_EQ("int s = f({\n" - " class X {\n" - " public:\n" - " void f();\n" - " };\n" - "});", - format("int s = f({\n" - " class X {\n" - " public:\n" - " void f();\n" - " };\n" - "});", - 0, 0, getLLVMStyle())); } TEST_F(FormatTest, LayoutBlockInsideStatement) { @@ -3330,90 +3187,6 @@ TEST_F(FormatTest, FormatNestedBlocksInMacros) { getGoogleStyle())); } -TEST_F(FormatTest, IndividualStatementsOfNestedBlocks) { - EXPECT_EQ("DEBUG({\n" - " int i;\n" - " int j;\n" - "});", - format("DEBUG( {\n" - " int i;\n" - " int j;\n" - "} ) ;", - 20, 1, getLLVMStyle())); - EXPECT_EQ("DEBUG( {\n" - " int i;\n" - " int j;\n" - "} ) ;", - format("DEBUG( {\n" - " int i;\n" - " int j;\n" - "} ) ;", - 41, 1, getLLVMStyle())); - EXPECT_EQ("DEBUG( {\n" - " int i;\n" - " int j;\n" - "} ) ;", - format("DEBUG( {\n" - " int i;\n" - " int j;\n" - "} ) ;", - 41, 1, getLLVMStyle())); - EXPECT_EQ("DEBUG({\n" - " int i;\n" - " int j;\n" - "});", - format("DEBUG( {\n" - " int i;\n" - " int j;\n" - "} ) ;", - 20, 1, getLLVMStyle())); - - EXPECT_EQ("Debug({\n" - " if (aaaaaaaaaaaaaaaaaaaaaaaa)\n" - " return;\n" - " },\n" - " a);", - format("Debug({\n" - " if (aaaaaaaaaaaaaaaaaaaaaaaa)\n" - " return;\n" - " },\n" - " a);", - 50, 1, getLLVMStyle())); - EXPECT_EQ("DEBUG({\n" - " DEBUG({\n" - " int a;\n" - " int b;\n" - " }) ;\n" - "});", - format("DEBUG({\n" - " DEBUG({\n" - " int a;\n" - " int b;\n" // Format this line only. - " }) ;\n" // Don't touch this line. - "});", - 35, 0, getLLVMStyle())); - EXPECT_EQ("DEBUG({\n" - " int a; //\n" - "});", - format("DEBUG({\n" - " int a; //\n" - "});", - 0, 0, getLLVMStyle())); - EXPECT_EQ("someFunction(\n" - " [] {\n" - " // Only with this comment.\n" - " int i; // invoke formatting here.\n" - " }, // force line break\n" - " aaa);", - format("someFunction(\n" - " [] {\n" - " // Only with this comment.\n" - " int i; // invoke formatting here.\n" - " }, // force line break\n" - " aaa);", - 63, 1, getLLVMStyle())); -} - TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { EXPECT_EQ("{}", format("{}")); verifyFormat("enum E {};"); @@ -4886,6 +4659,13 @@ TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { " L\"bbbb\"\n" " L\"cccc\");", Break); + verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" + " \"bbbb\"));", + Break); + verifyFormat("string s = someFunction(\n" + " \"abc\"\n" + " \"abc\");", + Break); // As we break before unary operators, breaking right after them is bad. verifyFormat("string foo = abc ? \"x\"\n" @@ -4906,11 +4686,11 @@ TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { "b\\\n" "c\";", NoBreak)); - EXPECT_EQ("x =\n" + EXPECT_EQ("xxxx =\n" " \"a\\\n" "b\\\n" "c\";", - format("x = \"a\\\n" + format("xxxx = \"a\\\n" "b\\\n" "c\";", Break)); @@ -5806,6 +5586,7 @@ TEST_F(FormatTest, FormatsCasts) { verifyFormat("my_int a = (const my_int *)-1;"); verifyFormat("my_int a = (my_int)(my_int)-1;"); verifyFormat("my_int a = (ns::my_int)-2;"); + verifyFormat("case (my_int)ONE:"); // FIXME: single value wrapped with paren will be treated as cast. verifyFormat("void f(int i = (kValue)*kMask) {}"); @@ -6357,20 +6138,19 @@ TEST_F(FormatTest, LayoutCxx11BraceInitializers) { "std::this_thread::sleep_for(\n" " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", ExtraSpaces); - verifyFormat( - "std::vector<MyValues> aaaaaaaaaaaaaaaaaaa{\n" - " aaaaaaa,\n" - " aaaaaaaaaa,\n" - " aaaaa,\n" - " aaaaaaaaaaaaaaa,\n" - " aaa,\n" - " aaaaaaaaaa,\n" - " a,\n" - " aaaaaaaaaaaaaaaaaaaaa,\n" - " aaaaaaaaaaaa,\n" - " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" - " aaaaaaa,\n" - " a};"); + verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaa{\n" + " aaaaaaa,\n" + " aaaaaaaaaa,\n" + " aaaaa,\n" + " aaaaaaaaaaaaaaa,\n" + " aaa,\n" + " aaaaaaaaaa,\n" + " a,\n" + " aaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaa,\n" + " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaa,\n" + " a};"); verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); } @@ -7613,114 +7393,6 @@ TEST_F(FormatTest, ObjCArrayLiterals) { "]];"); } -TEST_F(FormatTest, ReformatRegionAdjustsIndent) { - EXPECT_EQ("{\n" - "{\n" - "a;\n" - "b;\n" - "}\n" - "}", - format("{\n" - "{\n" - "a;\n" - " b;\n" - "}\n" - "}", - 13, 2, getLLVMStyle())); - EXPECT_EQ("{\n" - "{\n" - " a;\n" - "b;\n" - "}\n" - "}", - format("{\n" - "{\n" - " a;\n" - "b;\n" - "}\n" - "}", - 9, 2, getLLVMStyle())); - EXPECT_EQ("{\n" - "{\n" - "public:\n" - " b;\n" - "}\n" - "}", - format("{\n" - "{\n" - "public:\n" - " b;\n" - "}\n" - "}", - 17, 2, getLLVMStyle())); - EXPECT_EQ("{\n" - "{\n" - "a;\n" - "}\n" - "{\n" - " b; //\n" - "}\n" - "}", - format("{\n" - "{\n" - "a;\n" - "}\n" - "{\n" - " b; //\n" - "}\n" - "}", - 22, 2, getLLVMStyle())); - EXPECT_EQ(" {\n" - " a; //\n" - " }", - format(" {\n" - "a; //\n" - " }", - 4, 2, getLLVMStyle())); - EXPECT_EQ("void f() {}\n" - "void g() {}", - format("void f() {}\n" - "void g() {}", - 13, 0, getLLVMStyle())); - EXPECT_EQ("int a; // comment\n" - " // line 2\n" - "int b;", - format("int a; // comment\n" - " // line 2\n" - " int b;", - 35, 0, getLLVMStyle())); - EXPECT_EQ(" int a;\n" - " void\n" - " ffffff() {\n" - " }", - format(" int a;\n" - "void ffffff() {}", - 11, 0, getLLVMStyleWithColumns(11))); - - EXPECT_EQ(" void f() {\n" - "#define A 1\n" - " }", - format(" void f() {\n" - " #define A 1\n" // Format this line. - " }", - 20, 0, getLLVMStyle())); - EXPECT_EQ(" void f() {\n" - " int i;\n" - "#define A \\\n" - " int i; \\\n" - " int j;\n" - " int k;\n" - " }", - format(" void f() {\n" - " int i;\n" - "#define A \\\n" - " int i; \\\n" - " int j;\n" - " int k;\n" // Format this line. - " }", - 67, 0, getLLVMStyle())); -} - TEST_F(FormatTest, BreaksStringLiterals) { EXPECT_EQ("\"some text \"\n" "\"other\";", @@ -7843,13 +7515,14 @@ TEST_F(FormatTest, BreaksStringLiterals) { // Verify that splitting the strings understands // Style::AlwaysBreakBeforeMultilineStrings. - EXPECT_EQ("aaaaaaaaaaaa(aaaaaaaaaaaaa,\n" - " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" - " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", - format("aaaaaaaaaaaa(aaaaaaaaaaaaa, \"aaaaaaaaaaaaaaaaaaaaaa " - "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa " - "aaaaaaaaaaaaaaaaaaaaaa\");", - getGoogleStyle())); + EXPECT_EQ( + "aaaaaaaaaaaa(\n" + " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" + " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", + format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " + "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " + "aaaaaaaaaaaaaaaaaaaaaa\");", + getGoogleStyle())); EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", format("return \"aaaaaaaaaaaaaaaaaaaaaa " @@ -8206,33 +7879,6 @@ TEST_F(FormatTest, ConfigurableUseOfTab) { "\t\t parameter2); \\\n" "\t}", Tab); - EXPECT_EQ("void f() {\n" - "\tf();\n" - "\tg();\n" - "}", - format("void f() {\n" - "\tf();\n" - "\tg();\n" - "}", - 0, 0, Tab)); - EXPECT_EQ("void f() {\n" - "\tf();\n" - "\tg();\n" - "}", - format("void f() {\n" - "\tf();\n" - "\tg();\n" - "}", - 16, 0, Tab)); - EXPECT_EQ("void f() {\n" - " \tf();\n" - "\tg();\n" - "}", - format("void f() {\n" - " \tf();\n" - " \tg();\n" - "}", - 21, 0, Tab)); Tab.TabWidth = 4; Tab.IndentWidth = 8; @@ -9322,13 +8968,15 @@ TEST_F(FormatTest, GetsCorrectBasedOnStyle) { Styles[2].Language = FormatStyle::LK_JavaScript; EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" "BasedOnStyle: Google", - &Styles[2]).value()); + &Styles[2]) + .value()); Styles[3] = getLLVMStyle(); Styles[3].Language = FormatStyle::LK_JavaScript; EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" "Language: JavaScript", - &Styles[3]).value()); + &Styles[3]) + .value()); Styles[4] = getLLVMStyle(); Styles[4].Language = FormatStyle::LK_JavaScript; @@ -9338,7 +8986,8 @@ TEST_F(FormatTest, GetsCorrectBasedOnStyle) { "---\n" "BasedOnStyle: Google\n" "Language: JavaScript", - &Styles[4]).value()); + &Styles[4]) + .value()); EXPECT_ALL_STYLES_EQUAL(Styles); } @@ -9637,7 +9286,8 @@ TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { "Language: JavaScript\n" "IndentWidth: 76\n" "...\n", - &Style).value()); + &Style) + .value()); EXPECT_FALSE(Style.BreakBeforeTernaryOperators); EXPECT_EQ(76u, Style.IndentWidth); EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); @@ -10085,6 +9735,7 @@ TEST_F(FormatTest, FormatsLambdas) { // Lambdas with return types. verifyFormat("int c = []() -> int { return 2; }();\n"); + verifyFormat("int c = []() -> int * { return 2; }();\n"); verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); @@ -10309,8 +9960,7 @@ TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { ZeroColumn.AllowShortBlocksOnASingleLine = true; EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", - format("void (^largeBlock)(void) = ^{ int i; };", - ZeroColumn)); + format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); ZeroColumn.AllowShortBlocksOnASingleLine = false; EXPECT_EQ("void (^largeBlock)(void) = ^{\n" " int i;\n" @@ -10564,7 +10214,11 @@ TEST_F(FormatTest, DisableRegions) { " int k;")); } -TEST_F(FormatTest, DoNotCrashOnInvalidInput) { format("? ) ="); } +TEST_F(FormatTest, DoNotCrashOnInvalidInput) { + format("? ) ="); + verifyNoCrash("#define a\\\n /**/}"); +} -} // end namespace tooling +} // end namespace +} // end namespace format } // end namespace clang diff --git a/unittests/Format/FormatTestJS.cpp b/unittests/Format/FormatTestJS.cpp index efa845cd90be..15d62eb66c33 100644 --- a/unittests/Format/FormatTestJS.cpp +++ b/unittests/Format/FormatTestJS.cpp @@ -24,7 +24,10 @@ protected: DEBUG(llvm::errs() << "---\n"); DEBUG(llvm::errs() << Code << "\n\n"); std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length)); - tooling::Replacements Replaces = reformat(Style, Code, Ranges); + bool IncompleteFormat = false; + tooling::Replacements Replaces = + reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat); + EXPECT_FALSE(IncompleteFormat); std::string Result = applyAllReplacements(Code, Replaces); EXPECT_NE("", Result); DEBUG(llvm::errs() << "\n" << Result << "\n\n"); @@ -146,6 +149,10 @@ TEST_F(FormatTestJS, ContainerLiterals) { // Enum style top level assignment. verifyFormat("X = {\n a: 123\n};"); verifyFormat("X.Y = {\n a: 123\n};"); + // But only on the top level, otherwise its a plain object literal assignment. + verifyFormat("function x() {\n" + " y = {z: 1};\n" + "}"); verifyFormat("x = foo && {a: 123};"); // Arrow functions in object literals. @@ -245,12 +252,12 @@ TEST_F(FormatTestJS, FormatsFreestandingFunctions) { " function inner2(a, b) { return a; }\n" " inner2(a, b);\n" "}"); + verifyFormat("function f() {}"); } TEST_F(FormatTestJS, ArrayLiterals) { - verifyFormat( - "var aaaaa: List<SomeThing> =\n" - " [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()];"); + verifyFormat("var aaaaa: List<SomeThing> =\n" + " [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()];"); verifyFormat("return [\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" @@ -270,6 +277,13 @@ TEST_F(FormatTestJS, ArrayLiterals) { " bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" " ccccccccccccccccccccccccccc\n" "]);"); + verifyFormat("var someVariable = SomeFuntion(aaaa,\n" + " [\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" + " ccccccccccccccccccccccccccc\n" + " ],\n" + " aaaa);"); verifyFormat("someFunction([], {a: a});"); } @@ -280,6 +294,10 @@ TEST_F(FormatTestJS, FunctionLiterals) { verifyFormat("var func = function() {\n" " return 1;\n" "};"); + verifyFormat("var func = //\n" + " function() {\n" + " return 1;\n" + "};"); verifyFormat("return {\n" " body: {\n" " setAttribute: function(key, val) { this[key] = val; },\n" @@ -513,6 +531,18 @@ TEST_F(FormatTestJS, ReturnStatements) { "}"); } +TEST_F(FormatTestJS, AutomaticSemicolonInsertion) { + // The following statements must not wrap, as otherwise the program meaning + // would change due to automatic semicolon insertion. + // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1. + verifyFormat("return aaaaa;", getGoogleJSStyleWithColumns(10)); + verifyFormat("continue aaaaa;", getGoogleJSStyleWithColumns(10)); + verifyFormat("break aaaaa;", getGoogleJSStyleWithColumns(10)); + verifyFormat("throw aaaaa;", getGoogleJSStyleWithColumns(10)); + verifyFormat("aaaaaaaaa++;", getGoogleJSStyleWithColumns(10)); + verifyFormat("aaaaaaaaa--;", getGoogleJSStyleWithColumns(10)); +} + TEST_F(FormatTestJS, ClosureStyleCasts) { verifyFormat("var x = /** @type {foo} */ (bar);"); } @@ -657,7 +687,24 @@ TEST_F(FormatTestJS, ClassDeclarations) { TEST_F(FormatTestJS, InterfaceDeclarations) { verifyFormat("interface I {\n" " x: string;\n" + "}\n" + "var y;"); +} + +TEST_F(FormatTestJS, EnumDeclarations) { + verifyFormat("enum Foo {\n" + " A = 1,\n" + " B\n" "}"); + verifyFormat("export /* somecomment*/ enum Foo {\n" + " A = 1,\n" + " B\n" + "}"); + verifyFormat("enum Foo {\n" + " A = 1, // comment\n" + " B\n" + "}\n" + "var x = 1;"); } TEST_F(FormatTestJS, MetadataAnnotations) { @@ -700,12 +747,9 @@ TEST_F(FormatTestJS, Modules) { verifyFormat("export function fn() {\n" " return 'fn';\n" "}"); - verifyFormat("export function A() {\n" - "}\n" - "export default function B() {\n" - "}\n" - "export function C() {\n" - "}"); + verifyFormat("export function A() {}\n" + "export default function B() {}\n" + "export function C() {}"); verifyFormat("export const x = 12;"); verifyFormat("export default class X {}"); verifyFormat("export {X, Y} from 'some/module.js';"); @@ -721,11 +765,19 @@ TEST_F(FormatTestJS, Modules) { verifyFormat("export default class X { y: number }"); verifyFormat("export default function() {\n return 1;\n}"); verifyFormat("export var x = 12;"); + verifyFormat("class C {}\n" + "export function f() {}\n" + "var v;"); verifyFormat("export var x: number = 12;"); verifyFormat("export const y = {\n" " a: 1,\n" " b: 2\n" "};"); + verifyFormat("export enum Foo {\n" + " BAR,\n" + " // adsdasd\n" + " BAZ\n" + "}"); } TEST_F(FormatTestJS, TemplateStrings) { @@ -783,6 +835,11 @@ TEST_F(FormatTestJS, TemplateStrings) { "var y;", format("var x =\n `/*a`;\n" "var y;")); + // Unterminated string literals in a template string. + verifyFormat("var x = `'`; // comment with matching quote '\n" + "var y;"); + verifyFormat("var x = `\"`; // comment with matching quote \"\n" + "var y;"); // Backticks in a comment - not a template string. EXPECT_EQ("var x = 1 // `/*a`;\n" " ;", @@ -802,9 +859,7 @@ TEST_F(FormatTestJS, TemplateStrings) { "var y;")); } -TEST_F(FormatTestJS, CastSyntax) { - verifyFormat("var x = <type>foo;"); -} +TEST_F(FormatTestJS, CastSyntax) { verifyFormat("var x = <type>foo;"); } TEST_F(FormatTestJS, TypeArguments) { verifyFormat("class X<Y> {}"); @@ -812,12 +867,12 @@ TEST_F(FormatTestJS, TypeArguments) { verifyFormat("foo<Y>(a);"); verifyFormat("var x: X<Y>[];"); verifyFormat("class C extends D<E> implements F<G>, H<I> {}"); - verifyFormat("function f(a: List<any> = null) {\n}"); - verifyFormat("function f(): List<any> {\n}"); + verifyFormat("function f(a: List<any> = null) {}"); + verifyFormat("function f(): List<any> {}"); } TEST_F(FormatTestJS, OptionalTypes) { - verifyFormat("function x(a?: b, c?, d?) {\n}"); + verifyFormat("function x(a?: b, c?, d?) {}"); verifyFormat("class X {\n" " y?: z;\n" " z?;\n" @@ -831,8 +886,7 @@ TEST_F(FormatTestJS, OptionalTypes) { " aaaaaaaa?: string,\n" " aaaaaaaaaaaaaaa?: boolean,\n" " aaaaaa?: List<string>\n" - "}) {\n" - "}"); + "}) {}"); } TEST_F(FormatTestJS, IndexSignature) { diff --git a/unittests/Format/FormatTestJava.cpp b/unittests/Format/FormatTestJava.cpp index 631a3dca27e7..4c161e0180af 100644 --- a/unittests/Format/FormatTestJava.cpp +++ b/unittests/Format/FormatTestJava.cpp @@ -31,9 +31,9 @@ protected: return Result; } - static std::string format( - llvm::StringRef Code, - const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_Java)) { + static std::string + format(llvm::StringRef Code, + const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_Java)) { return format(Code, 0, Code.size(), Style); } diff --git a/unittests/Format/FormatTestSelective.cpp b/unittests/Format/FormatTestSelective.cpp new file mode 100644 index 000000000000..8d2cb5a2fcbd --- /dev/null +++ b/unittests/Format/FormatTestSelective.cpp @@ -0,0 +1,441 @@ +//===- unittest/Format/FormatTestSelective.cpp - Formatting unit tests ----===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "FormatTestUtils.h" +#include "clang/Format/Format.h" +#include "llvm/Support/Debug.h" +#include "gtest/gtest.h" + +#define DEBUG_TYPE "format-test" + +namespace clang { +namespace format { +namespace { + +class FormatTestSelective : public ::testing::Test { +protected: + std::string format(llvm::StringRef Code, unsigned Offset, unsigned Length) { + DEBUG(llvm::errs() << "---\n"); + DEBUG(llvm::errs() << Code << "\n\n"); + std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length)); + bool IncompleteFormat = false; + tooling::Replacements Replaces = + reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat); + EXPECT_FALSE(IncompleteFormat) << Code << "\n\n"; + std::string Result = applyAllReplacements(Code, Replaces); + EXPECT_NE("", Result); + DEBUG(llvm::errs() << "\n" << Result << "\n\n"); + return Result; + } + + FormatStyle Style = getLLVMStyle(); +}; + +TEST_F(FormatTestSelective, RemovesTrailingWhitespaceOfFormattedLine) { + EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0)); + EXPECT_EQ("int a;", format("int a; ", 0, 0)); + EXPECT_EQ("int a;\n", format("int a; \n \n \n ", 0, 0)); + EXPECT_EQ("int a;\nint b; ", format("int a; \nint b; ", 0, 0)); +} + +TEST_F(FormatTestSelective, FormatsCorrectRegionForLeadingWhitespace) { + EXPECT_EQ("int b;\nint a;", format("int b;\n int a;", 7, 0)); + EXPECT_EQ("int b;\n int a;", format("int b;\n int a;", 6, 0)); + + Style.ColumnLimit = 12; + EXPECT_EQ("#define A \\\n" + " int a; \\\n" + " int b;", + format("#define A \\\n" + " int a; \\\n" + " int b;", + 26, 0)); + EXPECT_EQ("#define A \\\n" + " int a; \\\n" + " int b;", + format("#define A \\\n" + " int a; \\\n" + " int b;", + 25, 0)); +} + +TEST_F(FormatTestSelective, FormatLineWhenInvokedOnTrailingNewline) { + EXPECT_EQ("int b;\n\nint a;", format("int b;\n\nint a;", 8, 0)); + EXPECT_EQ("int b;\n\nint a;", format("int b;\n\nint a;", 7, 0)); + + // This might not strictly be correct, but is likely good in all practical + // cases. + EXPECT_EQ("int b;\nint a;", format("int b;int a;", 7, 0)); +} + +TEST_F(FormatTestSelective, RemovesWhitespaceWhenTriggeredOnEmptyLine) { + EXPECT_EQ("int a;\n\n int b;", format("int a;\n \n\n int b;", 8, 0)); + EXPECT_EQ("int a;\n\n int b;", format("int a;\n \n\n int b;", 9, 0)); +} + +TEST_F(FormatTestSelective, ReformatsMovedLines) { + EXPECT_EQ( + "template <typename T> T *getFETokenInfo() const {\n" + " return static_cast<T *>(FETokenInfo);\n" + "}\n" + " int a; // <- Should not be formatted", + format( + "template<typename T>\n" + "T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); }\n" + " int a; // <- Should not be formatted", + 9, 5)); +} + +TEST_F(FormatTestSelective, FormatsIfWithoutCompoundStatement) { + Style.AllowShortIfStatementsOnASingleLine = true; + EXPECT_EQ("if (a) return;", format("if(a)\nreturn;", 7, 1)); + EXPECT_EQ("if (a) return; // comment", + format("if(a)\nreturn; // comment", 20, 1)); +} + +TEST_F(FormatTestSelective, FormatsCommentsLocally) { + EXPECT_EQ("int a; // comment\n" + "int b; // comment", + format("int a; // comment\n" + "int b; // comment", + 0, 0)); + EXPECT_EQ("int a; // comment\n" + " // line 2\n" + "int b;", + format("int a; // comment\n" + " // line 2\n" + "int b;", + 28, 0)); + EXPECT_EQ("int aaaaaa; // comment\n" + "int b;\n" + "int c; // unrelated comment", + format("int aaaaaa; // comment\n" + "int b;\n" + "int c; // unrelated comment", + 31, 0)); + + EXPECT_EQ("int a; // This\n" + " // is\n" + " // a", + format("int a; // This\n" + " // is\n" + " // a", + 0, 0)); + EXPECT_EQ("int a; // This\n" + " // is\n" + " // a\n" + "// This is b\n" + "int b;", + format("int a; // This\n" + " // is\n" + " // a\n" + "// This is b\n" + "int b;", + 0, 0)); + EXPECT_EQ("int a; // This\n" + " // is\n" + " // a\n" + "\n" + " // This is unrelated", + format("int a; // This\n" + " // is\n" + " // a\n" + "\n" + " // This is unrelated", + 0, 0)); + EXPECT_EQ("int a;\n" + "// This is\n" + "// not formatted. ", + format("int a;\n" + "// This is\n" + "// not formatted. ", + 0, 0)); +} + +TEST_F(FormatTestSelective, IndividualStatementsOfNestedBlocks) { + EXPECT_EQ("DEBUG({\n" + " int i;\n" + " int j;\n" + "});", + format("DEBUG( {\n" + " int i;\n" + " int j;\n" + "} ) ;", + 20, 1)); + EXPECT_EQ("DEBUG( {\n" + " int i;\n" + " int j;\n" + "} ) ;", + format("DEBUG( {\n" + " int i;\n" + " int j;\n" + "} ) ;", + 41, 1)); + EXPECT_EQ("DEBUG( {\n" + " int i;\n" + " int j;\n" + "} ) ;", + format("DEBUG( {\n" + " int i;\n" + " int j;\n" + "} ) ;", + 41, 1)); + EXPECT_EQ("DEBUG({\n" + " int i;\n" + " int j;\n" + "});", + format("DEBUG( {\n" + " int i;\n" + " int j;\n" + "} ) ;", + 20, 1)); + + EXPECT_EQ("Debug({\n" + " if (aaaaaaaaaaaaaaaaaaaaaaaa)\n" + " return;\n" + " },\n" + " a);", + format("Debug({\n" + " if (aaaaaaaaaaaaaaaaaaaaaaaa)\n" + " return;\n" + " },\n" + " a);", + 50, 1)); + EXPECT_EQ("DEBUG({\n" + " DEBUG({\n" + " int a;\n" + " int b;\n" + " }) ;\n" + "});", + format("DEBUG({\n" + " DEBUG({\n" + " int a;\n" + " int b;\n" // Format this line only. + " }) ;\n" // Don't touch this line. + "});", + 35, 0)); + EXPECT_EQ("DEBUG({\n" + " int a; //\n" + "});", + format("DEBUG({\n" + " int a; //\n" + "});", + 0, 0)); + EXPECT_EQ("someFunction(\n" + " [] {\n" + " // Only with this comment.\n" + " int i; // invoke formatting here.\n" + " }, // force line break\n" + " aaa);", + format("someFunction(\n" + " [] {\n" + " // Only with this comment.\n" + " int i; // invoke formatting here.\n" + " }, // force line break\n" + " aaa);", + 63, 1)); + + EXPECT_EQ("int longlongname; // comment\n" + "int x = f({\n" + " int x; // comment\n" + " int y; // comment\n" + "});", + format("int longlongname; // comment\n" + "int x = f({\n" + " int x; // comment\n" + " int y; // comment\n" + "});", + 65, 0)); + EXPECT_EQ("int s = f({\n" + " class X {\n" + " public:\n" + " void f();\n" + " };\n" + "});", + format("int s = f({\n" + " class X {\n" + " public:\n" + " void f();\n" + " };\n" + "});", + 0, 0)); +} + +TEST_F(FormatTestSelective, AlwaysFormatsEntireMacroDefinitions) { + Style.AlignEscapedNewlinesLeft = true; + EXPECT_EQ("int i;\n" + "#define A \\\n" + " int i; \\\n" + " int j\n" + "int k;", + format("int i;\n" + "#define A \\\n" + " int i ; \\\n" + " int j\n" + "int k;", + 8, 0)); // 8: position of "#define". + EXPECT_EQ("int i;\n" + "#define A \\\n" + " int i; \\\n" + " int j\n" + "int k;", + format("int i;\n" + "#define A \\\n" + " int i ; \\\n" + " int j\n" + "int k;", + 45, 0)); // 45: position of "j". +} + +TEST_F(FormatTestSelective, ReformatRegionAdjustsIndent) { + EXPECT_EQ("{\n" + "{\n" + "a;\n" + "b;\n" + "}\n" + "}", + format("{\n" + "{\n" + "a;\n" + " b;\n" + "}\n" + "}", + 13, 2)); + EXPECT_EQ("{\n" + "{\n" + " a;\n" + "b;\n" + "}\n" + "}", + format("{\n" + "{\n" + " a;\n" + "b;\n" + "}\n" + "}", + 9, 2)); + EXPECT_EQ("{\n" + "{\n" + "public:\n" + " b;\n" + "}\n" + "}", + format("{\n" + "{\n" + "public:\n" + " b;\n" + "}\n" + "}", + 17, 2)); + EXPECT_EQ("{\n" + "{\n" + "a;\n" + "}\n" + "{\n" + " b; //\n" + "}\n" + "}", + format("{\n" + "{\n" + "a;\n" + "}\n" + "{\n" + " b; //\n" + "}\n" + "}", + 22, 2)); + EXPECT_EQ(" {\n" + " a; //\n" + " }", + format(" {\n" + "a; //\n" + " }", + 4, 2)); + EXPECT_EQ("void f() {}\n" + "void g() {}", + format("void f() {}\n" + "void g() {}", + 13, 0)); + EXPECT_EQ("int a; // comment\n" + " // line 2\n" + "int b;", + format("int a; // comment\n" + " // line 2\n" + " int b;", + 35, 0)); + + EXPECT_EQ(" void f() {\n" + "#define A 1\n" + " }", + format(" void f() {\n" + " #define A 1\n" // Format this line. + " }", + 20, 0)); + EXPECT_EQ(" void f() {\n" + " int i;\n" + "#define A \\\n" + " int i; \\\n" + " int j;\n" + " int k;\n" + " }", + format(" void f() {\n" + " int i;\n" + "#define A \\\n" + " int i; \\\n" + " int j;\n" + " int k;\n" // Format this line. + " }", + 67, 0)); + + Style.ColumnLimit = 11; + EXPECT_EQ(" int a;\n" + " void\n" + " ffffff() {\n" + " }", + format(" int a;\n" + "void ffffff() {}", + 11, 0)); +} + +TEST_F(FormatTestSelective, UnderstandsTabs) { + Style.IndentWidth = 8; + Style.UseTab = FormatStyle::UT_Always; + Style.AlignEscapedNewlinesLeft = true; + EXPECT_EQ("void f() {\n" + "\tf();\n" + "\tg();\n" + "}", + format("void f() {\n" + "\tf();\n" + "\tg();\n" + "}", + 0, 0)); + EXPECT_EQ("void f() {\n" + "\tf();\n" + "\tg();\n" + "}", + format("void f() {\n" + "\tf();\n" + "\tg();\n" + "}", + 16, 0)); + EXPECT_EQ("void f() {\n" + " \tf();\n" + "\tg();\n" + "}", + format("void f() {\n" + " \tf();\n" + " \tg();\n" + "}", + 21, 0)); +} + +} // end namespace +} // end namespace format +} // end namespace clang diff --git a/unittests/Tooling/RewriterTest.cpp b/unittests/Tooling/RewriterTest.cpp index c53e50a87d76..93f69eb9fa0c 100644 --- a/unittests/Tooling/RewriterTest.cpp +++ b/unittests/Tooling/RewriterTest.cpp @@ -8,9 +8,12 @@ //===----------------------------------------------------------------------===// #include "RewriterTestContext.h" +#include "clang/Tooling/Core/Replacement.h" #include "gtest/gtest.h" namespace clang { +namespace tooling { +namespace { TEST(Rewriter, OverwritesChangedFiles) { RewriterTestContext Context; @@ -34,4 +37,14 @@ TEST(Rewriter, ContinuesOverwritingFilesOnError) { Context.getFileContentFromDisk("working.cpp")); } +TEST(Rewriter, AdjacentInsertAndDelete) { + Replacements Replaces; + Replaces.insert(Replacement("<file>", 6, 6, "")); + Replaces.insert(Replacement("<file>", 6, 0, "replaced\n")); + EXPECT_EQ("line1\nreplaced\nline3\nline4", + applyAllReplacements("line1\nline2\nline3\nline4", Replaces)); +} + +} // end namespace +} // end namespace tooling } // end namespace clang diff --git a/utils/TableGen/ClangAttrEmitter.cpp b/utils/TableGen/ClangAttrEmitter.cpp index 11a766c7a4e9..f79c4a5f9212 100644 --- a/utils/TableGen/ClangAttrEmitter.cpp +++ b/utils/TableGen/ClangAttrEmitter.cpp @@ -2721,7 +2721,8 @@ void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) { StringMatcher("Name", Declspec, OS).Emit(); OS << " } else if (AttributeList::AS_CXX11 == Syntax) {\n"; StringMatcher("Name", CXX11, OS).Emit(); - OS << " } else if (AttributeList::AS_Keyword == Syntax) {\n"; + OS << " } else if (AttributeList::AS_Keyword == Syntax || "; + OS << "AttributeList::AS_ContextSensitiveKeyword == Syntax) {\n"; StringMatcher("Name", Keywords, OS).Emit(); OS << " } else if (AttributeList::AS_Pragma == Syntax) {\n"; StringMatcher("Name", Pragma, OS).Emit(); diff --git a/www/analyzer/scan-build.html b/www/analyzer/scan-build.html index 1a06f00913dd..28723e64eb80 100644 --- a/www/analyzer/scan-build.html +++ b/www/analyzer/scan-build.html @@ -136,8 +136,7 @@ with MinGW/MSYS the following information may be helpful:</p> <ul> <li> If getting unexpected <tt>"fatal error: no input files"</tt> while -building with MSYS make from the Windows cmd, try one of the these -solutions:</li> +building with MSYS make from the Windows cmd, try one of these solutions:</li> <ul> <li> Use MinGW <tt>mingw32-make</tt> instead of MSYS <tt>make</tt> and exclude the path to MSYS from PATH to prevent <tt>mingw32-make</tt> from using |