diff options
570 files changed, 17356 insertions, 9584 deletions
diff --git a/docs/AddressSanitizer.rst b/docs/AddressSanitizer.rst index 617543334d05..66ed3447fdb1 100644 --- a/docs/AddressSanitizer.rst +++ b/docs/AddressSanitizer.rst @@ -60,7 +60,28 @@ or: % clang -g -fsanitize=address example_UseAfterFree.o If a bug is detected, the program will print an error message to stderr and -exit with a non-zero exit code. To make AddressSanitizer symbolize its output +exit with a non-zero exit code. AddressSanitizer exits on the first detected error. +This is by design: + +* This approach allows AddressSanitizer to produce faster and smaller generated code + (both by ~5%). +* Fixing bugs becomes unavoidable. AddressSanitizer does not produce + false alarms. Once a memory corruption occurs, the program is in an inconsistent + state, which could lead to confusing results and potentially misleading + subsequent reports. + +If your process is sandboxed and you are running on OS X 10.10 or earlier, you +will need to set ``DYLD_INSERT_LIBRARIES`` environment variable and point it to +the ASan library that is packaged with the compiler used to build the +executable. (You can find the library by searching for dynamic libraries with +``asan`` in their name.) If the environment variable is not set, the process will +try to re-exec. Also keep in mind that when moving the executable to another machine, +the ASan library will also need to be copied over. + +Symbolizing the Reports +========================= + +To make AddressSanitizer symbolize its output you need to set the ``ASAN_SYMBOLIZER_PATH`` environment variable to point to the ``llvm-symbolizer`` binary (or make sure ``llvm-symbolizer`` is in your ``$PATH``): @@ -100,14 +121,63 @@ force disabled by setting ``ASAN_OPTIONS=symbolize=0``): Note that on OS X you may need to run ``dsymutil`` on your binary to have the file\:line info in the AddressSanitizer reports. -AddressSanitizer exits on the first detected error. This is by design. -One reason: it makes the generated code smaller and faster (both by -~5%). Another reason: this makes fixing bugs unavoidable. With Valgrind, -it is often the case that users treat Valgrind warnings as false -positives (which they are not) and don't fix them. +Additional Checks +================= -``__has_feature(address_sanitizer)`` ------------------------------------- +Initialization order checking +----------------------------- + +AddressSanitizer can optionally detect dynamic initialization order problems, +when initialization of globals defined in one translation unit uses +globals defined in another translation unit. To enable this check at runtime, +you should set environment variable +``ASAN_OPTIONS=check_initialization_order=1``. + +Note that this option is not supported on OS X. + +Memory leak detection +--------------------- + +For more information on leak detector in AddressSanitizer, see +:doc:`LeakSanitizer`. The leak detection is turned on by default on Linux; +however, it is not yet supported on other platforms. + +Issue Suppression +================= + +AddressSanitizer is not expected to produce false positives. If you see one, +look again; most likely it is a true positive! + +Suppressing Reports in External Libraries +----------------------------------------- +Runtime interposition allows AddressSanitizer to find bugs in code that is +not being recompiled. If you run into an issue in external libraries, we +recommend immediately reporting it to the library maintainer so that it +gets addressed. However, you can use the following suppression mechanism +to unblock yourself and continue on with the testing. This suppression +mechanism should only be used for suppressing issues in external code; it +does not work on code recompiled with AddressSanitizer. To suppress errors +in external libraries, set the ``ASAN_OPTIONS`` environment variable to point +to a suppression file. You can either specify the full path to the file or the +path of the file relative to the location of your executable. + +.. code-block:: bash + + ASAN_OPTIONS=suppressions=MyASan.supp + +Use the following format to specify the names of the functions or libraries +you want to suppress. You can see these in the error report. Remember that +the narrower the scope of the suppression, the more bugs you will be able to +catch. + +.. code-block:: bash + + interceptor_via_fun:NameOfCFunctionToSuppress + interceptor_via_fun:-[ClassName objCMethodToSuppress:] + interceptor_via_lib:NameOfTheLibraryToSuppress + +Conditional Compilation with ``__has_feature(address_sanitizer)`` +----------------------------------------------------------------- In some cases one may need to execute different code depending on whether AddressSanitizer is enabled. @@ -122,28 +192,19 @@ this purpose. # endif #endif -``__attribute__((no_sanitize_address))`` ------------------------------------------------ +Disabling Instrumentation with ``__attribute__((no_sanitize("address")))`` +-------------------------------------------------------------------------- Some code should not be instrumented by AddressSanitizer. One may use the -function attribute -:ref:`no_sanitize_address <langext-address_sanitizer>` -(or a deprecated synonym `no_address_safety_analysis`) -to disable instrumentation of a particular function. This attribute may not be -supported by other compilers, so we suggest to use it together with -``__has_feature(address_sanitizer)``. - -Initialization order checking ------------------------------ - -AddressSanitizer can optionally detect dynamic initialization order problems, -when initialization of globals defined in one translation unit uses -globals defined in another translation unit. To enable this check at runtime, -you should set environment variable -``ASAN_OPTIONS=check_initialization_order=1``. +function attribute ``__attribute__((no_sanitize("address")))`` +(which has deprecated synonyms +:ref:`no_sanitize_address <langext-address_sanitizer>` and +`no_address_safety_analysis`) to disable instrumentation of a particular +function. This attribute may not be supported by other compilers, so we suggest +to use it together with ``__has_feature(address_sanitizer)``. -Blacklist ---------- +Suppressing Errors in Recompiled Code (Blacklist) +------------------------------------------------- AddressSanitizer supports ``src`` and ``fun`` entity types in :doc:`SanitizerSpecialCaseList`, that can be used to suppress error reports @@ -172,24 +233,6 @@ problems happening in certain source files or with certain global variables. type:*BadInitClassSubstring*=init src:bad/init/files/*=init -Memory leak detection ---------------------- - -For the experimental memory leak detector in AddressSanitizer, see -:doc:`LeakSanitizer`. - -Supported Platforms -=================== - -AddressSanitizer is supported on - -* Linux i386/x86\_64 (tested on Ubuntu 12.04); -* MacOS 10.6 - 10.9 (i386/x86\_64). -* Android ARM -* FreeBSD i386/x86\_64 (tested on FreeBSD 11-current) - -Ports to various other platforms are in progress. - Limitations =========== @@ -202,6 +245,19 @@ Limitations usually expected. * Static linking is not supported. +Supported Platforms +=================== + +AddressSanitizer is supported on: + +* Linux i386/x86\_64 (tested on Ubuntu 12.04) +* OS X 10.7 - 10.11 (i386/x86\_64) +* iOS Simulator +* Android ARM +* FreeBSD i386/x86\_64 (tested on FreeBSD 11-current) + +Ports to various other platforms are in progress. + Current Status ============== diff --git a/docs/AttributeReference.rst b/docs/AttributeReference.rst index 115a217c4c19..a763ddeaeb10 100644 --- a/docs/AttributeReference.rst +++ b/docs/AttributeReference.rst @@ -1,1116 +1,13 @@ .. ------------------------------------------------------------------- NOTE: This file is automatically generated by running clang-tblgen - -gen-attr-docs. Do not edit this file by hand!! + -gen-attr-docs. Do not edit this file by hand!! The contents for + this file are automatically generated by a server-side process. + + Please do not commit this file. The file exists for local testing + purposes only. ------------------------------------------------------------------- =================== Attributes in Clang -=================== -.. contents:: - :local: - -Introduction -============ - -This page lists the attributes currently supported by Clang. - -Function Attributes -=================== - - -interrupt ---------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -Clang supports the GNU style ``__attribute__((interrupt("TYPE")))`` attribute on -ARM targets. This attribute may be attached to a function definition and -instructs the backend to generate appropriate function entry/exit code so that -it can be used directly as an interrupt service routine. - -The parameter passed to the interrupt attribute is optional, but if -provided it must be a string literal with one of the following values: "IRQ", -"FIQ", "SWI", "ABORT", "UNDEF". - -The semantics are as follows: - -- If the function is AAPCS, Clang instructs the backend to realign the stack to - 8 bytes on entry. This is a general requirement of the AAPCS at public - interfaces, but may not hold when an exception is taken. Doing this allows - other AAPCS functions to be called. -- If the CPU is M-class this is all that needs to be done since the architecture - itself is designed in such a way that functions obeying the normal AAPCS ABI - constraints are valid exception handlers. -- If the CPU is not M-class, the prologue and epilogue are modified to save all - non-banked registers that are used, so that upon return the user-mode state - will not be corrupted. Note that to avoid unnecessary overhead, only - general-purpose (integer) registers are saved in this way. If VFP operations - are needed, that state must be saved manually. - - Specifically, interrupt kinds other than "FIQ" will save all core registers - except "lr" and "sp". "FIQ" interrupts will save r0-r7. -- If the CPU is not M-class, the return instruction is changed to one of the - canonical sequences permitted by the architecture for exception return. Where - possible the function itself will make the necessary "lr" adjustments so that - the "preferred return address" is selected. - - Unfortunately the compiler is unable to make this guarantee for an "UNDEF" - handler, where the offset from "lr" to the preferred return address depends on - the execution state of the code which generated the exception. In this case - a sequence equivalent to "movs pc, lr" will be used. - - -acquire_capability (acquire_shared_capability, clang::acquire_capability, clang::acquire_shared_capability) ------------------------------------------------------------------------------------------------------------ -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -Marks a function as acquiring a capability. - - -assert_capability (assert_shared_capability, clang::assert_capability, clang::assert_shared_capability) -------------------------------------------------------------------------------------------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -Marks a function that dynamically tests whether a capability is held, and halts -the program if it is not held. - - -availability ------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -The ``availability`` attribute can be placed on declarations to describe the -lifecycle of that declaration relative to operating system versions. Consider -the function declaration for a hypothetical function ``f``: - -.. code-block:: c++ - - void f(void) __attribute__((availability(macosx,introduced=10.4,deprecated=10.6,obsoleted=10.7))); - -The availability attribute states that ``f`` was introduced in Mac OS X 10.4, -deprecated in Mac OS X 10.6, and obsoleted in Mac OS X 10.7. This information -is used by Clang to determine when it is safe to use ``f``: for example, if -Clang is instructed to compile code for Mac OS X 10.5, a call to ``f()`` -succeeds. If Clang is instructed to compile code for Mac OS X 10.6, the call -succeeds but Clang emits a warning specifying that the function is deprecated. -Finally, if Clang is instructed to compile code for Mac OS X 10.7, the call -fails because ``f()`` is no longer available. - -The availability attribute is a comma-separated list starting with the -platform name and then including clauses specifying important milestones in the -declaration's lifetime (in any order) along with additional information. Those -clauses can be: - -introduced=\ *version* - The first version in which this declaration was introduced. - -deprecated=\ *version* - The first version in which this declaration was deprecated, meaning that - users should migrate away from this API. - -obsoleted=\ *version* - The first version in which this declaration was obsoleted, meaning that it - was removed completely and can no longer be used. - -unavailable - This declaration is never available on this platform. - -message=\ *string-literal* - Additional message text that Clang will provide when emitting a warning or - error about use of a deprecated or obsoleted declaration. Useful to direct - users to replacement APIs. - -Multiple availability attributes can be placed on a declaration, which may -correspond to different platforms. Only the availability attribute with the -platform corresponding to the target platform will be used; any others will be -ignored. If no availability attribute specifies availability for the current -target platform, the availability attributes are ignored. Supported platforms -are: - -``ios`` - Apple's iOS operating system. The minimum deployment target is specified by - the ``-mios-version-min=*version*`` or ``-miphoneos-version-min=*version*`` - command-line arguments. - -``macosx`` - Apple's Mac OS X operating system. The minimum deployment target is - specified by the ``-mmacosx-version-min=*version*`` command-line argument. - -A declaration can be used even when deploying back to a platform version prior -to when the declaration was introduced. When this happens, the declaration is -`weakly linked -<https://developer.apple.com/library/mac/#documentation/MacOSX/Conceptual/BPFrameworks/Concepts/WeakLinking.html>`_, -as if the ``weak_import`` attribute were added to the declaration. A -weakly-linked declaration may or may not be present a run-time, and a program -can determine whether the declaration is present by checking whether the -address of that declaration is non-NULL. - -If there are multiple declarations of the same entity, the availability -attributes must either match on a per-platform basis or later -declarations must not have availability attributes for that -platform. For example: - -.. code-block:: c - - void g(void) __attribute__((availability(macosx,introduced=10.4))); - void g(void) __attribute__((availability(macosx,introduced=10.4))); // okay, matches - void g(void) __attribute__((availability(ios,introduced=4.0))); // okay, adds a new platform - void g(void); // okay, inherits both macosx and ios availability from above. - void g(void) __attribute__((availability(macosx,introduced=10.5))); // error: mismatch - -When one method overrides another, the overriding method can be more widely available than the overridden method, e.g.,: - -.. code-block:: objc - - @interface A - - (id)method __attribute__((availability(macosx,introduced=10.4))); - - (id)method2 __attribute__((availability(macosx,introduced=10.4))); - @end - - @interface B : A - - (id)method __attribute__((availability(macosx,introduced=10.3))); // okay: method moved into base class later - - (id)method __attribute__((availability(macosx,introduced=10.5))); // error: this method was available via the base class in 10.4 - @end - - -_Noreturn ---------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "","","","X" - -A function declared as ``_Noreturn`` shall not return to its caller. The -compiler will generate a diagnostic for a function declared as ``_Noreturn`` -that appears to be capable of returning to its caller. - - -noreturn --------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "","X","","" - -A function declared as ``[[noreturn]]`` shall not return to its caller. The -compiler will generate a diagnostic for a function declared as ``[[noreturn]]`` -that appears to be capable of returning to its caller. - - -carries_dependency ------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -The ``carries_dependency`` attribute specifies dependency propagation into and -out of functions. - -When specified on a function or Objective-C method, the ``carries_dependency`` -attribute means that the return value carries a dependency out of the function, -so that the implementation need not constrain ordering upon return from that -function. Implementations of the function and its caller may choose to preserve -dependencies instead of emitting memory ordering instructions such as fences. - -Note, this attribute does not change the meaning of the program, but may result -in generation of more efficient code. - - -enable_if ---------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -.. Note:: Some features of this attribute are experimental. The meaning of - multiple enable_if attributes on a single declaration is subject to change in - a future version of clang. Also, the ABI is not standardized and the name - mangling may change in future versions. To avoid that, use asm labels. - -The ``enable_if`` attribute can be placed on function declarations to control -which overload is selected based on the values of the function's arguments. -When combined with the ``overloadable`` attribute, this feature is also -available in C. - -.. code-block:: c++ - - int isdigit(int c); - int isdigit(int c) __attribute__((enable_if(c <= -1 || c > 255, "chosen when 'c' is out of range"))) __attribute__((unavailable("'c' must have the value of an unsigned char or EOF"))); - - void foo(char c) { - isdigit(c); - isdigit(10); - isdigit(-10); // results in a compile-time error. - } - -The enable_if attribute takes two arguments, the first is an expression written -in terms of the function parameters, the second is a string explaining why this -overload candidate could not be selected to be displayed in diagnostics. The -expression is part of the function signature for the purposes of determining -whether it is a redeclaration (following the rules used when determining -whether a C++ template specialization is ODR-equivalent), but is not part of -the type. - -The enable_if expression is evaluated as if it were the body of a -bool-returning constexpr function declared with the arguments of the function -it is being applied to, then called with the parameters at the callsite. If the -result is false or could not be determined through constant expression -evaluation, then this overload will not be chosen and the provided string may -be used in a diagnostic if the compile fails as a result. - -Because the enable_if expression is an unevaluated context, there are no global -state changes, nor the ability to pass information from the enable_if -expression to the function body. For example, suppose we want calls to -strnlen(strbuf, maxlen) to resolve to strnlen_chk(strbuf, maxlen, size of -strbuf) only if the size of strbuf can be determined: - -.. code-block:: c++ - - __attribute__((always_inline)) - static inline size_t strnlen(const char *s, size_t maxlen) - __attribute__((overloadable)) - __attribute__((enable_if(__builtin_object_size(s, 0) != -1))), - "chosen when the buffer size is known but 'maxlen' is not"))) - { - return strnlen_chk(s, maxlen, __builtin_object_size(s, 0)); - } - -Multiple enable_if attributes may be applied to a single declaration. In this -case, the enable_if expressions are evaluated from left to right in the -following manner. First, the candidates whose enable_if expressions evaluate to -false or cannot be evaluated are discarded. If the remaining candidates do not -share ODR-equivalent enable_if expressions, the overload resolution is -ambiguous. Otherwise, enable_if overload resolution continues with the next -enable_if attribute on the candidates that have not been discarded and have -remaining enable_if attributes. In this way, we pick the most specific -overload out of a number of viable overloads using enable_if. - -.. code-block:: c++ - - void f() __attribute__((enable_if(true, ""))); // #1 - void f() __attribute__((enable_if(true, ""))) __attribute__((enable_if(true, ""))); // #2 - - void g(int i, int j) __attribute__((enable_if(i, ""))); // #1 - void g(int i, int j) __attribute__((enable_if(j, ""))) __attribute__((enable_if(true))); // #2 - -In this example, a call to f() is always resolved to #2, as the first enable_if -expression is ODR-equivalent for both declarations, but #1 does not have another -enable_if expression to continue evaluating, so the next round of evaluation has -only a single candidate. In a call to g(1, 1), the call is ambiguous even though -#2 has more enable_if attributes, because the first enable_if expressions are -not ODR-equivalent. - -Query for this feature with ``__has_attribute(enable_if)``. - - -flatten (gnu::flatten) ----------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -The ``flatten`` attribute causes calls within the attributed function to -be inlined unless it is impossible to do so, for example if the body of the -callee is unavailable or if the callee has the ``noinline`` attribute. - - -format (gnu::format) --------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -Clang supports the ``format`` attribute, which indicates that the function -accepts a ``printf`` or ``scanf``-like format string and corresponding -arguments or a ``va_list`` that contains these arguments. - -Please see `GCC documentation about format attribute -<http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html>`_ to find details -about attribute syntax. - -Clang implements two kinds of checks with this attribute. - -#. Clang checks that the function with the ``format`` attribute is called with - a format string that uses format specifiers that are allowed, and that - arguments match the format string. This is the ``-Wformat`` warning, it is - on by default. - -#. Clang checks that the format string argument is a literal string. This is - the ``-Wformat-nonliteral`` warning, it is off by default. - - Clang implements this mostly the same way as GCC, but there is a difference - for functions that accept a ``va_list`` argument (for example, ``vprintf``). - GCC does not emit ``-Wformat-nonliteral`` warning for calls to such - fuctions. Clang does not warn if the format string comes from a function - parameter, where the function is annotated with a compatible attribute, - otherwise it warns. For example: - - .. code-block:: c - - __attribute__((__format__ (__scanf__, 1, 3))) - void foo(const char* s, char *buf, ...) { - va_list ap; - va_start(ap, buf); - - vprintf(s, ap); // warning: format string is not a string literal - } - - In this case we warn because ``s`` contains a format string for a - ``scanf``-like function, but it is passed to a ``printf``-like function. - - If the attribute is removed, clang still warns, because the format string is - not a string literal. - - Another example: - - .. code-block:: c - - __attribute__((__format__ (__printf__, 1, 3))) - void foo(const char* s, char *buf, ...) { - va_list ap; - va_start(ap, buf); - - vprintf(s, ap); // warning - } - - In this case Clang does not warn because the format string ``s`` and - the corresponding arguments are annotated. If the arguments are - incorrect, the caller of ``foo`` will receive a warning. - - -noduplicate (clang::noduplicate) --------------------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -The ``noduplicate`` attribute can be placed on function declarations to control -whether function calls to this function can be duplicated or not as a result of -optimizations. This is required for the implementation of functions with -certain special requirements, like the OpenCL "barrier" function, that might -need to be run concurrently by all the threads that are executing in lockstep -on the hardware. For example this attribute applied on the function -"nodupfunc" in the code below avoids that: - -.. code-block:: c - - void nodupfunc() __attribute__((noduplicate)); - // Setting it as a C++11 attribute is also valid - // void nodupfunc() [[clang::noduplicate]]; - void foo(); - void bar(); - - nodupfunc(); - if (a > n) { - foo(); - } else { - bar(); - } - -gets possibly modified by some optimizations into code similar to this: - -.. code-block:: c - - if (a > n) { - nodupfunc(); - foo(); - } else { - nodupfunc(); - bar(); - } - -where the call to "nodupfunc" is duplicated and sunk into the two branches -of the condition. - - -no_sanitize_address (no_address_safety_analysis, gnu::no_address_safety_analysis, gnu::no_sanitize_address) ------------------------------------------------------------------------------------------------------------ -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -.. _langext-address_sanitizer: - -Use ``__attribute__((no_sanitize_address))`` on a function declaration to -specify that address safety instrumentation (e.g. AddressSanitizer) should -not be applied to that function. - - -no_sanitize_memory ------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -.. _langext-memory_sanitizer: - -Use ``__attribute__((no_sanitize_memory))`` on a function declaration to -specify that checks for uninitialized memory should not be inserted -(e.g. by MemorySanitizer). The function may still be instrumented by the tool -to avoid false positives in other places. - - -no_sanitize_thread ------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -.. _langext-thread_sanitizer: - -Use ``__attribute__((no_sanitize_thread))`` on a function declaration to -specify that checks for data races on plain (non-atomic) memory accesses should -not be inserted by ThreadSanitizer. The function is still instrumented by the -tool to avoid false positives and provide meaningful stack traces. - - -no_split_stack (gnu::no_split_stack) ------------------------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -The ``no_split_stack`` attribute disables the emission of the split stack -preamble for a particular function. It has no effect if ``-fsplit-stack`` -is not specified. - - -objc_method_family ------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -Many methods in Objective-C have conventional meanings determined by their -selectors. It is sometimes useful to be able to mark a method as having a -particular conventional meaning despite not having the right selector, or as -not having the conventional meaning that its selector would suggest. For these -use cases, we provide an attribute to specifically describe the "method family" -that a method belongs to. - -**Usage**: ``__attribute__((objc_method_family(X)))``, where ``X`` is one of -``none``, ``alloc``, ``copy``, ``init``, ``mutableCopy``, or ``new``. This -attribute can only be placed at the end of a method declaration: - -.. code-block:: objc - - - (NSString *)initMyStringValue __attribute__((objc_method_family(none))); - -Users who do not wish to change the conventional meaning of a method, and who -merely want to document its non-standard retain and release semantics, should -use the retaining behavior attributes (``ns_returns_retained``, -``ns_returns_not_retained``, etc). - -Query for this feature with ``__has_attribute(objc_method_family)``. - - -objc_requires_super -------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -Some Objective-C classes allow a subclass to override a particular method in a -parent class but expect that the overriding method also calls the overridden -method in the parent class. For these cases, we provide an attribute to -designate that a method requires a "call to ``super``" in the overriding -method in the subclass. - -**Usage**: ``__attribute__((objc_requires_super))``. This attribute can only -be placed at the end of a method declaration: - -.. code-block:: objc - - - (void)foo __attribute__((objc_requires_super)); - -This attribute can only be applied the method declarations within a class, and -not a protocol. Currently this attribute does not enforce any placement of -where the call occurs in the overriding method (such as in the case of -``-dealloc`` where the call must appear at the end). It checks only that it -exists. - -Note that on both OS X and iOS that the Foundation framework provides a -convenience macro ``NS_REQUIRES_SUPER`` that provides syntactic sugar for this -attribute: - -.. code-block:: objc - - - (void)foo NS_REQUIRES_SUPER; - -This macro is conditionally defined depending on the compiler's support for -this attribute. If the compiler does not support the attribute the macro -expands to nothing. - -Operationally, when a method has this annotation the compiler will warn if the -implementation of an override in a subclass does not call super. For example: - -.. code-block:: objc - - warning: method possibly missing a [super AnnotMeth] call - - (void) AnnotMeth{}; - ^ - - -optnone (clang::optnone) ------------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -The ``optnone`` attribute suppresses essentially all optimizations -on a function or method, regardless of the optimization level applied to -the compilation unit as a whole. This is particularly useful when you -need to debug a particular function, but it is infeasible to build the -entire application without optimization. Avoiding optimization on the -specified function can improve the quality of the debugging information -for that function. - -This attribute is incompatible with the ``always_inline`` attribute. - - -overloadable ------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -Clang provides support for C++ function overloading in C. Function overloading -in C is introduced using the ``overloadable`` attribute. For example, one -might provide several overloaded versions of a ``tgsin`` function that invokes -the appropriate standard function computing the sine of a value with ``float``, -``double``, or ``long double`` precision: - -.. code-block:: c - - #include <math.h> - float __attribute__((overloadable)) tgsin(float x) { return sinf(x); } - double __attribute__((overloadable)) tgsin(double x) { return sin(x); } - long double __attribute__((overloadable)) tgsin(long double x) { return sinl(x); } - -Given these declarations, one can call ``tgsin`` with a ``float`` value to -receive a ``float`` result, with a ``double`` to receive a ``double`` result, -etc. Function overloading in C follows the rules of C++ function overloading -to pick the best overload given the call arguments, with a few C-specific -semantics: - -* Conversion from ``float`` or ``double`` to ``long double`` is ranked as a - floating-point promotion (per C99) rather than as a floating-point conversion - (as in C++). - -* A conversion from a pointer of type ``T*`` to a pointer of type ``U*`` is - considered a pointer conversion (with conversion rank) if ``T`` and ``U`` are - compatible types. - -* A conversion from type ``T`` to a value of type ``U`` is permitted if ``T`` - and ``U`` are compatible types. This conversion is given "conversion" rank. - -The declaration of ``overloadable`` functions is restricted to function -declarations and definitions. Most importantly, if any function with a given -name is given the ``overloadable`` attribute, then all function declarations -and definitions with that name (and in that scope) must have the -``overloadable`` attribute. This rule even applies to redeclarations of -functions whose original declaration had the ``overloadable`` attribute, e.g., - -.. code-block:: c - - int f(int) __attribute__((overloadable)); - float f(float); // error: declaration of "f" must have the "overloadable" attribute - - int g(int) __attribute__((overloadable)); - int g(int) { } // error: redeclaration of "g" must also have the "overloadable" attribute - -Functions marked ``overloadable`` must have prototypes. Therefore, the -following code is ill-formed: - -.. code-block:: c - - int h() __attribute__((overloadable)); // error: h does not have a prototype - -However, ``overloadable`` functions are allowed to use a ellipsis even if there -are no named parameters (as is permitted in C++). This feature is particularly -useful when combined with the ``unavailable`` attribute: - -.. code-block:: c++ - - void honeypot(...) __attribute__((overloadable, unavailable)); // calling me is an error - -Functions declared with the ``overloadable`` attribute have their names mangled -according to the same rules as C++ function names. For example, the three -``tgsin`` functions in our motivating example get the mangled names -``_Z5tgsinf``, ``_Z5tgsind``, and ``_Z5tgsine``, respectively. There are two -caveats to this use of name mangling: - -* Future versions of Clang may change the name mangling of functions overloaded - in C, so you should not depend on an specific mangling. To be completely - safe, we strongly urge the use of ``static inline`` with ``overloadable`` - functions. - -* The ``overloadable`` attribute has almost no meaning when used in C++, - because names will already be mangled and functions are already overloadable. - However, when an ``overloadable`` function occurs within an ``extern "C"`` - linkage specification, it's name *will* be mangled in the same way as it - would in C. - -Query for this feature with ``__has_extension(attribute_overloadable)``. - - -pcs (gnu::pcs) --------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -On ARM targets, this can attribute can be used to select calling conventions, -similar to ``stdcall`` on x86. Valid parameter values are "aapcs" and -"aapcs-vfp". - - -release_capability (release_shared_capability, clang::release_capability, clang::release_shared_capability) ------------------------------------------------------------------------------------------------------------ -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -Marks a function as releasing a capability. - - -try_acquire_capability (try_acquire_shared_capability, clang::try_acquire_capability, clang::try_acquire_shared_capability) ---------------------------------------------------------------------------------------------------------------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -Marks a function that attempts to acquire a capability. This function may fail to -actually acquire the capability; they accept a Boolean value determining -whether acquiring the capability means success (true), or failing to acquire -the capability means success (false). - - -Variable Attributes -=================== - - -section (gnu::section, __declspec(allocate)) --------------------------------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","X","" - -The ``section`` attribute allows you to specify a specific section a -global variable or function should be in after translation. - - -tls_model (gnu::tls_model) --------------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","X","","" - -The ``tls_model`` attribute allows you to specify which thread-local storage -model to use. It accepts the following strings: - -* global-dynamic -* local-dynamic -* initial-exec -* local-exec - -TLS models are mutually exclusive. - - -thread ------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "","","X","" - -The ``__declspec(thread)`` attribute declares a variable with thread local -storage. It is available under the ``-fms-extensions`` flag for MSVC -compatibility. Documentation for the Visual C++ attribute is available on MSDN_. - -.. _MSDN: http://msdn.microsoft.com/en-us/library/9w1sdazb.aspx - -In Clang, ``__declspec(thread)`` is generally equivalent in functionality to the -GNU ``__thread`` keyword. The variable must not have a destructor and must have -a constant initializer, if any. The attribute only applies to variables -declared with static storage duration, such as globals, class static data -members, and static locals. - - -Type Attributes -=============== - - -__single_inhertiance, __multiple_inheritance, __virtual_inheritance -------------------------------------------------------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "","","","X" - -This collection of keywords is enabled under ``-fms-extensions`` and controls -the pointer-to-member representation used on ``*-*-win32`` targets. - -The ``*-*-win32`` targets utilize a pointer-to-member representation which -varies in size and alignment depending on the definition of the underlying -class. - -However, this is problematic when a forward declaration is only available and -no definition has been made yet. In such cases, Clang is forced to utilize the -most general representation that is available to it. - -These keywords make it possible to use a pointer-to-member representation other -than the most general one regardless of whether or not the definition will ever -be present in the current translation unit. - -This family of keywords belong between the ``class-key`` and ``class-name``: - -.. code-block:: c++ - - struct __single_inheritance S; - int S::*i; - struct S {}; - -This keyword can be applied to class templates but only has an effect when used -on full specializations: - -.. code-block:: c++ - - template <typename T, typename U> struct __single_inheritance A; // warning: inheritance model ignored on primary template - template <typename T> struct __multiple_inheritance A<T, T>; // warning: inheritance model ignored on partial specialization - template <> struct __single_inheritance A<int, float>; - -Note that choosing an inheritance model less general than strictly necessary is -an error: - -.. code-block:: c++ - - struct __multiple_inheritance S; // error: inheritance model does not match definition - int S::*i; - struct S {}; - - -Statement Attributes -==================== - - -fallthrough (clang::fallthrough) --------------------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "","X","","" - -The ``clang::fallthrough`` attribute is used along with the -``-Wimplicit-fallthrough`` argument to annotate intentional fall-through -between switch labels. It can only be applied to a null statement placed at a -point of execution between any statement and the next switch label. It is -common to mark these places with a specific comment, but this attribute is -meant to replace comments with a more strict annotation, which can be checked -by the compiler. This attribute doesn't change semantics of the code and can -be used wherever an intended fall-through occurs. It is designed to mimic -control-flow statements like ``break;``, so it can be placed in most places -where ``break;`` can, but only if there are no statements on the execution path -between it and the next switch label. - -Here is an example: - -.. code-block:: c++ - - // compile with -Wimplicit-fallthrough - switch (n) { - case 22: - case 33: // no warning: no statements between case labels - f(); - case 44: // warning: unannotated fall-through - g(); - [[clang::fallthrough]]; - case 55: // no warning - if (x) { - h(); - break; - } - else { - i(); - [[clang::fallthrough]]; - } - case 66: // no warning - p(); - [[clang::fallthrough]]; // warning: fallthrough annotation does not - // directly precede case label - q(); - case 77: // warning: unannotated fall-through - r(); - } - - -Consumed Annotation Checking -============================ -Clang supports additional attributes for checking basic resource management -properties, specifically for unique objects that have a single owning reference. -The following attributes are currently supported, although **the implementation -for these annotations is currently in development and are subject to change.** - -callable_when -------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -Use ``__attribute__((callable_when(...)))`` to indicate what states a method -may be called in. Valid states are unconsumed, consumed, or unknown. Each -argument to this attribute must be a quoted string. E.g.: - -``__attribute__((callable_when("unconsumed", "unknown")))`` - - -consumable ----------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -Each ``class`` that uses any of the typestate annotations must first be marked -using the ``consumable`` attribute. Failure to do so will result in a warning. - -This attribute accepts a single parameter that must be one of the following: -``unknown``, ``consumed``, or ``unconsumed``. - - -param_typestate ---------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -This attribute specifies expectations about function parameters. Calls to an -function with annotated parameters will issue a warning if the corresponding -argument isn't in the expected state. The attribute is also used to set the -initial state of the parameter when analyzing the function's body. - - -return_typestate ----------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -The ``return_typestate`` attribute can be applied to functions or parameters. -When applied to a function the attribute specifies the state of the returned -value. The function's body is checked to ensure that it always returns a value -in the specified state. On the caller side, values returned by the annotated -function are initialized to the given state. - -When applied to a function parameter it modifies the state of an argument after -a call to the function returns. The function's body is checked to ensure that -the parameter is in the expected state before returning. - - -set_typestate -------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -Annotate methods that transition an object into a new state with -``__attribute__((set_typestate(new_state)))``. The new new state must be -unconsumed, consumed, or unknown. - - -test_typestate --------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -Use ``__attribute__((test_typestate(tested_state)))`` to indicate that a method -returns true if the object is in the specified state.. - - -Type Safety Checking -==================== -Clang supports additional attributes to enable checking type safety properties -that can't be enforced by the C type system. Use cases include: - -* MPI library implementations, where these attributes enable checking that - the buffer type matches the passed ``MPI_Datatype``; -* for HDF5 library there is a similar use case to MPI; -* checking types of variadic functions' arguments for functions like - ``fcntl()`` and ``ioctl()``. - -You can detect support for these attributes with ``__has_attribute()``. For -example: - -.. code-block:: c++ - - #if defined(__has_attribute) - # if __has_attribute(argument_with_type_tag) && \ - __has_attribute(pointer_with_type_tag) && \ - __has_attribute(type_tag_for_datatype) - # define ATTR_MPI_PWT(buffer_idx, type_idx) __attribute__((pointer_with_type_tag(mpi,buffer_idx,type_idx))) - /* ... other macros ... */ - # endif - #endif - - #if !defined(ATTR_MPI_PWT) - # define ATTR_MPI_PWT(buffer_idx, type_idx) - #endif - - int MPI_Send(void *buf, int count, MPI_Datatype datatype /*, other args omitted */) - ATTR_MPI_PWT(1,3); - -argument_with_type_tag ----------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -Use ``__attribute__((argument_with_type_tag(arg_kind, arg_idx, -type_tag_idx)))`` on a function declaration to specify that the function -accepts a type tag that determines the type of some other argument. -``arg_kind`` is an identifier that should be used when annotating all -applicable type tags. - -This attribute is primarily useful for checking arguments of variadic functions -(``pointer_with_type_tag`` can be used in most non-variadic cases). - -For example: - -.. code-block:: c++ - - int fcntl(int fd, int cmd, ...) - __attribute__(( argument_with_type_tag(fcntl,3,2) )); - - -pointer_with_type_tag ---------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -Use ``__attribute__((pointer_with_type_tag(ptr_kind, ptr_idx, type_tag_idx)))`` -on a function declaration to specify that the function accepts a type tag that -determines the pointee type of some other pointer argument. - -For example: - -.. code-block:: c++ - - int MPI_Send(void *buf, int count, MPI_Datatype datatype /*, other args omitted */) - __attribute__(( pointer_with_type_tag(mpi,1,3) )); - - -type_tag_for_datatype ---------------------- -.. csv-table:: Supported Syntaxes - :header: "GNU", "C++11", "__declspec", "Keyword" - - "X","","","" - -Clang supports annotating type tags of two forms. - -* **Type tag that is an expression containing a reference to some declared - identifier.** Use ``__attribute__((type_tag_for_datatype(kind, type)))`` on a - declaration with that identifier: - - .. code-block:: c++ - - extern struct mpi_datatype mpi_datatype_int - __attribute__(( type_tag_for_datatype(mpi,int) )); - #define MPI_INT ((MPI_Datatype) &mpi_datatype_int) - -* **Type tag that is an integral literal.** Introduce a ``static const`` - variable with a corresponding initializer value and attach - ``__attribute__((type_tag_for_datatype(kind, type)))`` on that declaration, - for example: - - .. code-block:: c++ - - #define MPI_INT ((MPI_Datatype) 42) - static const MPI_Datatype mpi_datatype_int - __attribute__(( type_tag_for_datatype(mpi,int) )) = 42 - -The attribute also accepts an optional third argument that determines how the -expression is compared to the type tag. There are two supported flags: - -* ``layout_compatible`` will cause types to be compared according to - layout-compatibility rules (C++11 [class.mem] p 17, 18). This is - implemented to support annotating types like ``MPI_DOUBLE_INT``. - - For example: - - .. code-block:: c++ - - /* In mpi.h */ - struct internal_mpi_double_int { double d; int i; }; - extern struct mpi_datatype mpi_datatype_double_int - __attribute__(( type_tag_for_datatype(mpi, struct internal_mpi_double_int, layout_compatible) )); - - #define MPI_DOUBLE_INT ((MPI_Datatype) &mpi_datatype_double_int) - - /* In user code */ - struct my_pair { double a; int b; }; - struct my_pair *buffer; - MPI_Send(buffer, 1, MPI_DOUBLE_INT /*, ... */); // no warning - - struct my_int_pair { int a; int b; } - struct my_int_pair *buffer2; - MPI_Send(buffer2, 1, MPI_DOUBLE_INT /*, ... */); // warning: actual buffer element - // type 'struct my_int_pair' - // doesn't match specified MPI_Datatype - -* ``must_be_null`` specifies that the expression should be a null pointer - constant, for example: - - .. code-block:: c++ - - /* In mpi.h */ - extern struct mpi_datatype mpi_datatype_null - __attribute__(( type_tag_for_datatype(mpi, void, must_be_null) )); - - #define MPI_DATATYPE_NULL ((MPI_Datatype) &mpi_datatype_null) - - /* In user code */ - MPI_Send(buffer, 1, MPI_DATATYPE_NULL /*, ... */); // warning: MPI_DATATYPE_NULL - // was specified but buffer - // is not a null pointer - - +===================
\ No newline at end of file diff --git a/docs/CMakeLists.txt b/docs/CMakeLists.txt index 20a1396c4877..47bb2e0c4b99 100644 --- a/docs/CMakeLists.txt +++ b/docs/CMakeLists.txt @@ -87,5 +87,8 @@ if (LLVM_ENABLE_SPHINX) if (${SPHINX_OUTPUT_HTML}) add_sphinx_target(html clang) endif() + if (${SPHINX_OUTPUT_MAN}) + add_sphinx_target(man clang) + endif() endif() endif() diff --git a/docs/ClangFormatStyleOptions.rst b/docs/ClangFormatStyleOptions.rst index f4c4c8cc9a21..ab7bd872ca28 100644 --- a/docs/ClangFormatStyleOptions.rst +++ b/docs/ClangFormatStyleOptions.rst @@ -218,12 +218,19 @@ the configuration (without a prefix: ``Auto``). If ``true``, ``while (true) continue;`` can be put on a single line. -**AlwaysBreakAfterDefinitionReturnType** (``bool``) - If ``true``, always break after function definition return types. +**AlwaysBreakAfterDefinitionReturnType** (``DefinitionReturnTypeBreakingStyle``) + The function definition return type breaking style to use. + + Possible values: + + * ``DRTBS_None`` (in configuration: ``None``) + Break after return type automatically. + ``PenaltyReturnTypeOnItsOwnLine`` is taken into account. + * ``DRTBS_All`` (in configuration: ``All``) + Always break after the return type. + * ``DRTBS_TopLevel`` (in configuration: ``TopLevel``) + Always break after the return types of top level functions. - More truthfully called 'break before the identifier following the type - in a function definition'. PenaltyReturnTypeOnItsOwnLine becomes - irrelevant. **AlwaysBreakBeforeMultilineStrings** (``bool``) If ``true``, always break before multiline string literals. @@ -327,7 +334,7 @@ the configuration (without a prefix: ``Auto``). alignment of & and \*. ``PointerAlignment`` is then used only as fallback. **DisableFormat** (``bool``) - Disables formatting at all. + Disables formatting completely. **ExperimentalAutoDetectBinPacking** (``bool``) If ``true``, clang-format detects whether function calls and diff --git a/docs/CommandGuide/clang.rst b/docs/CommandGuide/clang.rst new file mode 100644 index 000000000000..39dbe02a0b43 --- /dev/null +++ b/docs/CommandGuide/clang.rst @@ -0,0 +1,484 @@ +clang - the Clang C, C++, and Objective-C compiler +================================================== + +SYNOPSIS +-------- + +:program:`clang` [*options*] *filename ...* + +DESCRIPTION +----------- + +:program:`clang` is a C, C++, and Objective-C compiler which encompasses +preprocessing, parsing, optimization, code generation, assembly, and linking. +Depending on which high-level mode setting is passed, Clang will stop before +doing a full link. While Clang is highly integrated, it is important to +understand the stages of compilation, to understand how to invoke it. These +stages are: + +Driver + The clang executable is actually a small driver which controls the overall + execution of other tools such as the compiler, assembler and linker. + Typically you do not need to interact with the driver, but you + transparently use it to run the other tools. + +Preprocessing + 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. + +Parsing and Semantic Analysis + This stage parses the input file, translating preprocessor tokens into a + parse 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). + +Code Generation and Optimization + This stage translates an AST into low-level intermediate code (known as + "LLVM IR") and ultimately to machine code. This phase is responsible for + optimizing the generated code and handling target-specific code generation. + The output of this stage is typically called a ".s" file or "assembly" file. + + Clang also supports the use of an integrated assembler, in which the code + generator produces object files directly. This avoids the overhead of + generating the ".s" file and of calling the target assembler. + +Assembler + This stage runs the target assembler to translate the output of the + compiler into a target object file. The output of this stage is typically + called a ".o" file or "object" file. + +Linker + This stage runs the target linker to merge multiple object files into an + executable or dynamic library. The output of this stage is typically called + an "a.out", ".dylib" or ".so" file. + +:program:`Clang Static Analyzer` + +The Clang Static Analyzer is a tool that scans source code to try to find bugs +through code analysis. This tool uses many parts of Clang and is built into +the same driver. Please see <http://clang-analyzer.llvm.org> for more details +on how to use the static analyzer. + +OPTIONS +------- + +Stage Selection Options +~~~~~~~~~~~~~~~~~~~~~~~ + +.. option:: -E + + Run the preprocessor stage. + +.. option:: -fsyntax-only + + Run the preprocessor, parser and type checking stages. + +.. option:: -S + + Run the previous stages as well as LLVM generation and optimization stages + and target-specific code generation, producing an assembly file. + +.. option:: -c + + Run all of the above, plus the assembler, generating a target ".o" object file. + +.. option:: no stage selection option + + If no stage selection option is specified, all stages above are run, and the + linker is run to combine the results into an executable or shared library. + +Language Selection and Mode Options +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. option:: -x <language> + + Treat subsequent input files as having type language. + +.. option:: -std=<language> + + Specify the language standard to compile for. + +.. option:: -stdlib=<library> + + Specify the C++ standard library to use; supported options are libstdc++ and + libc++. + +.. option:: -ansi + + Same as -std=c89. + +.. option:: -ObjC, -ObjC++ + + Treat source input files as Objective-C and Object-C++ inputs respectively. + +.. option:: -trigraphs + + Enable trigraphs. + +.. option:: -ffreestanding + + Indicate that the file should be compiled for a freestanding, not a hosted, + environment. + +.. option:: -fno-builtin + + Disable special handling and optimizations of builtin functions like + :c:func:`strlen` and :c:func:`malloc`. + +.. option:: -fmath-errno + + Indicate that math functions should be treated as updating :c:data:`errno`. + +.. option:: -fpascal-strings + + Enable support for Pascal-style strings with "\\pfoo". + +.. option:: -fms-extensions + + Enable support for Microsoft extensions. + +.. option:: -fmsc-version= + + Set _MSC_VER. Defaults to 1300 on Windows. Not set otherwise. + +.. option:: -fborland-extensions + + Enable support for Borland extensions. + +.. option:: -fwritable-strings + + Make all string literals default to writable. This disables uniquing of + strings and other optimizations. + +.. option:: -flax-vector-conversions + + Allow loose type checking rules for implicit vector conversions. + +.. option:: -fblocks + + Enable the "Blocks" language feature. + +.. option:: -fobjc-gc-only + + Indicate that Objective-C code should be compiled in GC-only mode, which only + works when Objective-C Garbage Collection is enabled. + +.. option:: -fobjc-gc + + Indicate that Objective-C code should be compiled in hybrid-GC mode, which + works with both GC and non-GC mode. + +.. option:: -fobjc-abi-version=version + + Select the Objective-C ABI version to use. Available versions are 1 (legacy + "fragile" ABI), 2 (non-fragile ABI 1), and 3 (non-fragile ABI 2). + +.. option:: -fobjc-nonfragile-abi-version=<version> + + Select the Objective-C non-fragile ABI version to use by default. This will + only be used as the Objective-C ABI when the non-fragile ABI is enabled + (either via :option:`-fobjc-nonfragile-abi`, or because it is the platform + default). + +.. option:: -fobjc-nonfragile-abi + + Enable use of the Objective-C non-fragile ABI. On platforms for which this is + the default ABI, it can be disabled with :option:`-fno-objc-nonfragile-abi`. + +Target Selection Options +~~~~~~~~~~~~~~~~~~~~~~~~ + +Clang fully supports cross compilation as an inherent part of its design. +Depending on how your version of Clang is configured, it may have support for a +number of cross compilers, or may only support a native target. + +.. option:: -arch <architecture> + + Specify the architecture to build for. + +.. option:: -mmacosx-version-min=<version> + + When building for Mac OS X, specify the minimum version supported by your + application. + +.. option:: -miphoneos-version-min + + When building for iPhone OS, specify the minimum version supported by your + application. + +.. option:: -march=<cpu> + + Specify that Clang should generate code for a specific processor family + member and later. For example, if you specify -march=i486, the compiler is + allowed to generate instructions that are valid on i486 and later processors, + but which may not exist on earlier ones. + + +Code Generation Options +~~~~~~~~~~~~~~~~~~~~~~~ + +.. option:: -O0, -O1, -O2, -O3, -Ofast, -Os, -Oz, -O, -O4 + + Specify which optimization level to use: + + :option:`-O0` Means "no optimization": this level compiles the fastest and + generates the most debuggable code. + + :option:`-O1` Somewhere between :option:`-O0` and :option:`-O2`. + + :option:`-O2` Moderate level of optimization which enables most + optimizations. + + :option:`-O3` Like :option:`-O2`, except that it enables optimizations that + take longer to perform or that may generate larger code (in an attempt to + make the program run faster). + + :option:`-Ofast` Enables all the optimizations from :option:`-O3` along + with other aggressive optimizations that may violate strict compliance with + language standards. + + :option:`-Os` Like :option:`-O2` with extra optimizations to reduce code + size. + + :option:`-Oz` Like :option:`-Os` (and thus :option:`-O2`), but reduces code + size further. + + :option:`-O` Equivalent to :option:`-O2`. + + :option:`-O4` and higher + + Currently equivalent to :option:`-O3` + +.. option:: -g + + Generate debug information. Note that Clang debug information works best at -O0. + +.. option:: -fstandalone-debug -fno-standalone-debug + + Clang supports a number of optimizations to reduce the size of debug + information in the binary. They work based on the assumption that the + debug type information can be spread out over multiple compilation units. + For instance, Clang will not emit type definitions for types that are not + needed by a module and could be replaced with a forward declaration. + Further, Clang will only emit type info for a dynamic C++ class in the + module that contains the vtable for the class. + + The :option:`-fstandalone-debug` option turns off these optimizations. + This is useful when working with 3rd-party libraries that don't come with + debug information. This is the default on Darwin. Note that Clang will + never emit type information for types that are not referenced at all by the + program. + +.. option:: -fexceptions + + Enable generation of unwind information. This allows exceptions to be thrown + through Clang compiled stack frames. This is on by default in x86-64. + +.. option:: -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 when it happens. + +.. option:: -fvisibility + + This flag sets the default visibility level. + +.. option:: -fcommon + + This flag specifies that variables without initializers get common linkage. + It can be disabled with :option:`-fno-common`. + +.. option:: -ftls-model=<model> + + Set the default thread-local storage (TLS) model to use for thread-local + variables. Valid values are: "global-dynamic", "local-dynamic", + "initial-exec" and "local-exec". The default is "global-dynamic". The default + model can be overridden with the tls_model attribute. The compiler will try + to choose a more efficient model if possible. + +.. option:: -flto, -emit-llvm + + Generate output files in LLVM formats, suitable for link time optimization. + When used with :option:`-S` this generates LLVM intermediate language + assembly files, otherwise this generates LLVM bitcode format object files + (which may be passed to the linker depending on the stage selection options). + +Driver Options +~~~~~~~~~~~~~~ + +.. option:: -### + + Print (but do not run) the commands to run for this compilation. + +.. option:: --help + + Display available options. + +.. option:: -Qunused-arguments + + Do not emit any warnings for unused driver arguments. + +.. option:: -Wa,<args> + + Pass the comma separated arguments in args to the assembler. + +.. option:: -Wl,<args> + + Pass the comma separated arguments in args to the linker. + +.. option:: -Wp,<args> + + Pass the comma separated arguments in args to the preprocessor. + +.. option:: -Xanalyzer <arg> + + Pass arg to the static analyzer. + +.. option:: -Xassembler <arg> + + Pass arg to the assembler. + +.. option:: -Xlinker <arg> + + Pass arg to the linker. + +.. option:: -Xpreprocessor <arg> + + Pass arg to the preprocessor. + +.. option:: -o <file> + + Write output to file. + +.. option:: -print-file-name=<file> + + Print the full library path of file. + +.. option:: -print-libgcc-file-name + + Print the library path for "libgcc.a". + +.. option:: -print-prog-name=<name> + + Print the full program path of name. + +.. option:: -print-search-dirs + + Print the paths used for finding libraries and programs. + +.. option:: -save-temps + + Save intermediate compilation results. + +.. option:: -integrated-as, -no-integrated-as + + Used to enable and disable, respectively, the use of the integrated + assembler. Whether the integrated assembler is on by default is target + dependent. + +.. option:: -time + + Time individual commands. + +.. option:: -ftime-report + + Print timing summary of each stage of compilation. + +.. option:: -v + + Show commands to run and use verbose output. + + +Diagnostics Options +~~~~~~~~~~~~~~~~~~~ + +.. option:: -fshow-column, -fshow-source-location, -fcaret-diagnostics, -fdiagnostics-fixit-info, -fdiagnostics-parseable-fixits, -fdiagnostics-print-source-range-info, -fprint-source-range-info, -fdiagnostics-show-option, -fmessage-length + + These options control how Clang prints out information about diagnostics + (errors and warnings). Please see the Clang User's Manual for more information. + +Preprocessor Options +~~~~~~~~~~~~~~~~~~~~ + +.. option:: -D<macroname>=<value> + + Adds an implicit #define into the predefines buffer which is read before the + source file is preprocessed. + +.. option:: -U<macroname> + + Adds an implicit #undef into the predefines buffer which is read before the + source file is preprocessed. + +.. option:: -include <filename> + + Adds an implicit #include into the predefines buffer which is read before the + source file is preprocessed. + +.. option:: -I<directory> + + Add the specified directory to the search path for include files. + +.. option:: -F<directory> + + Add the specified directory to the search path for framework include files. + +.. option:: -nostdinc + + Do not search the standard system directories or compiler builtin directories + for include files. + +.. option:: -nostdlibinc + + Do not search the standard system directories for include files, but do + search compiler builtin include directories. + +.. option:: -nobuiltininc + + Do not search clang's builtin directory for include files. + + +ENVIRONMENT +----------- + +.. envvar:: TMPDIR, TEMP, TMP + + These environment variables are checked, in order, for the location to write + temporary files used during the compilation process. + +.. envvar:: CPATH + + 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 delimiter, as used in the PATH environment variable. + + Empty components in the environment variable are ignored. + +.. envvar:: C_INCLUDE_PATH, OBJC_INCLUDE_PATH, CPLUS_INCLUDE_PATH, OBJCPLUS_INCLUDE_PATH + + These environment variables specify additional paths, as for :envvar:`CPATH`, which are + only used when processing the appropriate language. + +.. envvar:: MACOSX_DEPLOYMENT_TARGET + + If :option:`-mmacosx-version-min` is unspecified, the default deployment + target is read from this environment variable. This option only affects + Darwin targets. + +BUGS +---- + +To report bugs, please visit <http://llvm.org/bugs/>. Most bug reports should +include preprocessed source files (use the :option:`-E` option) and the full +output of the compiler, along with information to reproduce. + +SEE ALSO +-------- + +:manpage:`as(1)`, :manpage:`ld(1)` + diff --git a/docs/CommandGuide/index.rst b/docs/CommandGuide/index.rst new file mode 100644 index 000000000000..826ed9711980 --- /dev/null +++ b/docs/CommandGuide/index.rst @@ -0,0 +1,17 @@ +Clang "man" pages +----------------- + +The following documents are command descriptions for all of the Clang tools. +These pages describe how to use the Clang commands and what their options are. +Note that these pages do not describe all of the options available for all +tools. To get a complete listing, pass the ``--help`` (general options) or +``--help-hidden`` (general and debugging options) arguments to the tool you are +interested in. + +Basic Commands +~~~~~~~~~~~~~~ + +.. toctree:: + :maxdepth: 1 + + clang diff --git a/docs/DriverInternals.rst b/docs/DriverInternals.rst index 4cd2e5dfe6b4..6bc5f7dac952 100644 --- a/docs/DriverInternals.rst +++ b/docs/DriverInternals.rst @@ -155,7 +155,7 @@ The driver functionality is conceptually divided into five stages: Subsequent stages should rarely, if ever, need to do any string processing. -#. **Pipeline: Compilation Job Construction** +#. **Pipeline: Compilation Action Construction** Once the arguments are parsed, the tree of subprocess jobs needed for the desired compilation sequence are constructed. This involves @@ -266,7 +266,7 @@ The driver functionality is conceptually divided into five stages: #. **Translate: Tool Specific Argument Translation** Once a Tool has been selected to perform a particular Action, the - Tool must construct concrete Jobs which will be executed during + Tool must construct concrete Commands which will be executed during compilation. The main work is in translating from the gcc style command line options to whatever options the subprocess expects. @@ -280,7 +280,7 @@ The driver functionality is conceptually divided into five stages: last of arguments corresponding to some option, or all arguments for an option. - The result of this stage is a list of Jobs (executable paths and + The result of this stage is a list of Commands (executable paths and argument strings) to execute. #. **Execute** diff --git a/docs/LeakSanitizer.rst b/docs/LeakSanitizer.rst index b1071efd1aa2..d4b4fa02d730 100644 --- a/docs/LeakSanitizer.rst +++ b/docs/LeakSanitizer.rst @@ -17,7 +17,8 @@ only, at a minimal performance cost. Current status ============== -LeakSanitizer is experimental and supported only on x86\_64 Linux. +LeakSanitizer is turned on by default, but it is only supported on x86\_64 +Linux. The combined mode has been tested on fairly large software projects. The stand-alone mode has received much less testing. diff --git a/docs/LibASTMatchersReference.html b/docs/LibASTMatchersReference.html index 74bbf9e47334..a555bb339fc1 100644 --- a/docs/LibASTMatchersReference.html +++ b/docs/LibASTMatchersReference.html @@ -1434,6 +1434,16 @@ Usable as: Matcher<<a href="http://clang.llvm.org/doxygen/classclang_1_1Charac Matcher<<a href="http://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>>, Matcher<<a href="http://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>> </pre></td></tr> +<tr><td>Matcher<<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXCatchStmt.html">CXXCatchStmt</a>></td><td class="name" onclick="toggle('isCatchAll1')"><a name="isCatchAll1Anchor">isCatchAll</a></td><td></td></tr> +<tr><td colspan="4" class="doc" id="isCatchAll1"><pre>Matches a C++ catch statement that has a handler that catches any exception type. + +Example matches catch(...) (matcher = catchStmt(isCatchAll())) + try { + // ... + } catch(...) { + } +</pre></td></tr> + <tr><td>Matcher<<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>></td><td class="name" onclick="toggle('argumentCountIs1')"><a name="argumentCountIs1Anchor">argumentCountIs</a></td><td>unsigned N</td></tr> <tr><td colspan="4" class="doc" id="argumentCountIs1"><pre>Checks that a call expression or a constructor call expression has diff --git a/docs/Makefile b/docs/Makefile index 96978d893ef8..a409cf6025bd 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -8,7 +8,6 @@ ##===----------------------------------------------------------------------===## CLANG_LEVEL := .. -DIRS := tools ifdef BUILD_FOR_WEBSITE PROJ_OBJ_DIR = . diff --git a/docs/ObjectiveCLiterals.rst b/docs/ObjectiveCLiterals.rst index 8907c1efc77d..9fe7f66dffbf 100644 --- a/docs/ObjectiveCLiterals.rst +++ b/docs/ObjectiveCLiterals.rst @@ -119,8 +119,8 @@ Objective-C provides a new syntax for boxing C expressions: @( <expression> ) -Expressions of scalar (numeric, enumerated, BOOL) and C string pointer -types are supported: +Expressions of scalar (numeric, enumerated, BOOL), C string pointer +and some C structures (via NSValue) are supported: .. code-block:: objc @@ -136,6 +136,12 @@ types are supported: NSString *path = @(getenv("PATH")); // [NSString stringWithUTF8String:(getenv("PATH"))] NSArray *pathComponents = [path componentsSeparatedByString:@":"]; + // structs. + NSValue *center = @(view.center); // Point p = view.center; + // [NSValue valueWithBytes:&p objCType:@encode(Point)]; + NSValue *frame = @(view.frame); // Rect r = view.frame; + // [NSValue valueWithBytes:&r objCType:@encode(Rect)]; + Boxed Enums ----------- @@ -218,6 +224,42 @@ character data is valid. Passing ``NULL`` as the character pointer will raise an exception at runtime. When possible, the compiler will reject ``NULL`` character pointers used in boxed expressions. +Boxed C Structures +------------------ + +Boxed expressions support construction of NSValue objects. +It said that C structures can be used, the only requirement is: +structure should be marked with ``objc_boxable`` attribute. +To support older version of frameworks and/or third-party libraries +you may need to add the attribute via ``typedef``. + +.. code-block:: objc + + struct __attribute__((objc_boxable)) Point { + // ... + }; + + typedef struct __attribute__((objc_boxable)) _Size { + // ... + } Size; + + typedef struct _Rect { + // ... + } Rect; + + struct Point p; + NSValue *point = @(p); // ok + Size s; + NSValue *size = @(s); // ok + + Rect r; + NSValue *bad_rect = @(r); // error + + typedef struct __attribute__((objc_boxable)) _Rect Rect; + + NSValue *good_rect = @(r); // ok + + Container Literals ================== @@ -539,6 +581,22 @@ checks. Here are examples of their use: } #endif + #if __has_attribute(objc_boxable) + typedef struct __attribute__((objc_boxable)) _Rect Rect; + #endif + + #if __has_feature(objc_boxed_nsvalue_expressions) + CABasicAnimation animation = [CABasicAnimation animationWithKeyPath:@"position"]; + animation.fromValue = @(layer.position); + animation.toValue = @(newPosition); + [layer addAnimation:animation forKey:@"move"]; + #else + CABasicAnimation animation = [CABasicAnimation animationWithKeyPath:@"position"]; + animation.fromValue = [NSValue valueWithCGPoint:layer.position]; + animation.toValue = [NSValue valueWithCGPoint:newPosition]; + [layer addAnimation:animation forKey:@"move"]; + #endif + Code can use also ``__has_feature(objc_bool)`` to check for the availability of numeric literals support. This checks for the new ``__objc_yes / __objc_no`` keywords, which enable the use of diff --git a/docs/SafeStack.rst b/docs/SafeStack.rst index 5115d959954e..21e9b6c621a8 100644 --- a/docs/SafeStack.rst +++ b/docs/SafeStack.rst @@ -15,14 +15,17 @@ 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. +on the safe stack. + +SafeStack is a part of the `Code-Pointer Integrity (CPI) Project +<http://dslab.epfl.ch/proj/cpi/>`_. 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 +<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 @@ -34,37 +37,6 @@ 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 ------------- @@ -83,21 +55,73 @@ 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. +SafeStack supports linking statically modules that are compiled with and +without SafeStack. An executable compiled with SafeStack can load dynamic +libraries that are not compiled with SafeStack. At the moment, compiling +dynamic libraries with SafeStack is not supported. 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. +Security +-------- + +SafeStack protects return addresses, spilled registers and local variables that +are always accessed in a safe way by separating them in a dedicated safe stack +region. The safe stack is automatically protected against stack-based buffer +overflows, since it is disjoint from the unsafe stack in memory, and it itself +is always accessed in a safe way. In the current implementation, the safe stack +is protected against arbitrary memory write vulnerabilities though +randomization and information hiding: the safe stack is allocated at a random +address and the instrumentation ensures that no pointers to the safe stack are +ever stored outside of the safe stack itself (see limitations below). + +Known security limitations +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A complete protection against control-flow hijack attacks requires combining +SafeStack with another mechanism that enforces the integrity of code pointers +that are stored on the heap or the unsafe stack, such as `CPI +<http://dslab.epfl.ch/proj/cpi/>`_, or a forward-edge control flow integrity +mechanism that enforces correct calling conventions at indirect call sites, +such as `IFCC <http://research.google.com/pubs/archive/42808.pdf>`_ with arity +checks. Clang has control-flow integrity protection scheme for :doc:`C++ virtual +calls <ControlFlowIntegrity>`, but not non-virtual indirect calls. With +SafeStack alone, an attacker can overwrite a function pointer on the heap or +the unsafe stack and cause a program to call arbitrary location, which in turn +might enable stack pivoting and return-oriented programming. + +In its current implementation, SafeStack provides precise protection against +stack-based buffer overflows, but protection against arbitrary memory write +vulnerabilities is probabilistic and relies on randomization and information +hiding. The randomization is currently based on system-enforced ASLR and shares +its known security limitations. The safe stack pointer hiding is not perfect +yet either: system library functions such as ``swapcontext``, exception +handling mechanisms, intrinsics such as ``__builtin_frame_address``, or +low-level bugs in runtime support could leak the safe stack pointer. In the +future, such leaks could be detected by static or dynamic analysis tools and +prevented by adjusting such functions to either encrypt the stack pointer when +storing it in the heap (as already done e.g., by ``setjmp``/``longjmp`` +implementation in glibc), or store it in a safe region instead. + +The `CPI paper <http://dslab.epfl.ch/pubs/cpi.pdf>`_ describes two alternative, +stronger safe stack protection mechanisms, that rely on software fault +isolation, or hardware segmentation (as available on x86-32 and some x86-64 +CPUs). + +At the moment, SafeStack assumes that the compiler's implementation is correct. +This has not been verified except through manual code inspection, and could +always regress in the future. It's therefore desirable to have a separate +static or dynamic binary verification tool that would check the correctness of +the SafeStack instrumentation in final binaries. + Usage ===== -To enable SafeStack, just pass ``-fsanitize=safe-stack`` flag to both compile and link -command lines. +To enable SafeStack, just pass ``-fsanitize=safe-stack`` flag to both compile +and link command lines. Supported Platforms ------------------- @@ -129,10 +153,11 @@ 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. - +All local variables in functions with this attribute will be stored on the safe +stack. The safe stack remains unprotected against memory errors when accessing +these variables, so extra care must be taken to manually ensure that all such +accesses are safe. Furthermore, the addresses of such local variables should +never be stored on the heap, as it would leak the location of the SafeStack. ``__builtin___get_unsafe_stack_ptr()`` ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -149,15 +174,14 @@ 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. - +Please refer to the `Code-Pointer Integrity <http://dslab.epfl.ch/proj/cpi/>`__ +project page for more information about the design of the SafeStack and its +related technologies. Publications ------------ -`Code-Pointer Integrity <http://dslab.epfl.ch/pubs/cpi.pdf>`_. +`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/conf.py b/docs/conf.py index 9030c2c28754..b7ed23ac66d2 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -41,7 +41,7 @@ master_doc = 'index' # General information about the project. project = u'Clang' -copyright = u'2007-2014, The Clang Team' +copyright = u'2007-2015, The Clang Team' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the @@ -212,10 +212,40 @@ latex_documents = [ # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). -man_pages = [ - ('index', 'clang', u'Clang Documentation', - [u'The Clang Team'], 1) -] +man_pages = [] + +# Automatically derive the list of man pages from the contents of the command +# guide subdirectory. This was copied from llvm/docs/conf.py. +basedir = os.path.dirname(__file__) +man_page_authors = u'Maintained by the Clang / LLVM Team (<http://clang.llvm.org>)' +command_guide_subpath = 'CommandGuide' +command_guide_path = os.path.join(basedir, command_guide_subpath) +for name in os.listdir(command_guide_path): + # Ignore non-ReST files and the index page. + if not name.endswith('.rst') or name in ('index.rst',): + continue + + # Otherwise, automatically extract the description. + file_subpath = os.path.join(command_guide_subpath, name) + with open(os.path.join(command_guide_path, name)) as f: + title = f.readline().rstrip('\n') + header = f.readline().rstrip('\n') + + if len(header) != len(title): + print >>sys.stderr, ( + "error: invalid header in %r (does not match title)" % ( + file_subpath,)) + if ' - ' not in title: + print >>sys.stderr, ( + ("error: invalid title in %r " + "(expected '<name> - <description>')") % ( + file_subpath,)) + + # Split the name out of the title. + name,description = title.split(' - ', 1) + man_pages.append((file_subpath.replace('.rst',''), name, + description, man_page_authors, 1)) + # If true, show URL addresses after external links. #man_show_urls = False diff --git a/docs/index.rst b/docs/index.rst index dec2bc828c1c..d50667d56691 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -32,6 +32,7 @@ Using Clang as a Compiler SafeStack Modules MSVCCompatibility + CommandGuide/index FAQ Using Clang as a Library diff --git a/docs/tools/Makefile b/docs/tools/Makefile deleted file mode 100644 index 5521d6b764c9..000000000000 --- a/docs/tools/Makefile +++ /dev/null @@ -1,116 +0,0 @@ -##===- docs/tools/Makefile ---------------------------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## - -ifdef BUILD_FOR_WEBSITE - -# FIXME: This was copied from the CommandGuide makefile. Figure out -# how to get this stuff on the website. - -# This special case is for keeping the CommandGuide on the LLVM web site -# up to date automatically as the documents are checked in. It must build -# the POD files to HTML only and keep them in the src directories. It must also -# build in an unconfigured tree, hence the ifdef. To use this, run -# make -s BUILD_FOR_WEBSITE=1 inside the cvs commit script. -SRC_DOC_DIR= -DST_HTML_DIR=html/ -DST_MAN_DIR=man/man1/ -DST_PS_DIR=ps/ -CLANG_VERSION := trunk - -# If we are in BUILD_FOR_WEBSITE mode, default to the all target. -all:: html man ps - -clean: - rm -f pod2htm*.*~~ $(HTML) $(MAN) $(PS) - -# To create other directories, as needed, and timestamp their creation -%/.dir: - -mkdir $* > /dev/null - date > $@ - -else - -# Otherwise, if not in BUILD_FOR_WEBSITE mode, use the project info. -CLANG_LEVEL := ../.. -include $(CLANG_LEVEL)/Makefile - -CLANG_VERSION := $(word 3,$(shell grep "CLANG_VERSION " \ - $(PROJ_OBJ_DIR)/$(CLANG_LEVEL)/include/clang/Basic/Version.inc)) - -SRC_DOC_DIR=$(PROJ_SRC_DIR)/ -DST_HTML_DIR=$(PROJ_OBJ_DIR)/ -DST_MAN_DIR=$(PROJ_OBJ_DIR)/ -DST_PS_DIR=$(PROJ_OBJ_DIR)/ - -endif - - -POD := $(wildcard $(SRC_DOC_DIR)*.pod) -HTML := $(patsubst $(SRC_DOC_DIR)%.pod, $(DST_HTML_DIR)%.html, $(POD)) -MAN := $(patsubst $(SRC_DOC_DIR)%.pod, $(DST_MAN_DIR)%.1, $(POD)) -PS := $(patsubst $(SRC_DOC_DIR)%.pod, $(DST_PS_DIR)%.ps, $(POD)) - -ifdef ONLY_MAN_DOCS -INSTALL_TARGETS := install-man -else -INSTALL_TARGETS := install-html install-man install-ps -endif - -.SUFFIXES: -.SUFFIXES: .html .pod .1 .ps - -$(DST_HTML_DIR)%.html: %.pod $(DST_HTML_DIR)/.dir - pod2html --css=manpage.css --htmlroot=. \ - --podpath=. --infile=$< --outfile=$@ --title=$* - -$(DST_MAN_DIR)%.1: %.pod $(DST_MAN_DIR)/.dir - pod2man --release "clang $(CLANG_VERSION)" --center="Clang Tools Documentation" $< $@ - -$(DST_PS_DIR)%.ps: $(DST_MAN_DIR)%.1 $(DST_PS_DIR)/.dir - groff -Tps -man $< > $@ - - -html: $(HTML) -man: $(MAN) -ps: $(PS) - -EXTRA_DIST := $(POD) - -clean-local:: - $(Verb) $(RM) -f pod2htm*.*~~ $(HTML) $(MAN) $(PS) - -HTML_DIR := $(DESTDIR)$(PROJ_docsdir)/html/clang -MAN_DIR := $(DESTDIR)$(PROJ_mandir)/man1 -PS_DIR := $(DESTDIR)$(PROJ_docsdir)/ps - -install-html:: $(HTML) - $(Echo) Installing HTML Clang Tools Documentation - $(Verb) $(MKDIR) $(HTML_DIR) - $(Verb) $(DataInstall) $(HTML) $(HTML_DIR) - $(Verb) $(DataInstall) $(PROJ_SRC_DIR)/manpage.css $(HTML_DIR) - -install-man:: $(MAN) - $(Echo) Installing MAN Clang Tools Documentation - $(Verb) $(MKDIR) $(MAN_DIR) - $(Verb) $(DataInstall) $(MAN) $(MAN_DIR) - -install-ps:: $(PS) - $(Echo) Installing PS Clang Tools Documentation - $(Verb) $(MKDIR) $(PS_DIR) - $(Verb) $(DataInstall) $(PS) $(PS_DIR) - -install-local:: $(INSTALL_TARGETS) - -uninstall-local:: - $(Echo) Uninstalling Clang Tools Documentation - $(Verb) $(RM) -rf $(HTML_DIR) $(MAN_DIR) $(PS_DIR) - -printvars:: - $(Echo) "POD : " '$(POD)' - $(Echo) "HTML : " '$(HTML)' diff --git a/docs/tools/clang.pod b/docs/tools/clang.pod deleted file mode 100644 index 153f97b2caa0..000000000000 --- a/docs/tools/clang.pod +++ /dev/null @@ -1,614 +0,0 @@ -=pod - -=head1 NAME - -clang - the Clang C, C++, and Objective-C compiler - -=head1 SYNOPSIS - -B<clang> [B<-c>|B<-S>|B<-E>] B<-std=>I<standard> B<-g> - [B<-O0>|B<-O1>|B<-O2>|B<-O3>|B<-Ofast>|B<-Os>|B<-Oz>|B<-O>|B<-O4>] - B<-W>I<warnings...> B<-pedantic> - B<-I>I<dir...> B<-L>I<dir...> - B<-D>I<macro[=defn]> - B<-f>I<feature-option...> - B<-m>I<machine-option...> - B<-o> I<output-file> - B<-stdlib=>I<library> - I<input-filenames> - -=head1 DESCRIPTION - -B<clang> is a C, C++, and Objective-C compiler which encompasses preprocessing, -parsing, optimization, code generation, assembly, and linking. Depending on -which high-level mode setting is passed, Clang will stop before doing a full -link. While Clang is highly integrated, it is important to understand the -stages of compilation, to understand how to invoke it. These stages are: - -=over - -=item B<Driver> - -The B<clang> executable is actually a small driver which controls the overall -execution of other tools such as the compiler, assembler and linker. Typically -you do not need to interact with the driver, but you transparently use it to run -the other tools. - -=item B<Preprocessing> - -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. - -=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 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). - -=item B<Code Generation and Optimization> - -This stage translates an AST into low-level intermediate code (known as "LLVM -IR") and ultimately to machine code. This phase is responsible for optimizing -the generated code and handling target-specific code generation. The output of -this stage is typically called a ".s" file or "assembly" file. - -Clang also supports the use of an integrated assembler, in which the code -generator produces object files directly. This avoids the overhead of generating -the ".s" file and of calling the target assembler. - -=item B<Assembler> - -This stage runs the target assembler to translate the output of the compiler -into a target object file. The output of this stage is typically called a ".o" -file or "object" file. - -=item B<Linker> - -This stage runs the target linker to merge multiple object files into an -executable or dynamic library. The output of this stage is typically called an -"a.out", ".dylib" or ".so" file. - -=back - -The Clang compiler supports a large number of options to control each of these -stages. In addition to compilation of code, Clang also supports other tools: - -B<Clang Static Analyzer> - -The Clang Static Analyzer is a tool that scans source code to try to find bugs -through code analysis. This tool uses many parts of Clang and is built into the -same driver. Please see L<http://clang-analyzer.llvm.org> for more details -on how to use the static analyzer. - - -=head1 OPTIONS - -=head2 Stage Selection Options - -=over - -=item B<-E> - -Run the preprocessor stage. - -=item B<-fsyntax-only> - -Run the preprocessor, parser and type checking stages. - -=item B<-S> - -Run the previous stages as well as LLVM generation and optimization stages and -target-specific code generation, producing an assembly file. - -=item B<-c> - -Run all of the above, plus the assembler, generating a target ".o" object file. - -=item B<no stage selection option> - -If no stage selection option is specified, all stages above are run, and the -linker is run to combine the results into an executable or shared library. - -=back - - - -=head2 Language Selection and Mode Options - -=over - -=item B<-x> I<language> - -Treat subsequent input files as having type I<language>. - -=item B<-std>=I<language> - -Specify the language standard to compile for. - -=item B<-stdlib>=I<library> - -Specify the C++ standard library to use; supported options are libstdc++ and -libc++. - -=item B<-ansi> - -Same as B<-std=c89>. - -=item B<-ObjC++> - -Treat source input files as Objective-C++ inputs. - -=item B<-ObjC> - -Treat source input files as Objective-C inputs. - -=item B<-trigraphs> - -Enable trigraphs. - -=item B<-ffreestanding> - -Indicate that the file should be compiled for a freestanding, not a hosted, -environment. - -=item B<-fno-builtin> - -Disable special handling and optimizations of builtin functions like strlen and -malloc. - -=item B<-fmath-errno> - -Indicate that math functions should be treated as updating errno. - -=item B<-fpascal-strings> - -Enable support for Pascal-style strings with "\pfoo". - -=item B<-fms-extensions> - -Enable support for Microsoft extensions. - -=item B<-fmsc-version=> - -Set _MSC_VER. Defaults to 1300 on Windows. Not set otherwise. - -=item B<-fborland-extensions> - -Enable support for Borland extensions. - -=item B<-fwritable-strings> - -Make all string literals default to writable. This disables uniquing of -strings and other optimizations. - -=item B<-flax-vector-conversions> - -Allow loose type checking rules for implicit vector conversions. - -=item B<-fblocks> - -Enable the "Blocks" language feature. - -=item B<-fobjc-gc-only> - -Indicate that Objective-C code should be compiled in GC-only mode, which only -works when Objective-C Garbage Collection is enabled. - -=item B<-fobjc-gc> - -Indicate that Objective-C code should be compiled in hybrid-GC mode, which works -with both GC and non-GC mode. - -=item B<-fobjc-abi-version>=I<version> - -Select the Objective-C ABI version to use. Available versions are 1 (legacy -"fragile" ABI), 2 (non-fragile ABI 1), and 3 (non-fragile ABI 2). - -=item B<-fobjc-nonfragile-abi-version>=I<version> - -Select the Objective-C non-fragile ABI version to use by default. This will only -be used as the Objective-C ABI when the non-fragile ABI is enabled (either via --fobjc-nonfragile-abi, or because it is the platform default). - -=item B<-fobjc-nonfragile-abi> - -Enable use of the Objective-C non-fragile ABI. On platforms for which this is -the default ABI, it can be disabled with B<-fno-objc-nonfragile-abi>. - -=back - - - -=head2 Target Selection Options - -Clang fully supports cross compilation as an inherent part of its design. -Depending on how your version of Clang is configured, it may have support for -a number of cross compilers, or may only support a native target. - -=over - -=item B<-arch> I<architecture> - -Specify the architecture to build for. - -=item B<-mmacosx-version-min>=I<version> - -When building for Mac OS X, specify the minimum version supported by your -application. - -=item B<-miphoneos-version-min> - -When building for iPhone OS, specify the minimum version supported by your -application. - - -=item B<-march>=I<cpu> - -Specify that Clang should generate code for a specific processor family member -and later. For example, if you specify -march=i486, the compiler is allowed to -generate instructions that are valid on i486 and later processors, but which -may not exist on earlier ones. - -=back - - -=head2 Code Generation Options - -=over - -=item B<-O0> B<-O1> B<-O2> B<-O3> B<-Ofast> B<-Os> B<-Oz> B<-O> B<-O4> - -Specify which optimization level to use: - -=over - -=item B<-O0> - -Means "no optimization": this level compiles the fastest and -generates the most debuggable code. - -=item B<-O1> - -Somewhere between B<-O0> and B<-O2>. - -=item B<-O2> - -Moderate level of optimization which enables most optimizations. - -=item B<-O3> - -Like B<-O2>, except that it enables optimizations that take longer to perform -or that may generate larger code (in an attempt to make the program run faster). - -=item B<-Ofast> - -Enables all the optimizations from B<-O3> along with other aggressive -optimizations that may violate strict compliance with language standards. - -=item B<-Os> - -Like B<-O2> with extra optimizations to reduce code size. - -=item B<-Oz> - -Like B<-Os> (and thus B<-O2>), but reduces code size further. - -=item B<-O> - -Equivalent to B<-O2>. - -=item B<-O4> and higher - -Currently equivalent to B<-O3> - -=back - -=item B<-g> - -Generate debug information. Note that Clang debug information works best at -B<-O0>. - -=item B<-fstandalone-debug> B<-fno-standalone-debug> - -Clang supports a number of optimizations to reduce the size of debug -information in the binary. They work based on the assumption that the -debug type information can be spread out over multiple compilation -units. For instance, Clang will not emit type definitions for types -that are not needed by a module and could be replaced with a forward -declaration. Further, Clang will only emit type info for a dynamic -C++ class in the module that contains the vtable for the class. - -The B<-fstandalone-debug> option turns off these optimizations. This -is useful when working with 3rd-party libraries that don't come with -debug information. This is the default on Darwin. Note that Clang -will never emit type information for types that are not referenced at -all by the program. - -=item B<-fexceptions> - -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 -when it happens. - - -=item B<-fvisibility> - -This flag sets the default visibility level. - -=item B<-fcommon> - -This flag specifies that variables without initializers get common linkage. It -can be disabled with B<-fno-common>. - -=item B<-ftls-model> - -Set the default thread-local storage (TLS) model to use for thread-local -variables. Valid values are: "global-dynamic", "local-dynamic", "initial-exec" -and "local-exec". The default is "global-dynamic". The default model can be -overridden with the tls_model attribute. The compiler will try to choose a more -efficient model if possible. - -=item B<-flto> B<-emit-llvm> - -Generate output files in LLVM formats, suitable for link time optimization. When -used with B<-S> this generates LLVM intermediate language assembly files, -otherwise this generates LLVM bitcode format object files (which may be passed -to the linker depending on the stage selection options). - -=cut - -##=item B<-fnext-runtime> B<-fobjc-nonfragile-abi> B<-fgnu-runtime> -##These options specify which Objective-C runtime the code generator should -##target. FIXME: we don't want people poking these generally. - -=pod - -=back - - -=head2 Driver Options - -=over - -=item B<-###> - -Print (but do not run) the commands to run for this compilation. - -=item B<--help> - -Display available options. - -=item B<-Qunused-arguments> - -Do not emit any warnings for unused driver arguments. - -=item B<-Wa,>I<args> - -Pass the comma separated arguments in I<args> to the assembler. - -=item B<-Wl,>I<args> - -Pass the comma separated arguments in I<args> to the linker. - -=item B<-Wp,>I<args> - -Pass the comma separated arguments in I<args> to the preprocessor. - -=item B<-Xanalyzer> I<arg> - -Pass I<arg> to the static analyzer. - -=item B<-Xassembler> I<arg> - -Pass I<arg> to the assembler. - -=item B<-Xlinker> I<arg> - -Pass I<arg> to the linker. - -=item B<-Xpreprocessor> I<arg> - -Pass I<arg> to the preprocessor. - -=item B<-o> I<file> - -Write output to I<file>. - -=item B<-print-file-name>=I<file> - -Print the full library path of I<file>. - -=item B<-print-libgcc-file-name> - -Print the library path for "libgcc.a". - -=item B<-print-prog-name>=I<name> - -Print the full program path of I<name>. - -=item B<-print-search-dirs> - -Print the paths used for finding libraries and programs. - -=item B<-save-temps> - -Save intermediate compilation results. - -=item B<-integrated-as> B<-no-integrated-as> - -Used to enable and disable, respectively, the use of the integrated -assembler. Whether the integrated assembler is on by default is target -dependent. - -=item B<-time> - -Time individual commands. - -=item B<-ftime-report> - -Print timing summary of each stage of compilation. - -=item B<-v> - -Show commands to run and use verbose output. - -=back - - -=head2 Diagnostics Options - -=over - -=item B<-fshow-column> -B<-fshow-source-location> -B<-fcaret-diagnostics> -B<-fdiagnostics-fixit-info> -B<-fdiagnostics-parseable-fixits> -B<-fdiagnostics-print-source-range-info> -B<-fprint-source-range-info> -B<-fdiagnostics-show-option> -B<-fmessage-length> - -These options control how Clang prints out information about diagnostics (errors -and warnings). Please see the Clang User's Manual for more information. - -=back - - -=head2 Preprocessor Options - -=over - -=item B<-D>I<macroname=value> - -Adds an implicit #define into the predefines buffer which is read before the -source file is preprocessed. - -=item B<-U>I<macroname> - -Adds an implicit #undef into the predefines buffer which is read before the -source file is preprocessed. - -=item B<-include> I<filename> - -Adds an implicit #include into the predefines buffer which is read before the -source file is preprocessed. - -=item B<-I>I<directory> - -Add the specified directory to the search path for include files. - -=item B<-F>I<directory> - -Add the specified directory to the search path for framework include files. - -=item B<-nostdinc> - -Do not search the standard system directories or compiler builtin directories -for include files. - -=item B<-nostdlibinc> - -Do not search the standard system directories for include files, but do search -compiler builtin include directories. - -=item B<-nobuiltininc> - -Do not search clang's builtin directory for include files. - -=cut - -## TODO, but do we really want people using this stuff? -#=item B<-idirafter>I<directory> -#=item B<-iquote>I<directory> -#=item B<-isystem>I<directory> -#=item B<-iprefix>I<directory> -#=item B<-iwithprefix>I<directory> -#=item B<-iwithprefixbefore>I<directory> -#=item B<-isysroot> - -=pod - - -=back - - - -=cut - -### TODO someday. -#=head2 Warning Control Options -#=over -#=back -#=head2 Code Generation and Optimization Options -#=over -#=back -#=head2 Assembler Options -#=over -#=back -#=head2 Linker Options -#=over -#=back -#=head2 Static Analyzer Options -#=over -#=back - -=pod - - -=head1 ENVIRONMENT - -=over - -=item B<TMPDIR>, B<TEMP>, B<TMP> - -These environment variables are checked, in order, for the location to -write temporary files used during the compilation process. - -=item B<CPATH> - -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 delimiter, as used in the I<PATH> -environment variable. - -Empty components in the environment variable are ignored. - -=item B<C_INCLUDE_PATH>, B<OBJC_INCLUDE_PATH>, B<CPLUS_INCLUDE_PATH>, -B<OBJCPLUS_INCLUDE_PATH> - -These environment variables specify additional paths, as for CPATH, -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 -targets. - -=back - -=head1 BUGS - -To report bugs, please visit L<http://llvm.org/bugs/>. Most bug reports should -include preprocessed source files (use the B<-E> option) and the full output of -the compiler, along with information to reproduce. - -=head1 SEE ALSO - - as(1), ld(1) - -=head1 AUTHOR - -Maintained by the Clang / LLVM Team (L<http://clang.llvm.org>). - -=cut diff --git a/docs/tools/manpage.css b/docs/tools/manpage.css deleted file mode 100644 index c922564dc3c3..000000000000 --- a/docs/tools/manpage.css +++ /dev/null @@ -1,256 +0,0 @@ -/* Based on http://www.perldoc.com/css/perldoc.css */ - -@import url("../llvm.css"); - -body { font-family: Arial,Helvetica; } - -blockquote { margin: 10pt; } - -h1, a { color: #336699; } - - -/*** Top menu style ****/ -.mmenuon { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #ff6600; font-size: 10pt; -} -.mmenuoff { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #ffffff; font-size: 10pt; -} -.cpyright { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #ffffff; font-size: xx-small; -} -.cpyrightText { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #ffffff; font-size: xx-small; -} -.sections { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #336699; font-size: 11pt; -} -.dsections { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #336699; font-size: 12pt; -} -.slink { - font-family: Arial,Helvetica; font-weight: normal; text-decoration: none; - color: #000000; font-size: 9pt; -} - -.slink2 { font-family: Arial,Helvetica; text-decoration: none; color: #336699; } - -.maintitle { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #336699; font-size: 18pt; -} -.dblArrow { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #336699; font-size: small; -} -.menuSec { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #336699; font-size: small; -} - -.newstext { - font-family: Arial,Helvetica; font-size: small; -} - -.linkmenu { - font-family: Arial,Helvetica; color: #000000; font-weight: bold; - text-decoration: none; -} - -P { - font-family: Arial,Helvetica; -} - -PRE { - font-size: 10pt; -} -.quote { - font-family: Times; text-decoration: none; - color: #000000; font-size: 9pt; font-style: italic; -} -.smstd { font-family: Arial,Helvetica; color: #000000; font-size: x-small; } -.std { font-family: Arial,Helvetica; color: #000000; } -.meerkatTitle { - font-family: sans-serif; font-size: x-small; color: black; } - -.meerkatDescription { font-family: sans-serif; font-size: 10pt; color: black } -.meerkatCategory { - font-family: sans-serif; font-size: 9pt; font-weight: bold; font-style: italic; - color: brown; } -.meerkatChannel { - font-family: sans-serif; font-size: 9pt; font-style: italic; color: brown; } -.meerkatDate { font-family: sans-serif; font-size: xx-small; color: #336699; } - -.tocTitle { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #333333; font-size: 10pt; -} - -.toc-item { - font-family: Arial,Helvetica; font-weight: bold; - color: #336699; font-size: 10pt; text-decoration: underline; -} - -.perlVersion { - font-family: Arial,Helvetica; font-weight: bold; - color: #336699; font-size: 10pt; text-decoration: none; -} - -.podTitle { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #000000; -} - -.docTitle { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #000000; font-size: 10pt; -} -.dotDot { - font-family: Arial,Helvetica; font-weight: bold; - color: #000000; font-size: 9pt; -} - -.docSec { - font-family: Arial,Helvetica; font-weight: normal; - color: #333333; font-size: 9pt; -} -.docVersion { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #336699; font-size: 10pt; -} - -.docSecs-on { - font-family: Arial,Helvetica; font-weight: normal; text-decoration: none; - color: #ff0000; font-size: 10pt; -} -.docSecs-off { - font-family: Arial,Helvetica; font-weight: normal; text-decoration: none; - color: #333333; font-size: 10pt; -} - -h2 { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #336699; font-size: medium; -} -h1 { - font-family: Verdana,Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #336699; font-size: large; -} - -DL { - font-family: Arial,Helvetica; font-weight: normal; text-decoration: none; - color: #333333; font-size: 10pt; -} - -UL > LI > A { - font-family: Arial,Helvetica; font-weight: bold; - color: #336699; font-size: 10pt; -} - -.moduleInfo { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #333333; font-size: 11pt; -} - -.moduleInfoSec { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #336699; font-size: 10pt; -} - -.moduleInfoVal { - font-family: Arial,Helvetica; font-weight: normal; text-decoration: underline; - color: #000000; font-size: 10pt; -} - -.cpanNavTitle { - font-family: Arial,Helvetica; font-weight: bold; - color: #ffffff; font-size: 10pt; -} -.cpanNavLetter { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #333333; font-size: 9pt; -} -.cpanCat { - font-family: Arial,Helvetica; font-weight: bold; text-decoration: none; - color: #336699; font-size: 9pt; -} - -.bttndrkblue-bkgd-top { - background-color: #225688; - background-image: url(/global/mvc_objects/images/bttndrkblue_bgtop.gif); -} -.bttndrkblue-bkgd-left { - background-color: #225688; - background-image: url(/global/mvc_objects/images/bttndrkblue_bgleft.gif); -} -.bttndrkblue-bkgd { - padding-top: 0px; - padding-bottom: 0px; - margin-bottom: 0px; - margin-top: 0px; - background-repeat: no-repeat; - background-color: #225688; - background-image: url(/global/mvc_objects/images/bttndrkblue_bgmiddle.gif); - vertical-align: top; -} -.bttndrkblue-bkgd-right { - background-color: #225688; - background-image: url(/global/mvc_objects/images/bttndrkblue_bgright.gif); -} -.bttndrkblue-bkgd-bottom { - background-color: #225688; - background-image: url(/global/mvc_objects/images/bttndrkblue_bgbottom.gif); -} -.bttndrkblue-text a { - color: #ffffff; - text-decoration: none; -} -a.bttndrkblue-text:hover { - color: #ffDD3C; - text-decoration: none; -} -.bg-ltblue { - background-color: #f0f5fa; -} - -.border-left-b { - background: #f0f5fa url(/i/corner-leftline.gif) repeat-y; -} - -.border-right-b { - background: #f0f5fa url(/i/corner-rightline.gif) repeat-y; -} - -.border-top-b { - background: #f0f5fa url(/i/corner-topline.gif) repeat-x; -} - -.border-bottom-b { - background: #f0f5fa url(/i/corner-botline.gif) repeat-x; -} - -.border-right-w { - background: #ffffff url(/i/corner-rightline.gif) repeat-y; -} - -.border-top-w { - background: #ffffff url(/i/corner-topline.gif) repeat-x; -} - -.border-bottom-w { - background: #ffffff url(/i/corner-botline.gif) repeat-x; -} - -.bg-white { - background-color: #ffffff; -} - -.border-left-w { - background: #ffffff url(/i/corner-leftline.gif) repeat-y; -} diff --git a/examples/analyzer-plugin/MainCallChecker.cpp b/examples/analyzer-plugin/MainCallChecker.cpp index 2ad8c8416a5e..a6f69fd175bc 100644 --- a/examples/analyzer-plugin/MainCallChecker.cpp +++ b/examples/analyzer-plugin/MainCallChecker.cpp @@ -37,9 +37,10 @@ void MainCallChecker::checkPreStmt(const CallExpr *CE, CheckerContext &C) const if (!BT) BT.reset(new BugType(this, "call to main", "example analyzer plugin")); - BugReport *report = new BugReport(*BT, BT->getName(), N); + std::unique_ptr<BugReport> report = + llvm::make_unique<BugReport>(*BT, BT->getName(), N); report->addRange(Callee->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); } } diff --git a/include/clang-c/Index.h b/include/clang-c/Index.h index a2241802078e..fad9cfa61b3c 100644 --- a/include/clang-c/Index.h +++ b/include/clang-c/Index.h @@ -2225,12 +2225,19 @@ enum CXCursorKind { */ CXCursor_OMPTeamsDirective = 253, - /** \brief OpenMP taskwait directive. + /** \brief OpenMP taskgroup directive. */ CXCursor_OMPTaskgroupDirective = 254, + /** \brief OpenMP cancellation point directive. + */ + CXCursor_OMPCancellationPointDirective = 255, + + /** \brief OpenMP cancel directive. + */ + CXCursor_OMPCancelDirective = 256, - CXCursor_LastStmt = CXCursor_OMPTaskgroupDirective, + CXCursor_LastStmt = CXCursor_OMPCancelDirective, /** * \brief Cursor that represents the translation unit itself. diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h index da288c4fe5ed..682be3d41513 100644 --- a/include/clang/AST/ASTContext.h +++ b/include/clang/AST/ASTContext.h @@ -1664,6 +1664,9 @@ public: TypeInfo getTypeInfo(const Type *T) const; TypeInfo getTypeInfo(QualType T) const { return getTypeInfo(T.getTypePtr()); } + /// \brief Get default simd alignment of the specified complete type in bits. + unsigned getOpenMPDefaultSimdAlign(QualType T) const; + /// \brief Return the size of the specified (complete) type \p T, in bits. uint64_t getTypeSize(QualType T) const { return getTypeInfo(T).Width; } uint64_t getTypeSize(const Type *T) const { return getTypeInfo(T).Width; } @@ -1780,6 +1783,17 @@ public: /// \param method should be the declaration from the class definition void setNonKeyFunction(const CXXMethodDecl *method); + /// Loading virtual member pointers using the virtual inheritance model + /// always results in an adjustment using the vbtable even if the index is + /// zero. + /// + /// This is usually OK because the first slot in the vbtable points + /// backwards to the top of the MDC. However, the MDC might be reusing a + /// vbptr from an nv-base. In this case, the first slot in the vbtable + /// points to the start of the nv-base which introduced the vbptr and *not* + /// the MDC. Modify the NonVirtualBaseAdjustment to account for this. + CharUnits getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const; + /// Get the offset of a FieldDecl or IndirectFieldDecl, in bits. uint64_t getFieldOffset(const ValueDecl *FD) const; diff --git a/include/clang/AST/ASTMutationListener.h b/include/clang/AST/ASTMutationListener.h index 4f3acc3a75c1..f4026e952643 100644 --- a/include/clang/AST/ASTMutationListener.h +++ b/include/clang/AST/ASTMutationListener.h @@ -14,6 +14,7 @@ #define LLVM_CLANG_AST_ASTMUTATIONLISTENER_H namespace clang { + class Attr; class ClassTemplateDecl; class ClassTemplateSpecializationDecl; class CXXDestructorDecl; @@ -29,6 +30,7 @@ namespace clang { class ObjCInterfaceDecl; class ObjCPropertyDecl; class QualType; + class RecordDecl; class TagDecl; class VarDecl; class VarTemplateDecl; @@ -119,6 +121,14 @@ public: /// \param M The containing module in which the definition was made visible, /// if any. virtual void RedefinedHiddenDefinition(const NamedDecl *D, Module *M) {} + + /// \brief An attribute was added to a RecordDecl + /// + /// \param Attr The attribute that was added to the Record + /// + /// \param Record The RecordDecl that got a new attribute + virtual void AddedAttributeToRecord(const Attr *Attr, + const RecordDecl *Record) {} // NOTE: If new methods are added they should also be added to // MultiplexASTMutationListener. diff --git a/include/clang/AST/DataRecursiveASTVisitor.h b/include/clang/AST/DataRecursiveASTVisitor.h index ef8817659338..923d98fb1664 100644 --- a/include/clang/AST/DataRecursiveASTVisitor.h +++ b/include/clang/AST/DataRecursiveASTVisitor.h @@ -1861,8 +1861,8 @@ DEF_TRAVERSE_DECL(ParmVarDecl, { TRY_TO(WalkUpFrom##STMT(S)); \ StmtQueueAction StmtQueue(*this); \ { CODE; } \ - for (Stmt::child_range range = S->children(); range; ++range) { \ - StmtQueue.queue(*range); \ + for (Stmt *SubStmt : S->children()) { \ + StmtQueue.queue(SubStmt); \ } \ return true; \ } @@ -2011,8 +2011,8 @@ bool RecursiveASTVisitor<Derived>::TraverseInitListExpr(InitListExpr *S) { TRY_TO(WalkUpFromInitListExpr(S)); StmtQueueAction StmtQueue(*this); // All we need are the default actions. FIXME: use a helper function. - for (Stmt::child_range range = S->children(); range; ++range) { - StmtQueue.queue(*range); + for (Stmt *SubStmt : S->children()) { + StmtQueue.queue(SubStmt); } return true; } @@ -2358,6 +2358,12 @@ DEF_TRAVERSE_STMT(OMPTaskwaitDirective, DEF_TRAVERSE_STMT(OMPTaskgroupDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) +DEF_TRAVERSE_STMT(OMPCancellationPointDirective, + { TRY_TO(TraverseOMPExecutableDirective(S)); }) + +DEF_TRAVERSE_STMT(OMPCancelDirective, + { TRY_TO(TraverseOMPExecutableDirective(S)); }) + DEF_TRAVERSE_STMT(OMPFlushDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) @@ -2622,6 +2628,12 @@ bool RecursiveASTVisitor<Derived>::VisitOMPFlushClause(OMPFlushClause *C) { return true; } +template <typename Derived> +bool RecursiveASTVisitor<Derived>::VisitOMPDependClause(OMPDependClause *C) { + TRY_TO(VisitOMPClauseList(C)); + return true; +} + // FIXME: look at the following tricky-seeming exprs to see if we // need to recurse on anything. These are ones that have methods // returning decls or qualtypes or nestednamespecifier -- though I'm diff --git a/include/clang/AST/EvaluatedExprVisitor.h b/include/clang/AST/EvaluatedExprVisitor.h index 5cae5d9eca3f..ad5287314d56 100644 --- a/include/clang/AST/EvaluatedExprVisitor.h +++ b/include/clang/AST/EvaluatedExprVisitor.h @@ -98,9 +98,9 @@ public: /// \brief The basis case walks all of the children of the statement or /// expression, assuming they are all potentially evaluated. void VisitStmt(PTR(Stmt) S) { - for (auto C = S->children(); C; ++C) - if (*C) - this->Visit(*C); + for (auto *SubStmt : S->children()) + if (SubStmt) + this->Visit(SubStmt); } #undef PTR diff --git a/include/clang/AST/ExprObjC.h b/include/clang/AST/ExprObjC.h index f296e8f71d30..899e6487f737 100644 --- a/include/clang/AST/ExprObjC.h +++ b/include/clang/AST/ExprObjC.h @@ -86,7 +86,7 @@ public: }; /// ObjCBoxedExpr - used for generalized expression boxing. -/// as in: @(strdup("hello world")) or @(random()) +/// as in: @(strdup("hello world")), @(random()) or @(view.frame) /// Also used for boxing non-parenthesized numeric literals; /// as in: @42 or \@true (c++/objc++) or \@__yes (c/objc). class ObjCBoxedExpr : public Expr { diff --git a/include/clang/AST/ExternalASTSource.h b/include/clang/AST/ExternalASTSource.h index 9a7608076214..08c2e0cf267f 100644 --- a/include/clang/AST/ExternalASTSource.h +++ b/include/clang/AST/ExternalASTSource.h @@ -156,6 +156,20 @@ public: /// \brief Retrieve the module that corresponds to the given module ID. virtual Module *getModule(unsigned ID) { return nullptr; } + /// \brief Holds everything needed to generate debug info for an + /// imported module or precompiled header file. + struct ASTSourceDescriptor { + std::string ModuleName; + std::string Path; + std::string ASTFile; + uint64_t Signature; + }; + + /// \brief Return a descriptor for the corresponding module, if one exists. + virtual llvm::Optional<ASTSourceDescriptor> getSourceDescriptor(unsigned ID); + /// \brief Return a descriptor for the module. + virtual ASTSourceDescriptor getSourceDescriptor(const Module &M); + /// \brief Finds all declarations lexically contained within the given /// DeclContext, after applying an optional filter predicate. /// diff --git a/include/clang/AST/Mangle.h b/include/clang/AST/Mangle.h index c5a7ea16a7ec..735ae11a2339 100644 --- a/include/clang/AST/Mangle.h +++ b/include/clang/AST/Mangle.h @@ -204,6 +204,10 @@ public: virtual void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD, raw_ostream &) = 0; + virtual void mangleCXXVirtualDisplacementMap(const CXXRecordDecl *SrcRD, + const CXXRecordDecl *DstRD, + raw_ostream &Out) = 0; + virtual void mangleCXXThrowInfo(QualType T, bool IsConst, bool IsVolatile, uint32_t NumEntries, raw_ostream &Out) = 0; diff --git a/include/clang/AST/NSAPI.h b/include/clang/AST/NSAPI.h index fc994c1fbd9f..ce2c7cea9e02 100644 --- a/include/clang/AST/NSAPI.h +++ b/include/clang/AST/NSAPI.h @@ -37,8 +37,9 @@ public: ClassId_NSMutableSet, ClassId_NSCountedSet, ClassId_NSMutableOrderedSet, + ClassId_NSValue }; - static const unsigned NumClassIds = 10; + static const unsigned NumClassIds = 11; enum NSStringMethodKind { NSStr_stringWithString, diff --git a/include/clang/AST/OpenMPClause.h b/include/clang/AST/OpenMPClause.h index 386c8dd3ee94..fcfa1dd4753e 100644 --- a/include/clang/AST/OpenMPClause.h +++ b/include/clang/AST/OpenMPClause.h @@ -2212,6 +2212,94 @@ public: } }; +/// \brief This represents implicit clause 'depend' for the '#pragma omp task' +/// directive. +/// +/// \code +/// #pragma omp task depend(in:a,b) +/// \endcode +/// In this example directive '#pragma omp task' with clause 'depend' with the +/// variables 'a' and 'b' with dependency 'in'. +/// +class OMPDependClause : public OMPVarListClause<OMPDependClause> { + friend class OMPClauseReader; + /// \brief Dependency type (one of in, out, inout). + OpenMPDependClauseKind DepKind; + /// \brief Dependency type location. + SourceLocation DepLoc; + /// \brief Colon location. + SourceLocation ColonLoc; + /// \brief Build clause with number of variables \a N. + /// + /// \param StartLoc Starting location of the clause. + /// \param LParenLoc Location of '('. + /// \param EndLoc Ending location of the clause. + /// \param N Number of the variables in the clause. + /// + OMPDependClause(SourceLocation StartLoc, SourceLocation LParenLoc, + SourceLocation EndLoc, unsigned N) + : OMPVarListClause<OMPDependClause>(OMPC_depend, StartLoc, LParenLoc, + EndLoc, N), + DepKind(OMPC_DEPEND_unknown) {} + + /// \brief Build an empty clause. + /// + /// \param N Number of variables. + /// + explicit OMPDependClause(unsigned N) + : OMPVarListClause<OMPDependClause>(OMPC_depend, SourceLocation(), + SourceLocation(), SourceLocation(), + N), + DepKind(OMPC_DEPEND_unknown) {} + /// \brief Set dependency kind. + void setDependencyKind(OpenMPDependClauseKind K) { DepKind = K; } + + /// \brief Set dependency kind and its location. + void setDependencyLoc(SourceLocation Loc) { DepLoc = Loc; } + + /// \brief Set colon location. + void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; } + +public: + /// \brief Creates clause with a list of variables \a VL. + /// + /// \param C AST context. + /// \param StartLoc Starting location of the clause. + /// \param LParenLoc Location of '('. + /// \param EndLoc Ending location of the clause. + /// \param DepKind Dependency type. + /// \param DepLoc Location of the dependency type. + /// \param ColonLoc Colon location. + /// \param VL List of references to the variables. + /// + static OMPDependClause * + Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, + SourceLocation EndLoc, OpenMPDependClauseKind DepKind, + SourceLocation DepLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL); + /// \brief Creates an empty clause with \a N variables. + /// + /// \param C AST context. + /// \param N The number of variables. + /// + static OMPDependClause *CreateEmpty(const ASTContext &C, unsigned N); + + /// \brief Get dependency type. + OpenMPDependClauseKind getDependencyKind() const { return DepKind; } + /// \brief Get dependency type location. + SourceLocation getDependencyLoc() const { return DepLoc; } + /// \brief Get colon location. + SourceLocation getColonLoc() const { return ColonLoc; } + + StmtRange children() { + return StmtRange(reinterpret_cast<Stmt **>(varlist_begin()), + reinterpret_cast<Stmt **>(varlist_end())); + } + + static bool classof(const OMPClause *T) { + return T->getClauseKind() == OMPC_depend; + } +}; + } // end namespace clang #endif diff --git a/include/clang/AST/RecursiveASTVisitor.h b/include/clang/AST/RecursiveASTVisitor.h index 95d773073184..b118503b674b 100644 --- a/include/clang/AST/RecursiveASTVisitor.h +++ b/include/clang/AST/RecursiveASTVisitor.h @@ -1881,8 +1881,8 @@ DEF_TRAVERSE_DECL(ParmVarDecl, { bool RecursiveASTVisitor<Derived>::Traverse##STMT(STMT *S) { \ TRY_TO(WalkUpFrom##STMT(S)); \ { CODE; } \ - for (Stmt::child_range range = S->children(); range; ++range) { \ - TRY_TO(TraverseStmt(*range)); \ + for (Stmt *SubStmt : S->children()) { \ + TRY_TO(TraverseStmt(SubStmt)); \ } \ return true; \ } @@ -2038,15 +2038,15 @@ bool RecursiveASTVisitor<Derived>::TraverseInitListExpr(InitListExpr *S) { if (Syn) { TRY_TO(WalkUpFromInitListExpr(Syn)); // All we need are the default actions. FIXME: use a helper function. - for (Stmt::child_range range = Syn->children(); range; ++range) { - TRY_TO(TraverseStmt(*range)); + for (Stmt *SubStmt : Syn->children()) { + TRY_TO(TraverseStmt(SubStmt)); } } InitListExpr *Sem = S->isSemanticForm() ? S : S->getSemanticForm(); if (Sem) { TRY_TO(WalkUpFromInitListExpr(Sem)); - for (Stmt::child_range range = Sem->children(); range; ++range) { - TRY_TO(TraverseStmt(*range)); + for (Stmt *SubStmt : Sem->children()) { + TRY_TO(TraverseStmt(SubStmt)); } } return true; @@ -2391,6 +2391,12 @@ DEF_TRAVERSE_STMT(OMPTaskwaitDirective, DEF_TRAVERSE_STMT(OMPTaskgroupDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) +DEF_TRAVERSE_STMT(OMPCancellationPointDirective, + { TRY_TO(TraverseOMPExecutableDirective(S)); }) + +DEF_TRAVERSE_STMT(OMPCancelDirective, + { TRY_TO(TraverseOMPExecutableDirective(S)); }) + DEF_TRAVERSE_STMT(OMPFlushDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) @@ -2655,6 +2661,12 @@ bool RecursiveASTVisitor<Derived>::VisitOMPFlushClause(OMPFlushClause *C) { return true; } +template <typename Derived> +bool RecursiveASTVisitor<Derived>::VisitOMPDependClause(OMPDependClause *C) { + TRY_TO(VisitOMPClauseList(C)); + return true; +} + // FIXME: look at the following tricky-seeming exprs to see if we // need to recurse on anything. These are ones that have methods // returning decls or qualtypes or nestednamespecifier -- though I'm diff --git a/include/clang/AST/StmtIterator.h b/include/clang/AST/StmtIterator.h index ec7329a4a013..a5a57af523d1 100644 --- a/include/clang/AST/StmtIterator.h +++ b/include/clang/AST/StmtIterator.h @@ -32,8 +32,10 @@ protected: enum { StmtMode = 0x0, SizeOfTypeVAMode = 0x1, DeclGroupMode = 0x2, Flags = 0x3 }; - Stmt **stmt; - Decl **DGI; + union { + Stmt **stmt; + Decl **DGI; + }; uintptr_t RawVAPtr; Decl **DGE; @@ -64,10 +66,10 @@ protected: Stmt*& GetDeclExpr() const; - StmtIteratorBase(Stmt **s) : stmt(s), DGI(nullptr), RawVAPtr(0) {} + StmtIteratorBase(Stmt **s) : stmt(s), RawVAPtr(0) {} StmtIteratorBase(const VariableArrayType *t); StmtIteratorBase(Decl **dgi, Decl **dge); - StmtIteratorBase() : stmt(nullptr), DGI(nullptr), RawVAPtr(0) {} + StmtIteratorBase() : stmt(nullptr), RawVAPtr(0) {} }; diff --git a/include/clang/AST/StmtOpenMP.h b/include/clang/AST/StmtOpenMP.h index 63f295ddfec0..b412daaf2858 100644 --- a/include/clang/AST/StmtOpenMP.h +++ b/include/clang/AST/StmtOpenMP.h @@ -1856,6 +1856,121 @@ public: } }; +/// \brief This represents '#pragma omp cancellation point' directive. +/// +/// \code +/// #pragma omp cancellation point for +/// \endcode +/// +/// In this example a cancellation point is created for innermost 'for' region. +class OMPCancellationPointDirective : public OMPExecutableDirective { + friend class ASTStmtReader; + OpenMPDirectiveKind CancelRegion; + /// \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. + /// + OMPCancellationPointDirective(SourceLocation StartLoc, SourceLocation EndLoc) + : OMPExecutableDirective(this, OMPCancellationPointDirectiveClass, + OMPD_cancellation_point, StartLoc, EndLoc, 0, 0), + CancelRegion(OMPD_unknown) {} + + /// \brief Build an empty directive. + /// + explicit OMPCancellationPointDirective() + : OMPExecutableDirective(this, OMPCancellationPointDirectiveClass, + OMPD_cancellation_point, SourceLocation(), + SourceLocation(), 0, 0), + CancelRegion(OMPD_unknown) {} + + /// \brief Set cancel region for current cancellation point. + /// \param CR Cancellation region. + void setCancelRegion(OpenMPDirectiveKind CR) { CancelRegion = CR; } + +public: + /// \brief Creates directive. + /// + /// \param C AST context. + /// \param StartLoc Starting location of the directive kind. + /// \param EndLoc Ending Location of the directive. + /// + static OMPCancellationPointDirective * + Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, + OpenMPDirectiveKind CancelRegion); + + /// \brief Creates an empty directive. + /// + /// \param C AST context. + /// + static OMPCancellationPointDirective *CreateEmpty(const ASTContext &C, + EmptyShell); + + /// \brief Get cancellation region for the current cancellation point. + OpenMPDirectiveKind getCancelRegion() const { return CancelRegion; } + + static bool classof(const Stmt *T) { + return T->getStmtClass() == OMPCancellationPointDirectiveClass; + } +}; + +/// \brief This represents '#pragma omp cancel' directive. +/// +/// \code +/// #pragma omp cancel for +/// \endcode +/// +/// In this example a cancel is created for innermost 'for' region. +class OMPCancelDirective : public OMPExecutableDirective { + friend class ASTStmtReader; + OpenMPDirectiveKind CancelRegion; + /// \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. + /// + OMPCancelDirective(SourceLocation StartLoc, SourceLocation EndLoc) + : OMPExecutableDirective(this, OMPCancelDirectiveClass, OMPD_cancel, + StartLoc, EndLoc, 0, 0), + CancelRegion(OMPD_unknown) {} + + /// \brief Build an empty directive. + /// + explicit OMPCancelDirective() + : OMPExecutableDirective(this, OMPCancelDirectiveClass, OMPD_cancel, + SourceLocation(), SourceLocation(), 0, 0), + CancelRegion(OMPD_unknown) {} + + /// \brief Set cancel region for current cancellation point. + /// \param CR Cancellation region. + void setCancelRegion(OpenMPDirectiveKind CR) { CancelRegion = CR; } + +public: + /// \brief Creates directive. + /// + /// \param C AST context. + /// \param StartLoc Starting location of the directive kind. + /// \param EndLoc Ending Location of the directive. + /// + static OMPCancelDirective *Create(const ASTContext &C, + SourceLocation StartLoc, + SourceLocation EndLoc, + OpenMPDirectiveKind CancelRegion); + + /// \brief Creates an empty directive. + /// + /// \param C AST context. + /// + static OMPCancelDirective *CreateEmpty(const ASTContext &C, EmptyShell); + + /// \brief Get cancellation region for the current cancellation point. + OpenMPDirectiveKind getCancelRegion() const { return CancelRegion; } + + static bool classof(const Stmt *T) { + return T->getStmtClass() == OMPCancelDirectiveClass; + } +}; + } // end namespace clang #endif diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h index d903b9d8cbcf..97f13313b339 100644 --- a/include/clang/AST/Type.h +++ b/include/clang/AST/Type.h @@ -1564,6 +1564,7 @@ public: bool isRecordType() const; bool isClassType() const; bool isStructureType() const; + bool isObjCBoxableRecordType() const; bool isInterfaceType() const; bool isStructureOrClassType() const; bool isUnionType() const; diff --git a/include/clang/ASTMatchers/ASTMatchers.h b/include/clang/ASTMatchers/ASTMatchers.h index 94c77f7f73ba..e7a97a7ff745 100644 --- a/include/clang/ASTMatchers/ASTMatchers.h +++ b/include/clang/ASTMatchers/ASTMatchers.h @@ -2528,6 +2528,23 @@ AST_MATCHER_P2(DeclStmt, containsDeclaration, unsigned, N, return InnerMatcher.matches(**Iterator, Finder, Builder); } +/// \brief Matches a C++ catch statement that has a catch-all handler. +/// +/// Given +/// \code +/// try { +/// // ... +/// } catch (int) { +/// // ... +/// } catch (...) { +/// // ... +/// } +/// /endcode +/// catchStmt(isCatchAll()) matches catch(...) but not catch(int). +AST_MATCHER(CXXCatchStmt, isCatchAll) { + return Node.getExceptionDecl() == nullptr; +} + /// \brief Matches a constructor initializer. /// /// Given diff --git a/include/clang/Analysis/Analyses/FormatString.h b/include/clang/Analysis/Analyses/FormatString.h index 2e8058dabda2..4471311a3390 100644 --- a/include/clang/Analysis/Analyses/FormatString.h +++ b/include/clang/Analysis/Analyses/FormatString.h @@ -40,6 +40,7 @@ public: void clear() { flag = false; } void setPosition(const char *position) { assert(position); + flag = true; this->position = position; } const char *getPosition() const { @@ -435,12 +436,14 @@ class PrintfSpecifier : public analyze_format_string::FormatSpecifier { OptionalFlag HasSpacePrefix; // ' ' OptionalFlag HasAlternativeForm; // '#' OptionalFlag HasLeadingZeroes; // '0' + OptionalFlag HasObjCTechnicalTerm; // '[tt]' OptionalAmount Precision; public: PrintfSpecifier() : FormatSpecifier(/* isPrintf = */ true), HasThousandsGrouping("'"), IsLeftJustified("-"), HasPlusPrefix("+"), - HasSpacePrefix(" "), HasAlternativeForm("#"), HasLeadingZeroes("0") {} + HasSpacePrefix(" "), HasAlternativeForm("#"), HasLeadingZeroes("0"), + HasObjCTechnicalTerm("tt") {} static PrintfSpecifier Parse(const char *beg, const char *end); @@ -449,29 +452,26 @@ public: CS = cs; } void setHasThousandsGrouping(const char *position) { - HasThousandsGrouping = true; HasThousandsGrouping.setPosition(position); } void setIsLeftJustified(const char *position) { - IsLeftJustified = true; IsLeftJustified.setPosition(position); } void setHasPlusPrefix(const char *position) { - HasPlusPrefix = true; HasPlusPrefix.setPosition(position); } void setHasSpacePrefix(const char *position) { - HasSpacePrefix = true; HasSpacePrefix.setPosition(position); } void setHasAlternativeForm(const char *position) { - HasAlternativeForm = true; HasAlternativeForm.setPosition(position); } void setHasLeadingZeros(const char *position) { - HasLeadingZeroes = true; HasLeadingZeroes.setPosition(position); } + void setHasObjCTechnicalTerm(const char *position) { + HasObjCTechnicalTerm.setPosition(position); + } void setUsesPositionalArg() { UsesPositionalArg = true; } // Methods for querying the format specifier. @@ -508,6 +508,7 @@ public: const OptionalFlag &hasAlternativeForm() const { return HasAlternativeForm; } const OptionalFlag &hasLeadingZeros() const { return HasLeadingZeroes; } const OptionalFlag &hasSpacePrefix() const { return HasSpacePrefix; } + const OptionalFlag &hasObjCTechnicalTerm() const { return HasObjCTechnicalTerm; } bool usesPositionalArg() const { return UsesPositionalArg; } /// Changes the specifier and length according to a QualType, retaining any @@ -565,7 +566,6 @@ public: SuppressAssignment("*") {} void setSuppressAssignment(const char *position) { - SuppressAssignment = true; SuppressAssignment.setPosition(position); } @@ -621,6 +621,15 @@ public: virtual void HandleIncompleteSpecifier(const char *startSpecifier, unsigned specifierLen) {} + virtual void HandleEmptyObjCModifierFlag(const char *startFlags, + unsigned flagsLen) {} + + virtual void HandleInvalidObjCModifierFlag(const char *startFlag, + unsigned flagLen) {} + + virtual void HandleObjCFlagsWithNonObjCConversion(const char *flagsStart, + const char *flagsEnd, + const char *conversionPosition) {} // Printf-specific handlers. virtual bool HandleInvalidPrintfConversionSpecifier( diff --git a/include/clang/Basic/Attr.td b/include/clang/Basic/Attr.td index f36f654ff630..2bbce37e57bb 100644 --- a/include/clang/Basic/Attr.td +++ b/include/clang/Basic/Attr.td @@ -950,30 +950,30 @@ def NonNull : InheritableAttr { } }]; // FIXME: We should merge duplicates into a single nonnull attribute. let DuplicatesAllowedWhileMerging = 1; - let Documentation = [Undocumented]; + let Documentation = [NonNullDocs]; } def ReturnsNonNull : InheritableAttr { let Spellings = [GCC<"returns_nonnull">]; let Subjects = SubjectList<[ObjCMethod, Function], WarnDiag, "ExpectedFunctionOrMethod">; - let Documentation = [Undocumented]; + let Documentation = [ReturnsNonNullDocs]; } // Nullability type attributes. def TypeNonNull : TypeAttr { - let Spellings = [Keyword<"__nonnull">]; - let Documentation = [Undocumented]; + let Spellings = [Keyword<"_Nonnull">]; + let Documentation = [TypeNonNullDocs]; } def TypeNullable : TypeAttr { - let Spellings = [Keyword<"__nullable">]; - let Documentation = [Undocumented]; + let Spellings = [Keyword<"_Nullable">]; + let Documentation = [TypeNullableDocs]; } def TypeNullUnspecified : TypeAttr { - let Spellings = [Keyword<"__null_unspecified">]; - let Documentation = [Undocumented]; + let Spellings = [Keyword<"_Null_unspecified">]; + let Documentation = [TypeNullUnspecifiedDocs]; } def AssumeAligned : InheritableAttr { @@ -1125,6 +1125,12 @@ def ObjCRuntimeName : Attr { let Documentation = [ObjCRuntimeNameDocs]; } +def ObjCBoxable : Attr { + let Spellings = [GNU<"objc_boxable">]; + let Subjects = SubjectList<[Record], ErrorDiag, "ExpectedStructOrUnion">; + let Documentation = [Undocumented]; +} + def OptimizeNone : InheritableAttr { let Spellings = [GNU<"optnone">, CXX11<"clang", "optnone">]; let Subjects = SubjectList<[Function, ObjCMethod]>; diff --git a/include/clang/Basic/AttrDocs.td b/include/clang/Basic/AttrDocs.td index 9314c445a56b..107458e46145 100644 --- a/include/clang/Basic/AttrDocs.td +++ b/include/clang/Basic/AttrDocs.td @@ -181,6 +181,11 @@ to enforce the provided alignment assumption. def EnableIfDocs : Documentation { let Category = DocCatFunction; let Content = [{ +.. Note:: Some features of this attribute are experimental. The meaning of
+ multiple enable_if attributes on a single declaration is subject to change in
+ a future version of clang. Also, the ABI is not standardized and the name
+ mangling may change in future versions. To avoid that, use asm labels. + The ``enable_if`` attribute can be placed on function declarations to control which overload is selected based on the values of the function's arguments. When combined with the ``overloadable`` attribute, this feature is also @@ -1448,3 +1453,114 @@ private address space. Kernel function arguments of a pointer or an array type cannot point to the private address space. }]; } + +def NullabilityDocs : DocumentationCategory<"Nullability Attributes"> { + let Content = [{ +Whether a particular pointer may be "null" is an important concern when working with pointers in the C family of languages. The various nullability attributes indicate whether a particular pointer can be null or not, which makes APIs more expressive and can help static analysis tools identify bugs involving null pointers. Clang supports several kinds of nullability attributes: the ``nonnull`` and ``returns_nonnull`` attributes indicate which function or method parameters and result types can never be null, while nullability type qualifiers indicate which pointer types can be null (``_Nullable``) or cannot be null (``_Nonnull``). + +The nullability (type) qualifiers express whether a value of a given pointer type can be null (the ``_Nullable`` qualifier), doesn't have a defined meaning for null (the ``_Nonnull`` qualifier), or for which the purpose of null is unclear (the ``_Null_unspecified`` qualifier). Because nullability qualifiers are expressed within the type system, they are more general than the ``nonnull`` and ``returns_nonnull`` attributes, allowing one to express (for example) a nullable pointer to an array of nonnull pointers. Nullability qualifiers are written to the right of the pointer to which they apply. For example: + + .. code-block:: c + + // No meaningful result when 'ptr' is null (here, it happens to be undefined behavior). + int fetch(int * _Nonnull ptr) { return *ptr; } + + // 'ptr' may be null. + int fetch_or_zero(int * _Nullable ptr) { + return ptr ? *ptr : 0; + } + + // A nullable pointer to non-null pointers to const characters. + const char *join_strings(const char * _Nonnull * _Nullable strings, unsigned n); + +In Objective-C, there is an alternate spelling for the nullability qualifiers that can be used in Objective-C methods and properties using context-sensitive, non-underscored keywords. For example: + + .. code-block:: objective-c + + @interface NSView : NSResponder + - (nullable NSView *)ancestorSharedWithView:(nonnull NSView *)aView; + @property (assign, nullable) NSView *superview; + @property (readonly, nonnull) NSArray *subviews; + @end + }]; +} + +def TypeNonNullDocs : Documentation { + let Category = NullabilityDocs; + let Heading = "_Nonnull"; + let Content = [{ +The ``_Nonnull`` nullability qualifier indicates that null is not a meaningful value for a value of the ``_Nonnull`` pointer type. For example, given a declaration such as: + + .. code-block:: c + + int fetch(int * _Nonnull ptr); + +a caller of ``fetch`` should not provide a null value, and the compiler will produce a warning if it sees a literal null value passed to ``fetch``. Note that, unlike the declaration attribute ``nonnull``, the presence of ``_Nonnull`` does not imply that passing null is undefined behavior: ``fetch`` is free to consider null undefined behavior or (perhaps for backward-compatibility reasons) defensively handle null. + }]; +} + +def TypeNullableDocs : Documentation { + let Category = NullabilityDocs; + let Heading = "_Nullable"; + let Content = [{ +The ``_Nullable`` nullability qualifier indicates that a value of the ``_Nullable`` pointer type can be null. For example, given: + + .. code-block:: c + + int fetch_or_zero(int * _Nullable ptr); + +a caller of ``fetch_or_zero`` can provide null. + }]; +} + +def TypeNullUnspecifiedDocs : Documentation { + let Category = NullabilityDocs; + let Heading = "_Null_unspecified"; + let Content = [{ +The ``_Null_unspecified`` nullability qualifier indicates that neither the ``_Nonnull`` nor ``_Nullable`` qualifiers make sense for a particular pointer type. It is used primarily to indicate that the role of null with specific pointers in a nullability-annotated header is unclear, e.g., due to overly-complex implementations or historical factors with a long-lived API. + }]; +} + +def NonNullDocs : Documentation { + let Category = NullabilityDocs; + let Heading = "nonnull"; + let Content = [{ +The ``nonnull`` attribute indicates that some function parameters must not be null, and can be used in several different ways. It's original usage (`from GCC <https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#Common-Function-Attributes>`_) is as a function (or Objective-C method) attribute that specifies which parameters of the function are nonnull in a comma-separated list. For example: + + .. code-block:: c + + extern void * my_memcpy (void *dest, const void *src, size_t len) + __attribute__((nonnull (1, 2))); + +Here, the ``nonnull`` attribute indicates that parameters 1 and 2 +cannot have a null value. Omitting the parenthesized list of parameter indices means that all parameters of pointer type cannot be null: + + .. code-block:: c + + extern void * my_memcpy (void *dest, const void *src, size_t len) + __attribute__((nonnull)); + +Clang also allows the ``nonnull`` attribute to be placed directly on a function (or Objective-C method) parameter, eliminating the need to specify the parameter index ahead of type. For example: + + .. code-block:: c + + extern void * my_memcpy (void *dest __attribute__((nonnull)), + const void *src __attribute__((nonnull)), size_t len); + +Note that the ``nonnull`` attribute indicates that passing null to a non-null parameter is undefined behavior, which the optimizer may take advantage of to, e.g., remove null checks. The ``_Nonnull`` type qualifier indicates that a pointer cannot be null in a more general manner (because it is part of the type system) and does not imply undefined behavior, making it more widely applicable. + }]; +} + +def ReturnsNonNullDocs : Documentation { + let Category = NullabilityDocs; + let Heading = "returns_nonnull"; + let Content = [{ +The ``returns_nonnull`` attribute indicates that a particular function (or Objective-C method) always returns a non-null pointer. For example, a particular system ``malloc`` might be defined to terminate a process when memory is not available rather than returning a null pointer: + + .. code-block:: c + + extern void * malloc (size_t size) __attribute__((returns_nonnull)); + +The ``returns_nonnull`` attribute implies that returning a null pointer is undefined behavior, which the optimizer may take advantage of. The ``_Nonnull`` type qualifier indicates that a pointer cannot be null in a more general manner (because it is part of the type system) and does not imply undefined behavior, making it more widely applicable +}]; +} diff --git a/include/clang/Basic/BuiltinsARM.def b/include/clang/Basic/BuiltinsARM.def index 0610d47f8ba1..c9cdb4b675bc 100644 --- a/include/clang/Basic/BuiltinsARM.def +++ b/include/clang/Basic/BuiltinsARM.def @@ -105,10 +105,10 @@ LANGBUILTIN(__dmb, "vUi", "nc", ALL_MS_LANGUAGES) LANGBUILTIN(__dsb, "vUi", "nc", ALL_MS_LANGUAGES) LANGBUILTIN(__isb, "vUi", "nc", ALL_MS_LANGUAGES) LANGBUILTIN(__ldrexd, "WiWiCD*", "", ALL_MS_LANGUAGES) -LANGBUILTIN(_MoveFromCoprocessor, "UiUiUiUiUiUi", "", ALL_MS_LANGUAGES) -LANGBUILTIN(_MoveFromCoprocessor2, "UiUiUiUiUiUi", "", ALL_MS_LANGUAGES) -LANGBUILTIN(_MoveToCoprocessor, "vUiUiUiUiUiUi", "", ALL_MS_LANGUAGES) -LANGBUILTIN(_MoveToCoprocessor2, "vUiUiUiUiUiUi", "", ALL_MS_LANGUAGES) +LANGBUILTIN(_MoveFromCoprocessor, "UiIUiIUiIUiIUiIUi", "", ALL_MS_LANGUAGES) +LANGBUILTIN(_MoveFromCoprocessor2, "UiIUiIUiIUiIUiIUi", "", ALL_MS_LANGUAGES) +LANGBUILTIN(_MoveToCoprocessor, "vUiIUiIUiIUiIUiIUi", "", ALL_MS_LANGUAGES) +LANGBUILTIN(_MoveToCoprocessor2, "vUiIUiIUiIUiIUiIUi", "", ALL_MS_LANGUAGES) #undef BUILTIN #undef LANGBUILTIN diff --git a/include/clang/Basic/BuiltinsNVPTX.def b/include/clang/Basic/BuiltinsNVPTX.def index 9c920dce5cab..970f55fe223c 100644 --- a/include/clang/Basic/BuiltinsNVPTX.def +++ b/include/clang/Basic/BuiltinsNVPTX.def @@ -501,7 +501,7 @@ BUILTIN(__nvvm_atom_min_s_ui, "UiUiD*3Ui", "n") BUILTIN(__nvvm_atom_min_gen_ui, "UiUiD*Ui", "n") BUILTIN(__nvvm_atom_min_g_l, "LiLiD*1Li", "n") BUILTIN(__nvvm_atom_min_s_l, "LiLiD*3Li", "n") -BUILTIN(__nvvm_atom_min_gen_l, "LiLi10D*Li", "n") +BUILTIN(__nvvm_atom_min_gen_l, "LiLiD*Li", "n") BUILTIN(__nvvm_atom_min_g_ul, "ULiULiD*1ULi", "n") BUILTIN(__nvvm_atom_min_s_ul, "ULiULiD*3ULi", "n") BUILTIN(__nvvm_atom_min_gen_ul, "ULiULiD*ULi", "n") diff --git a/include/clang/Basic/BuiltinsPPC.def b/include/clang/Basic/BuiltinsPPC.def index 6f3bea887f59..02e52947ed6c 100644 --- a/include/clang/Basic/BuiltinsPPC.def +++ b/include/clang/Basic/BuiltinsPPC.def @@ -267,6 +267,18 @@ BUILTIN(__builtin_vsx_xsmindp, "ddd", "") BUILTIN(__builtin_vsx_xvdivdp, "V2dV2dV2d", "") BUILTIN(__builtin_vsx_xvdivsp, "V4fV4fV4f", "") +BUILTIN(__builtin_vsx_xvrdpip, "V2dV2d", "") +BUILTIN(__builtin_vsx_xvrspip, "V4fV4f", "") + +BUILTIN(__builtin_vsx_xvcmpeqdp, "V2ULLiV2dV2d", "") +BUILTIN(__builtin_vsx_xvcmpeqsp, "V4UiV4fV4f", "") + +BUILTIN(__builtin_vsx_xvcmpgedp, "V2ULLiV2dV2d", "") +BUILTIN(__builtin_vsx_xvcmpgesp, "V4UiV4fV4f", "") + +BUILTIN(__builtin_vsx_xvcmpgtdp, "V2ULLiV2dV2d", "") +BUILTIN(__builtin_vsx_xvcmpgtsp, "V4UiV4fV4f", "") + // HTM builtins BUILTIN(__builtin_tbegin, "UiUIi", "") BUILTIN(__builtin_tend, "UiUIi", "") diff --git a/include/clang/Basic/BuiltinsX86.def b/include/clang/Basic/BuiltinsX86.def index 00c1340ac37f..aaf279f3713f 100644 --- a/include/clang/Basic/BuiltinsX86.def +++ b/include/clang/Basic/BuiltinsX86.def @@ -24,6 +24,11 @@ // FIXME: Are these nothrow/const? +// Miscellaneous builtin for checking x86 cpu features. +// TODO: Make this somewhat generic so that other backends +// can use it? +BUILTIN(__builtin_cpu_supports, "bcC*", "nc") + // 3DNow! // BUILTIN(__builtin_ia32_femms, "v", "") @@ -651,6 +656,12 @@ BUILTIN(__builtin_ia32_wrfsbase64, "vULLi", "") BUILTIN(__builtin_ia32_wrgsbase32, "vUi", "") BUILTIN(__builtin_ia32_wrgsbase64, "vULLi", "") +// FXSR +BUILTIN(__builtin_ia32_fxrstor, "vv*", "") +BUILTIN(__builtin_ia32_fxrstor64, "vv*", "") +BUILTIN(__builtin_ia32_fxsave, "vv*", "") +BUILTIN(__builtin_ia32_fxsave64, "vv*", "") + // ADX BUILTIN(__builtin_ia32_addcarryx_u32, "UcUcUiUiUi*", "") BUILTIN(__builtin_ia32_addcarryx_u64, "UcUcULLiULLiULLi*", "") @@ -722,12 +733,72 @@ BUILTIN(__builtin_ia32_vfmaddsubps256, "V8fV8fV8fV8f", "") BUILTIN(__builtin_ia32_vfmaddsubpd256, "V4dV4dV4dV4d", "") BUILTIN(__builtin_ia32_vfmsubaddps256, "V8fV8fV8fV8f", "") BUILTIN(__builtin_ia32_vfmsubaddpd256, "V4dV4dV4dV4d", "") -BUILTIN(__builtin_ia32_vfmaddpd512_mask, "V8dV8dV8dV8dUcIi", "") -BUILTIN(__builtin_ia32_vfmsubpd512_mask, "V8dV8dV8dV8dUcIi", "") -BUILTIN(__builtin_ia32_vfnmaddpd512_mask, "V8dV8dV8dV8dUcIi", "") -BUILTIN(__builtin_ia32_vfmaddps512_mask, "V16fV16fV16fV16fUsIi", "") -BUILTIN(__builtin_ia32_vfmsubps512_mask, "V16fV16fV16fV16fUsIi", "") -BUILTIN(__builtin_ia32_vfnmaddps512_mask, "V16fV16fV16fV16fUsIi", "") +BUILTIN(__builtin_ia32_vfmaddpd128_mask, "V2dV2dV2dV2dUc", "") +BUILTIN(__builtin_ia32_vfmaddpd128_mask3, "V2dV2dV2dV2dUc", "") +BUILTIN(__builtin_ia32_vfmaddpd128_maskz, "V2dV2dV2dV2dUc", "") +BUILTIN(__builtin_ia32_vfmaddpd256_mask, "V4dV4dV4dV4dUc", "") +BUILTIN(__builtin_ia32_vfmaddpd256_mask3, "V4dV4dV4dV4dUc", "") +BUILTIN(__builtin_ia32_vfmaddpd256_maskz, "V4dV4dV4dV4dUc", "") +BUILTIN(__builtin_ia32_vfmaddpd512_mask, "V8dV8dV8dV8dUcIi", "") +BUILTIN(__builtin_ia32_vfmaddpd512_mask3, "V8dV8dV8dV8dUcIi", "") +BUILTIN(__builtin_ia32_vfmaddpd512_maskz, "V8dV8dV8dV8dUcIi", "") +BUILTIN(__builtin_ia32_vfmaddps128_mask, "V4fV4fV4fV4fUc", "") +BUILTIN(__builtin_ia32_vfmaddps128_mask3, "V4fV4fV4fV4fUc", "") +BUILTIN(__builtin_ia32_vfmaddps128_maskz, "V4fV4fV4fV4fUc", "") +BUILTIN(__builtin_ia32_vfmaddps256_mask, "V8fV8fV8fV8fUc", "") +BUILTIN(__builtin_ia32_vfmaddps256_mask3, "V8fV8fV8fV8fUc", "") +BUILTIN(__builtin_ia32_vfmaddps256_maskz, "V8fV8fV8fV8fUc", "") +BUILTIN(__builtin_ia32_vfmaddps512_mask, "V16fV16fV16fV16fUsIi", "") +BUILTIN(__builtin_ia32_vfmaddps512_mask3, "V16fV16fV16fV16fUsIi", "") +BUILTIN(__builtin_ia32_vfmaddps512_maskz, "V16fV16fV16fV16fUsIi", "") +BUILTIN(__builtin_ia32_vfmaddsubpd128_mask, "V2dV2dV2dV2dUc", "") +BUILTIN(__builtin_ia32_vfmaddsubpd128_mask3, "V2dV2dV2dV2dUc", "") +BUILTIN(__builtin_ia32_vfmaddsubpd128_maskz, "V2dV2dV2dV2dUc", "") +BUILTIN(__builtin_ia32_vfmaddsubpd256_mask, "V4dV4dV4dV4dUc", "") +BUILTIN(__builtin_ia32_vfmaddsubpd256_mask3, "V4dV4dV4dV4dUc", "") +BUILTIN(__builtin_ia32_vfmaddsubpd256_maskz, "V4dV4dV4dV4dUc", "") +BUILTIN(__builtin_ia32_vfmaddsubpd512_mask, "V8dV8dV8dV8dUcIi", "") +BUILTIN(__builtin_ia32_vfmaddsubpd512_mask3, "V8dV8dV8dV8dUcIi", "") +BUILTIN(__builtin_ia32_vfmaddsubpd512_maskz, "V8dV8dV8dV8dUcIi", "") +BUILTIN(__builtin_ia32_vfmaddsubps128_mask, "V4fV4fV4fV4fUc", "") +BUILTIN(__builtin_ia32_vfmaddsubps128_mask3, "V4fV4fV4fV4fUc", "") +BUILTIN(__builtin_ia32_vfmaddsubps128_maskz, "V4fV4fV4fV4fUc", "") +BUILTIN(__builtin_ia32_vfmaddsubps256_mask, "V8fV8fV8fV8fUc", "") +BUILTIN(__builtin_ia32_vfmaddsubps256_mask3, "V8fV8fV8fV8fUc", "") +BUILTIN(__builtin_ia32_vfmaddsubps256_maskz, "V8fV8fV8fV8fUc", "") +BUILTIN(__builtin_ia32_vfmaddsubps512_mask, "V16fV16fV16fV16fUsIi", "") +BUILTIN(__builtin_ia32_vfmaddsubps512_mask3, "V16fV16fV16fV16fUsIi", "") +BUILTIN(__builtin_ia32_vfmaddsubps512_maskz, "V16fV16fV16fV16fUsIi", "") +BUILTIN(__builtin_ia32_vfmsubpd128_mask3, "V2dV2dV2dV2dUc", "") +BUILTIN(__builtin_ia32_vfmsubpd256_mask3, "V4dV4dV4dV4dUc", "") +BUILTIN(__builtin_ia32_vfmsubpd512_mask3, "V8dV8dV8dV8dUcIi", "") +BUILTIN(__builtin_ia32_vfmsubps128_mask3, "V4fV4fV4fV4fUc", "") +BUILTIN(__builtin_ia32_vfmsubps256_mask3, "V8fV8fV8fV8fUc", "") +BUILTIN(__builtin_ia32_vfmsubps512_mask3, "V16fV16fV16fV16fUsIi", "") +BUILTIN(__builtin_ia32_vfmsubaddpd128_mask3, "V2dV2dV2dV2dUc", "") +BUILTIN(__builtin_ia32_vfmsubaddpd256_mask3, "V4dV4dV4dV4dUc", "") +BUILTIN(__builtin_ia32_vfmsubaddpd512_mask3, "V8dV8dV8dV8dUcIi", "") +BUILTIN(__builtin_ia32_vfmsubaddps128_mask3, "V4fV4fV4fV4fUc", "") +BUILTIN(__builtin_ia32_vfmsubaddps256_mask3, "V8fV8fV8fV8fUc", "") +BUILTIN(__builtin_ia32_vfmsubaddps512_mask3, "V16fV16fV16fV16fUsIi", "") +BUILTIN(__builtin_ia32_vfnmaddpd128_mask, "V2dV2dV2dV2dUc", "") +BUILTIN(__builtin_ia32_vfnmaddpd256_mask, "V4dV4dV4dV4dUc", "") +BUILTIN(__builtin_ia32_vfnmaddpd512_mask, "V8dV8dV8dV8dUcIi", "") +BUILTIN(__builtin_ia32_vfnmaddps128_mask, "V4fV4fV4fV4fUc", "") +BUILTIN(__builtin_ia32_vfnmaddps256_mask, "V8fV8fV8fV8fUc", "") +BUILTIN(__builtin_ia32_vfnmaddps512_mask, "V16fV16fV16fV16fUsIi", "") +BUILTIN(__builtin_ia32_vfnmsubpd128_mask, "V2dV2dV2dV2dUc", "") +BUILTIN(__builtin_ia32_vfnmsubpd128_mask3, "V2dV2dV2dV2dUc", "") +BUILTIN(__builtin_ia32_vfnmsubpd256_mask, "V4dV4dV4dV4dUc", "") +BUILTIN(__builtin_ia32_vfnmsubpd256_mask3, "V4dV4dV4dV4dUc", "") +BUILTIN(__builtin_ia32_vfnmsubpd512_mask, "V8dV8dV8dV8dUcIi", "") +BUILTIN(__builtin_ia32_vfnmsubpd512_mask3, "V8dV8dV8dV8dUcIi", "") +BUILTIN(__builtin_ia32_vfnmsubps128_mask, "V4fV4fV4fV4fUc", "") +BUILTIN(__builtin_ia32_vfnmsubps128_mask3, "V4fV4fV4fV4fUc", "") +BUILTIN(__builtin_ia32_vfnmsubps256_mask, "V8fV8fV8fV8fUc", "") +BUILTIN(__builtin_ia32_vfnmsubps256_mask3, "V8fV8fV8fV8fUc", "") +BUILTIN(__builtin_ia32_vfnmsubps512_mask, "V16fV16fV16fV16fUsIi", "") +BUILTIN(__builtin_ia32_vfnmsubps512_mask3, "V16fV16fV16fV16fUsIi", "") // XOP BUILTIN(__builtin_ia32_vpmacssww, "V8sV8sV8sV8s", "") @@ -1052,5 +1123,39 @@ BUILTIN(__builtin_ia32_orpd256_mask, "V4dV4dV4dV4dUc", "") BUILTIN(__builtin_ia32_orpd128_mask, "V2dV2dV2dV2dUc", "") BUILTIN(__builtin_ia32_orps256_mask, "V8fV8fV8fV8fUc", "") BUILTIN(__builtin_ia32_orps128_mask, "V4fV4fV4fV4fUc", "") +BUILTIN(__builtin_ia32_blendmb_512_mask, "V64cV64cV64cULLi", "") +BUILTIN(__builtin_ia32_blendmw_512_mask, "V32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_pabsb512_mask, "V64cV64cV64cULLi", "") +BUILTIN(__builtin_ia32_pabsw512_mask, "V32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_packssdw512_mask, "V32sV16iV16iV32sUi", "") +BUILTIN(__builtin_ia32_packsswb512_mask, "V64cV32sV32sV64cULLi", "") +BUILTIN(__builtin_ia32_packusdw512_mask, "V32sV16iV16iV32sUi", "") +BUILTIN(__builtin_ia32_packuswb512_mask, "V64cV32sV32sV64cULLi", "") +BUILTIN(__builtin_ia32_paddsb512_mask, "V64cV64cV64cV64cULLi", "") +BUILTIN(__builtin_ia32_paddsw512_mask, "V32sV32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_paddusb512_mask, "V64cV64cV64cV64cULLi", "") +BUILTIN(__builtin_ia32_paddusw512_mask, "V32sV32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_pavgb512_mask, "V64cV64cV64cV64cULLi", "") +BUILTIN(__builtin_ia32_pavgw512_mask, "V32sV32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_pmaxsb512_mask, "V64cV64cV64cV64cULLi", "") +BUILTIN(__builtin_ia32_pmaxsw512_mask, "V32sV32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_pmaxub512_mask, "V64cV64cV64cV64cULLi", "") +BUILTIN(__builtin_ia32_pmaxuw512_mask, "V32sV32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_pminsb512_mask, "V64cV64cV64cV64cULLi", "") +BUILTIN(__builtin_ia32_pminsw512_mask, "V32sV32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_pminub512_mask, "V64cV64cV64cV64cULLi", "") +BUILTIN(__builtin_ia32_pminuw512_mask, "V32sV32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_pshufb512_mask, "V64cV64cV64cV64cULLi", "") +BUILTIN(__builtin_ia32_psubsb512_mask, "V64cV64cV64cV64cULLi", "") +BUILTIN(__builtin_ia32_psubsw512_mask, "V32sV32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_psubusb512_mask, "V64cV64cV64cV64cULLi", "") +BUILTIN(__builtin_ia32_psubusw512_mask, "V32sV32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_vpermi2varhi512_mask, "V32sV32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_vpermt2varhi512_mask, "V32sV32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_vpermt2varhi512_maskz, "V32sV32sV32sV32sUi", "") +BUILTIN(__builtin_ia32_vpconflictdi_512_mask, "V8LLiV8LLiV8LLiUc", "") +BUILTIN(__builtin_ia32_vpconflictsi_512_mask, "V16iV16iV16iUs", "") +BUILTIN(__builtin_ia32_vplzcntd_512_mask, "V16iV16iV16iUs", "") +BUILTIN(__builtin_ia32_vplzcntq_512_mask, "V8LLiV8LLiV8LLiUc", "") #undef BUILTIN diff --git a/include/clang/Basic/Diagnostic.h b/include/clang/Basic/Diagnostic.h index 0f3831d6007e..3b7c282d37ad 100644 --- a/include/clang/Basic/Diagnostic.h +++ b/include/clang/Basic/Diagnostic.h @@ -18,6 +18,7 @@ #include "clang/Basic/DiagnosticIDs.h" #include "clang/Basic/DiagnosticOptions.h" #include "clang/Basic/SourceLocation.h" +#include "clang/Basic/Specifiers.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" @@ -1107,6 +1108,13 @@ inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, return DB; } +/// A nullability kind paired with a bit indicating whether it used a +/// context-sensitive keyword. +typedef std::pair<NullabilityKind, bool> DiagNullabilityKind; + +const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, + DiagNullabilityKind nullability); + inline DiagnosticBuilder DiagnosticsEngine::Report(SourceLocation Loc, unsigned DiagID) { assert(CurDiagID == ~0U && "Multiple diagnostics in flight at once!"); diff --git a/include/clang/Basic/DiagnosticCommonKinds.td b/include/clang/Basic/DiagnosticCommonKinds.td index 82718d9255f3..24813c67c2f5 100644 --- a/include/clang/Basic/DiagnosticCommonKinds.td +++ b/include/clang/Basic/DiagnosticCommonKinds.td @@ -102,31 +102,21 @@ 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'">, + "duplicate nullability specifier %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'">, + "conflicting nullability specifier on return types, %0 " + "conflicts with existing specifier %1">, 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'">, + "conflicting nullability specifier on parameter types, %0 " + "conflicts with existing specifier %1">, 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'">; + "nullability specifier %0 conflicts with existing specifier %1">; } diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index 803203cc50be..750219483c6c 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -426,6 +426,7 @@ def warn_redecl_library_builtin : Warning< 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 err_invalid_cpu_supports : Error<"invalid cpu feature string for builtin">; def warn_builtin_unknown : Warning<"use of unknown builtin %0">, InGroup<ImplicitFunctionDeclare>, DefaultError; def warn_dyn_class_memaccess : Warning< @@ -1050,6 +1051,7 @@ def ext_friend_tag_redecl_outside_namespace : ExtWarn< "unqualified friend declaration referring to type outside of the nearest " "enclosing namespace is a Microsoft extension; add a nested name specifier">, InGroup<Microsoft>; +def err_pure_friend : Error<"friend declaration cannot have a pure-specifier">; def err_invalid_member_in_interface : Error< "%select{data member |non-public member function |static member function |" @@ -1262,6 +1264,8 @@ def ext_mutable_reference : ExtWarn< def err_mutable_const : Error<"'mutable' and 'const' cannot be mixed">; def err_mutable_nonmember : Error< "'mutable' can only be applied to member variables">; +def err_virtual_in_union : Error< + "unions cannot have virtual functions">; def err_virtual_non_function : Error< "'virtual' can only appear on non-static member functions">; def err_virtual_out_of_class : Error< @@ -2081,12 +2085,16 @@ def err_attr_objc_ownership_redundant : Error< "the type %0 is already explicitly ownership-qualified">; def err_undeclared_nsnumber : Error< "NSNumber must be available to use Objective-C literals">; +def err_undeclared_nsvalue : Error< + "NSValue must be available to use Objective-C boxed expressions">; def err_invalid_nsnumber_type : Error< "%0 is not a valid literal type for NSNumber">; def err_undeclared_nsstring : Error< "cannot box a string value because NSString has not been declared">; def err_objc_illegal_boxed_expression_type : Error< "illegal type %0 used in a boxed expression">; +def err_objc_non_trivially_copyable_boxed_expression_type : Error< + "non-trivially copyable type %0 cannot be used in a boxed expression">; def err_objc_incomplete_boxed_expression_type : Error< "incomplete type %0 used in a boxed expression">; def err_undeclared_nsarray : Error< @@ -2190,7 +2198,7 @@ def err_attribute_invalid_on_stmt : Error< "%0 attribute cannot be applied to a statement">; def warn_declspec_attribute_ignored : Warning< "attribute %0 is ignored, place it after " - "\"%select{class|struct|union|interface|enum}1\" to apply attribute to " + "\"%select{class|struct|interface|union|enum}1\" to apply attribute to " "type declaration">, InGroup<IgnoredAttributes>; def warn_attribute_precede_definition : Warning< "attribute declaration must precede definition">, @@ -4690,13 +4698,15 @@ def ext_sizeof_alignof_void_type : Extension< "invalid application of '%select{sizeof|alignof|vec_step}0' to a void " "type">, InGroup<PointerArith>; def err_opencl_sizeof_alignof_type : Error< - "invalid application of '%select{sizeof|alignof|vec_step}0' to a void type">; + "invalid application of '%select{sizeof|alignof|vec_step|__builtin_omp_required_simd_align}0' to a void type">; def err_sizeof_alignof_incomplete_type : Error< - "invalid application of '%select{sizeof|alignof|vec_step}0' to an " + "invalid application of '%select{sizeof|alignof|vec_step|__builtin_omp_required_simd_align}0' to an " "incomplete type %1">; def err_sizeof_alignof_function_type : Error< - "invalid application of '%select{sizeof|alignof|vec_step}0' to a " + "invalid application of '%select{sizeof|alignof|vec_step|__builtin_omp_required_simd_align}0' to a " "function type">; +def err_openmp_default_simd_align_expr : Error< + "invalid application of '__builtin_omp_required_simd_align' to an expression, only type is allowed">; def err_sizeof_alignof_bitfield : Error< "invalid application of '%select{sizeof|alignof}0' to bit-field">; def err_alignof_member_of_incomplete_type : Error< @@ -6791,6 +6801,15 @@ def warn_format_non_standard_conversion_spec: Warning< def warn_printf_ignored_flag: Warning< "flag '%0' is ignored when flag '%1' is present">, InGroup<Format>; +def warn_printf_empty_objc_flag: Warning< + "missing object format flag">, + InGroup<Format>; +def warn_printf_ObjCflags_without_ObjCConversion: Warning< + "object format flags cannot be used with '%0' conversion specifier">, + InGroup<Format>; +def warn_printf_invalid_objc_flag: Warning< + "'%0' is not a valid object format flag">, + InGroup<Format>; def warn_scanf_scanlist_incomplete : Warning< "no closing ']' for '%%[' in scanf format string">, InGroup<Format>; @@ -7413,6 +7432,8 @@ def err_omp_unexpected_clause_value : Error< "expected %0 in OpenMP clause '%1'">; def err_omp_expected_var_name : Error< "expected variable name">; +def err_omp_expected_var_name_or_array_item : Error< + "expected variable name, array element or array section">; def note_omp_task_predetermined_firstprivate_here : Note< "predetermined as a firstprivate in a task construct here">; def err_omp_clause_ref_type_arg : Error< @@ -7601,6 +7622,12 @@ def err_omp_single_copyprivate_with_nowait : Error< "the 'copyprivate' clause must not be used with the 'nowait' clause">; def note_omp_nowait_clause_here : Note< "'nowait' clause is here">; +def err_omp_wrong_cancel_region : Error< + "one of 'for', 'parallel', 'sections' or 'taskgroup' is expected">; +def err_omp_parent_cancel_region_nowait : Error< + "parent region for 'omp %select{cancellation point/cancel}0' construct cannot be nowait">; +def err_omp_parent_cancel_region_ordered : Error< + "parent region for 'omp %select{cancellation point/cancel}0' construct cannot be ordered">; } // end of OpenMP category let CategoryName = "Related Result Type Issue" in { @@ -7677,28 +7704,21 @@ def warn_profile_data_unprofiled : Warning< 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'">, + "nullability specifier %0 conflicts with existing specifier %1">, InGroup<Nullability>; def warn_nullability_declspec : Warning< - "nullability specifier " - "'%select{__nonnull|__nullable|__null_unspecified}0' cannot be applied " + "nullability specifier %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 note_nullability_here : Note<"%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">; + "nullability specifier %0 cannot be applied to non-pointer type %1">; def warn_nullability_lost : Warning< "implicit conversion from nullable pointer %0 to non-nullable pointer " @@ -7706,12 +7726,9 @@ def warn_nullability_lost : Warning< 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">; + "nullability keyword %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 " + "use nullability type specifier %0 to affect the innermost " "pointer type of %1">; def warn_null_resettable_setter : Warning< @@ -7720,7 +7737,7 @@ def warn_null_resettable_setter : Warning< def warn_nullability_missing : Warning< "%select{pointer|block pointer|member pointer}0 is missing a nullability " - "type specifier (__nonnull, __nullable, or __null_unspecified)">, + "type specifier (_Nonnull, _Nullable, or _Null_unspecified)">, InGroup<NullabilityCompleteness>; } diff --git a/include/clang/Basic/IdentifierTable.h b/include/clang/Basic/IdentifierTable.h index bc586e41f854..33a8b747c62d 100644 --- a/include/clang/Basic/IdentifierTable.h +++ b/include/clang/Basic/IdentifierTable.h @@ -406,19 +406,6 @@ public: virtual IdentifierIterator *getIdentifiers(); }; -/// \brief An abstract class used to resolve numerical identifier -/// references (meaningful only to some external source) into -/// IdentifierInfo pointers. -class ExternalIdentifierLookup { -public: - virtual ~ExternalIdentifierLookup(); - - /// \brief Return the identifier associated with the given ID number. - /// - /// The ID 0 is associated with the NULL identifier. - virtual IdentifierInfo *GetIdentifier(unsigned ID) = 0; -}; - /// \brief Implements an efficient mapping from strings to IdentifierInfo nodes. /// /// This has no other purpose, but this is an extremely performance-critical diff --git a/include/clang/Basic/LangOptions.def b/include/clang/Basic/LangOptions.def index bef122f093c4..b27605b15d28 100644 --- a/include/clang/Basic/LangOptions.def +++ b/include/clang/Basic/LangOptions.def @@ -130,6 +130,7 @@ COMPATIBLE_LANGOPT(ModulesStrictDeclUse, 1, 0, "require declaration of module us 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(ModulesHideInternalLinkage, 1, 1, "hiding non-visible internal linkage declarations from redeclaration lookup") COMPATIBLE_LANGOPT(Optimize , 1, 0, "__OPTIMIZE__ predefined macro") COMPATIBLE_LANGOPT(OptimizeSize , 1, 0, "__OPTIMIZE_SIZE__ predefined macro") LANGOPT(Static , 1, 0, "__STATIC__ predefined macro (as opposed to __DYNAMIC__)") diff --git a/include/clang/Basic/LangOptions.h b/include/clang/Basic/LangOptions.h index 84836eb4e5c3..3c9d23efe63b 100644 --- a/include/clang/Basic/LangOptions.h +++ b/include/clang/Basic/LangOptions.h @@ -102,6 +102,8 @@ public: /// \brief The names of any features to enable in module 'requires' decls /// in addition to the hard-coded list in Module.cpp and the target features. + /// + /// This list is sorted. std::vector<std::string> ModuleFeatures; /// \brief Options for parsing comments. diff --git a/include/clang/Basic/Module.h b/include/clang/Basic/Module.h index 747061074038..1bc89257d384 100644 --- a/include/clang/Basic/Module.h +++ b/include/clang/Basic/Module.h @@ -66,6 +66,9 @@ public: /// \brief The umbrella header or directory. llvm::PointerUnion<const DirectoryEntry *, const FileEntry *> Umbrella; + /// \brief The module signature. + uint64_t Signature; + /// \brief The name of the umbrella entry, as written in the module map. std::string UmbrellaAsWritten; diff --git a/include/clang/Basic/OpenMPKinds.def b/include/clang/Basic/OpenMPKinds.def index b09f012c4317..67a5068cc2cb 100644 --- a/include/clang/Basic/OpenMPKinds.def +++ b/include/clang/Basic/OpenMPKinds.def @@ -69,6 +69,9 @@ #ifndef OPENMP_SCHEDULE_KIND #define OPENMP_SCHEDULE_KIND(Name) #endif +#ifndef OPENMP_DEPEND_KIND +#define OPENMP_DEPEND_KIND(Name) +#endif // OpenMP directives. OPENMP_DIRECTIVE(threadprivate) @@ -90,10 +93,12 @@ OPENMP_DIRECTIVE(ordered) OPENMP_DIRECTIVE(atomic) OPENMP_DIRECTIVE(target) OPENMP_DIRECTIVE(teams) +OPENMP_DIRECTIVE(cancel) OPENMP_DIRECTIVE_EXT(parallel_for, "parallel for") OPENMP_DIRECTIVE_EXT(parallel_for_simd, "parallel for simd") OPENMP_DIRECTIVE_EXT(parallel_sections, "parallel sections") OPENMP_DIRECTIVE_EXT(for_simd, "for simd") +OPENMP_DIRECTIVE_EXT(cancellation_point, "cancellation point") // OpenMP clauses. OPENMP_CLAUSE(if, OMPIfClause) @@ -123,6 +128,7 @@ OPENMP_CLAUSE(write, OMPWriteClause) OPENMP_CLAUSE(update, OMPUpdateClause) OPENMP_CLAUSE(capture, OMPCaptureClause) OPENMP_CLAUSE(seq_cst, OMPSeqCstClause) +OPENMP_CLAUSE(depend, OMPDependClause) // Clauses allowed for OpenMP directive 'parallel'. OPENMP_PARALLEL_CLAUSE(if) @@ -195,6 +201,11 @@ OPENMP_SCHEDULE_KIND(guided) OPENMP_SCHEDULE_KIND(auto) OPENMP_SCHEDULE_KIND(runtime) +// Static attributes for 'depend' clause. +OPENMP_DEPEND_KIND(in) +OPENMP_DEPEND_KIND(out) +OPENMP_DEPEND_KIND(inout) + // Clauses allowed for OpenMP directive 'parallel for'. OPENMP_PARALLEL_FOR_CLAUSE(if) OPENMP_PARALLEL_FOR_CLAUSE(num_threads) @@ -248,6 +259,7 @@ OPENMP_TASK_CLAUSE(firstprivate) OPENMP_TASK_CLAUSE(shared) OPENMP_TASK_CLAUSE(untied) OPENMP_TASK_CLAUSE(mergeable) +OPENMP_TASK_CLAUSE(depend) // Clauses allowed for OpenMP directive 'atomic'. OPENMP_ATOMIC_CLAUSE(read) @@ -268,6 +280,7 @@ OPENMP_TEAMS_CLAUSE(firstprivate) OPENMP_TEAMS_CLAUSE(shared) OPENMP_TEAMS_CLAUSE(reduction) +#undef OPENMP_DEPEND_KIND #undef OPENMP_SCHEDULE_KIND #undef OPENMP_PROC_BIND_KIND #undef OPENMP_DEFAULT_KIND diff --git a/include/clang/Basic/OpenMPKinds.h b/include/clang/Basic/OpenMPKinds.h index e2f115113e20..83939bb079a8 100644 --- a/include/clang/Basic/OpenMPKinds.h +++ b/include/clang/Basic/OpenMPKinds.h @@ -62,6 +62,14 @@ enum OpenMPScheduleClauseKind { OMPC_SCHEDULE_unknown }; +/// \brief OpenMP attributes for 'depend' clause. +enum OpenMPDependClauseKind { +#define OPENMP_DEPEND_KIND(Name) \ + OMPC_DEPEND_##Name, +#include "clang/Basic/OpenMPKinds.def" + OMPC_DEPEND_unknown +}; + OpenMPDirectiveKind getOpenMPDirectiveKind(llvm::StringRef Str); const char *getOpenMPDirectiveName(OpenMPDirectiveKind Kind); diff --git a/include/clang/Basic/Specifiers.h b/include/clang/Basic/Specifiers.h index 5ce56c0ee1f8..d95a77f88e97 100644 --- a/include/clang/Basic/Specifiers.h +++ b/include/clang/Basic/Specifiers.h @@ -257,7 +257,8 @@ namespace clang { }; /// Retrieve the spelling of the given nullability kind. - llvm::StringRef getNullabilitySpelling(NullabilityKind kind); + llvm::StringRef getNullabilitySpelling(NullabilityKind kind, + bool isContextSensitive = false); } // end namespace clang #endif // LLVM_CLANG_BASIC_SPECIFIERS_H diff --git a/include/clang/Basic/StmtNodes.td b/include/clang/Basic/StmtNodes.td index 675e91d866d0..9d7b6fb0cbe2 100644 --- a/include/clang/Basic/StmtNodes.td +++ b/include/clang/Basic/StmtNodes.td @@ -205,3 +205,5 @@ def OMPOrderedDirective : DStmt<OMPExecutableDirective>; def OMPAtomicDirective : DStmt<OMPExecutableDirective>; def OMPTargetDirective : DStmt<OMPExecutableDirective>; def OMPTeamsDirective : DStmt<OMPExecutableDirective>; +def OMPCancellationPointDirective : DStmt<OMPExecutableDirective>; +def OMPCancelDirective : DStmt<OMPExecutableDirective>; diff --git a/include/clang/Basic/TargetInfo.h b/include/clang/Basic/TargetInfo.h index e415733189ab..a3bb535fa26f 100644 --- a/include/clang/Basic/TargetInfo.h +++ b/include/clang/Basic/TargetInfo.h @@ -70,6 +70,7 @@ protected: unsigned char MinGlobalAlign; unsigned char MaxAtomicPromoteWidth, MaxAtomicInlineWidth; unsigned short MaxVectorAlign; + unsigned short SimdDefaultAlign; const char *DescriptionString; const char *UserLabelPrefix; const char *MCountName; @@ -393,6 +394,10 @@ public: /// \brief Return the maximum vector alignment supported for the given target. unsigned getMaxVectorAlign() const { return MaxVectorAlign; } + /// \brief Return default simd alignment for the given target. Generally, this + /// value is type-specific, but this alignment can be used for most of the + /// types for the given target. + unsigned getSimdDefaultAlign() const { return SimdDefaultAlign; } /// \brief Return the size of intmax_t and uintmax_t for this target, in bits. unsigned getIntMaxTWidth() const { @@ -611,6 +616,9 @@ public: } }; + // Validate the contents of the __builtin_cpu_supports(const char*) argument. + virtual bool validateCpuSupports(StringRef Name) const { return false; } + // validateOutputConstraint, validateInputConstraint - Checks that // a constraint is valid and provides information about it. // FIXME: These should return a real error instead of just true/false. diff --git a/include/clang/Basic/TokenKinds.def b/include/clang/Basic/TokenKinds.def index 67b9933562eb..ed2aa82d17e1 100644 --- a/include/clang/Basic/TokenKinds.def +++ b/include/clang/Basic/TokenKinds.def @@ -503,6 +503,9 @@ ALIAS("read_write", __read_write , KEYOPENCL) KEYWORD(__builtin_astype , KEYOPENCL) KEYWORD(vec_step , KEYOPENCL|KEYALTIVEC) +// OpenMP Type Traits +KEYWORD(__builtin_omp_required_simd_align, KEYALL) + // Borland Extensions. KEYWORD(__pascal , KEYALL) @@ -549,9 +552,9 @@ ALIAS("__volatile" , volatile , KEYALL) ALIAS("__volatile__" , volatile , KEYALL) // Type nullability. -KEYWORD(__nonnull , KEYALL) -KEYWORD(__nullable , KEYALL) -KEYWORD(__null_unspecified , KEYALL) +KEYWORD(_Nonnull , KEYALL) +KEYWORD(_Nullable , KEYALL) +KEYWORD(_Null_unspecified , KEYALL) // Microsoft extensions which should be disabled in strict conformance mode KEYWORD(__ptr64 , KEYMS) diff --git a/include/clang/Basic/TypeTraits.h b/include/clang/Basic/TypeTraits.h index ef84d2b11163..765246b4cc54 100644 --- a/include/clang/Basic/TypeTraits.h +++ b/include/clang/Basic/TypeTraits.h @@ -92,7 +92,8 @@ namespace clang { enum UnaryExprOrTypeTrait { UETT_SizeOf, UETT_AlignOf, - UETT_VecStep + UETT_VecStep, + UETT_OpenMPRequiredSimdAlign, }; } diff --git a/include/clang/CodeGen/CodeGenABITypes.h b/include/clang/CodeGen/CodeGenABITypes.h index 97a9dc82940d..4e76cd4d5b0b 100644 --- a/include/clang/CodeGen/CodeGenABITypes.h +++ b/include/clang/CodeGen/CodeGenABITypes.h @@ -37,9 +37,11 @@ namespace clang { class ASTContext; class CXXRecordDecl; class CodeGenOptions; +class CoverageSourceInfo; class DiagnosticsEngine; +class HeaderSearchOptions; class ObjCMethodDecl; -class CoverageSourceInfo; +class PreprocessorOptions; namespace CodeGen { class CGFunctionInfo; @@ -74,6 +76,8 @@ private: /// CodeGenModule and otherwise not used. More specifically, it is /// not used in ABI type generation, so none of the options matter. CodeGenOptions *CGO; + HeaderSearchOptions *HSO; + PreprocessorOptions *PPO; /// The CodeGenModule we use get to the CodeGenTypes object. CodeGen::CodeGenModule *CGM; diff --git a/include/clang/CodeGen/ModuleBuilder.h b/include/clang/CodeGen/ModuleBuilder.h index 8facc3c8307b..52497d9a9ac8 100644 --- a/include/clang/CodeGen/ModuleBuilder.h +++ b/include/clang/CodeGen/ModuleBuilder.h @@ -26,6 +26,8 @@ namespace clang { class DiagnosticsEngine; class CoverageSourceInfo; class LangOptions; + class HeaderSearchOptions; + class PreprocessorOptions; class CodeGenOptions; class Decl; @@ -42,6 +44,8 @@ namespace clang { /// the allocated CodeGenerator instance. CodeGenerator *CreateLLVMCodeGen(DiagnosticsEngine &Diags, const std::string &ModuleName, + const HeaderSearchOptions &HeaderSearchOpts, + const PreprocessorOptions &PreprocessorOpts, const CodeGenOptions &CGO, llvm::LLVMContext& C, CoverageSourceInfo *CoverageInfo = nullptr); diff --git a/include/clang/Driver/CC1Options.td b/include/clang/Driver/CC1Options.td index f2ef71e2f919..60cc6ec11568 100644 --- a/include/clang/Driver/CC1Options.td +++ b/include/clang/Driver/CC1Options.td @@ -369,6 +369,10 @@ def fmodules_local_submodule_visibility : Flag<["-"], "fmodules-local-submodule-visibility">, HelpText<"Enforce name visibility rules across submodules of the same " "top-level module.">; +def fno_modules_hide_internal_linkage : + Flag<["-"], "fno-modules-hide-internal-linkage">, + HelpText<"Make all declarations visible to redeclaration lookup, " + "even if they have internal linkage.">; def fconcepts_ts : Flag<["-"], "fconcepts-ts">, HelpText<"Enable C++ Extensions for Concepts.">; diff --git a/include/clang/Driver/CLCompatOptions.td b/include/clang/Driver/CLCompatOptions.td index 01913be93d56..cf6b76bf29f2 100644 --- a/include/clang/Driver/CLCompatOptions.td +++ b/include/clang/Driver/CLCompatOptions.td @@ -52,16 +52,18 @@ class CLRemainingArgs<string name> : Option<["/", "-"], name, // (We don't put any of these in cl_compile_Group as the options they alias are // already in the right group.) -def _SLASH_C : CLFlag<"C">, HelpText<"Don't discard comments when preprocessing">, - Alias<C>; +def _SLASH_C : CLFlag<"C">, + HelpText<"Don't discard comments when preprocessing">, Alias<C>; def _SLASH_c : CLFlag<"c">, HelpText<"Compile only">, Alias<c>; def _SLASH_D : CLJoinedOrSeparate<"D">, HelpText<"Define macro">, MetaVarName<"<macro[=value]>">, Alias<D>; def _SLASH_E : CLFlag<"E">, HelpText<"Preprocess to stdout">, Alias<E>; def _SLASH_fp_except : CLFlag<"fp:except">, HelpText<"">, Alias<ftrapping_math>; -def _SLASH_fp_except_ : CLFlag<"fp:except-">, HelpText<"">, Alias<fno_trapping_math>; +def _SLASH_fp_except_ : CLFlag<"fp:except-">, + HelpText<"">, Alias<fno_trapping_math>; def _SLASH_fp_fast : CLFlag<"fp:fast">, HelpText<"">, Alias<ffast_math>; -def _SLASH_fp_precise : CLFlag<"fp:precise">, HelpText<"">, Alias<fno_fast_math>; +def _SLASH_fp_precise : CLFlag<"fp:precise">, + HelpText<"">, Alias<fno_fast_math>; def _SLASH_fp_strict : CLFlag<"fp:strict">, HelpText<"">, Alias<fno_fast_math>; def _SLASH_GA : CLFlag<"GA">, Alias<ftlsmodel_EQ>, AliasArgs<["local-exec"]>, HelpText<"Assume thread-local variables are defined in the executable">; @@ -73,11 +75,13 @@ def _SLASH_Gs : CLJoined<"Gs">, HelpText<"Set stack probe size">, Alias<mstack_probe_size>; def _SLASH_Gy : CLFlag<"Gy">, HelpText<"Put each function in its own section">, Alias<ffunction_sections>; -def _SLASH_Gy_ : CLFlag<"Gy-">, HelpText<"Don't put each function in its own section">, +def _SLASH_Gy_ : CLFlag<"Gy-">, + HelpText<"Don't put each function in its own section">, Alias<fno_function_sections>; def _SLASH_Gw : CLFlag<"Gw">, HelpText<"Put each data item in its own section">, Alias<fdata_sections>; -def _SLASH_Gw_ : CLFlag<"Gw-">, HelpText<"Don't put each data item in its own section">, +def _SLASH_Gw_ : CLFlag<"Gw-">, + HelpText<"Don't put each data item in its own section">, Alias<fno_data_sections>; def _SLASH_help : CLFlag<"help">, Alias<help>, HelpText<"Display available options">; @@ -109,21 +113,15 @@ def _SLASH_Oy_ : CLFlag<"Oy-">, HelpText<"Disable frame pointer omission">, Alias<fno_omit_frame_pointer>; def _SLASH_QUESTION : CLFlag<"?">, Alias<help>, HelpText<"Display available options">; +def _SLASH_Qvec : CLFlag<"Qvec">, + HelpText<"Enable the loop vectorization passes">, Alias<fvectorize>; +def _SLASH_Qvec_ : CLFlag<"Qvec-">, + HelpText<"Disable the loop vectorization passes">, Alias<fno_vectorize>; def _SLASH_showIncludes : CLFlag<"showIncludes">, HelpText<"Print info about included files to stderr">, Alias<show_includes>; def _SLASH_U : CLJoinedOrSeparate<"U">, HelpText<"Undefine macro">, MetaVarName<"<macro>">, Alias<U>; -def _SLASH_vmb : CLFlag<"vmb">, - HelpText<"Use a best-case representation method for member pointers">; -def _SLASH_vmg : CLFlag<"vmg">, - HelpText<"Use a most-general representation for member pointers">; -def _SLASH_vms : CLFlag<"vms">, - HelpText<"Set the default most-general representation to single inheritance">; -def _SLASH_vmm : CLFlag<"vmm">, - HelpText<"Set the default most-general representation to multiple inheritance">; -def _SLASH_vmv : CLFlag<"vmv">, - HelpText<"Set the default most-general representation to virtual inheritance">; def _SLASH_W0 : CLFlag<"W0">, HelpText<"Disable all warnings">, Alias<w>; def _SLASH_W1 : CLFlag<"W1">, HelpText<"Enable -Wall">, Alias<Wall>; def _SLASH_W2 : CLFlag<"W2">, HelpText<"Enable -Wall">, Alias<Wall>; @@ -181,7 +179,8 @@ def _SLASH_arch : CLCompileJoined<"arch:">, HelpText<"Set architecture for code generation">; def _SLASH_M_Group : OptionGroup<"</M group>">, Group<cl_compile_Group>; -def _SLASH_volatile_Group : OptionGroup<"</volatile group>">, Group<cl_compile_Group>; +def _SLASH_volatile_Group : OptionGroup<"</volatile group>">, + Group<cl_compile_Group>; def _SLASH_EH : CLJoined<"EH">, HelpText<"Exception handling model">; def _SLASH_EP : CLFlag<"EP">, @@ -220,22 +219,30 @@ def _SLASH_o : CLJoinedOrSeparate<"o">, HelpText<"Set output file or directory (ends in / or \\)">, MetaVarName<"<file or directory>">; def _SLASH_P : CLFlag<"P">, HelpText<"Preprocess to file">; -def _SLASH_Qvec : CLFlag<"Qvec">, - HelpText<"Enable the loop vectorization passes">, - Alias<fvectorize>; -def _SLASH_Qvec_ : CLFlag<"Qvec-">, - HelpText<"Disable the loop vectorization passes">, - Alias<fno_vectorize>; def _SLASH_Tc : CLCompileJoinedOrSeparate<"Tc">, HelpText<"Specify a C source file">, MetaVarName<"<filename>">; def _SLASH_TC : CLCompileFlag<"TC">, HelpText<"Treat all source files as C">; def _SLASH_Tp : CLCompileJoinedOrSeparate<"Tp">, HelpText<"Specify a C++ source file">, MetaVarName<"<filename>">; def _SLASH_TP : CLCompileFlag<"TP">, HelpText<"Treat all source files as C++">; -def _SLASH_volatile_iso : Option<["/", "-"], "volatile:iso", KIND_FLAG>, Group<_SLASH_volatile_Group>, - Flags<[CLOption, DriverOption]>, HelpText<"Volatile loads and stores have standard semantics">; -def _SLASH_volatile_ms : Option<["/", "-"], "volatile:ms", KIND_FLAG>, Group<_SLASH_volatile_Group>, - Flags<[CLOption, DriverOption]>, HelpText<"Volatile loads and stores have acquire and release semantics">; +def _SLASH_volatile_iso : Option<["/", "-"], "volatile:iso", KIND_FLAG>, + Group<_SLASH_volatile_Group>, Flags<[CLOption, DriverOption]>, + HelpText<"Volatile loads and stores have standard semantics">; +def _SLASH_vmb : CLFlag<"vmb">, + HelpText<"Use a best-case representation method for member pointers">; +def _SLASH_vmg : CLFlag<"vmg">, + HelpText<"Use a most-general representation for member pointers">; +def _SLASH_vms : CLFlag<"vms">, + HelpText<"Set the default most-general representation to single inheritance">; +def _SLASH_vmm : CLFlag<"vmm">, + HelpText<"Set the default most-general representation to " + "multiple inheritance">; +def _SLASH_vmv : CLFlag<"vmv">, + HelpText<"Set the default most-general representation to " + "virtual inheritance">; +def _SLASH_volatile_ms : Option<["/", "-"], "volatile:ms", KIND_FLAG>, + Group<_SLASH_volatile_Group>, Flags<[CLOption, DriverOption]>, + HelpText<"Volatile loads and stores have acquire and release semantics">; // Ignored: diff --git a/include/clang/Driver/Compilation.h b/include/clang/Driver/Compilation.h index 5574e2ca0533..f0c1bedb3989 100644 --- a/include/clang/Driver/Compilation.h +++ b/include/clang/Driver/Compilation.h @@ -169,8 +169,9 @@ public: /// /// \param FailingCommands - For non-zero results, this will be a vector of /// failing commands and their associated result code. - void ExecuteJob(const Job &J, - SmallVectorImpl< std::pair<int, const Command *> > &FailingCommands) const; + void ExecuteJobs( + const JobList &Jobs, + SmallVectorImpl<std::pair<int, const Command *>> &FailingCommands) const; /// initCompilationForDiagnostics - Remove stale state and suppress output /// so compilation can be reexecuted to generate additional diagnostic diff --git a/include/clang/Driver/Driver.h b/include/clang/Driver/Driver.h index d7bb1d2283fb..15c194b09848 100644 --- a/include/clang/Driver/Driver.h +++ b/include/clang/Driver/Driver.h @@ -42,7 +42,7 @@ namespace driver { class Command; class Compilation; class InputInfo; - class Job; + class JobList; class JobAction; class SanitizerArgs; class ToolChain; @@ -195,7 +195,7 @@ private: llvm::opt::Arg **FinalPhaseArg = nullptr) const; // Before executing jobs, sets up response files for commands that need them. - void setUpResponseFiles(Compilation &C, Job &J); + void setUpResponseFiles(Compilation &C, Command &Cmd); void generatePrefixedToolNames(const char *Tool, const ToolChain &TC, SmallVectorImpl<std::string> &Names) const; @@ -262,7 +262,7 @@ public: /// ParseArgStrings - Parse the given list of strings into an /// ArgList. - llvm::opt::InputArgList *ParseArgStrings(ArrayRef<const char *> Args); + llvm::opt::InputArgList ParseArgStrings(ArrayRef<const char *> Args); /// BuildInputs - Construct the list of inputs and their types from /// the given arguments. diff --git a/include/clang/Driver/Job.h b/include/clang/Driver/Job.h index bc7e3ecaf06f..8fc2e8d3a5b9 100644 --- a/include/clang/Driver/Job.h +++ b/include/clang/Driver/Job.h @@ -37,37 +37,9 @@ struct CrashReportInfo { : Filename(Filename), VFSPath(VFSPath) {} }; -class Job { -public: - enum JobClass { - CommandClass, - FallbackCommandClass, - JobListClass - }; - -private: - JobClass Kind; - -protected: - Job(JobClass _Kind) : Kind(_Kind) {} -public: - virtual ~Job(); - - JobClass getKind() const { return Kind; } - - /// Print - Print this Job in -### format. - /// - /// \param OS - The stream to print on. - /// \param Terminator - A string to print at the end of the line. - /// \param Quote - Should separate arguments be quoted. - /// \param CrashInfo - Details for inclusion in a crash report. - virtual void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote, - CrashReportInfo *CrashInfo = nullptr) const = 0; -}; - /// Command - An executable path/name and argument vector to /// execute. -class Command : public Job { +class Command { /// Source - The action which caused the creation of this job. const Action &Source; @@ -106,11 +78,12 @@ class Command : public Job { void writeResponseFile(raw_ostream &OS) const; public: - Command(const Action &_Source, const Tool &_Creator, const char *_Executable, - const llvm::opt::ArgStringList &_Arguments); + Command(const Action &Source, const Tool &Creator, const char *Executable, + const llvm::opt::ArgStringList &Arguments); + virtual ~Command() {} - void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote, - CrashReportInfo *CrashInfo = nullptr) const override; + virtual void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote, + CrashReportInfo *CrashInfo = nullptr) const; virtual int Execute(const StringRef **Redirects, std::string *ErrMsg, bool *ExecutionFailed) const; @@ -133,11 +106,6 @@ public: const char *getExecutable() const { return Executable; } const llvm::opt::ArgStringList &getArguments() const { return Arguments; } - - static bool classof(const Job *J) { - return J->getKind() == CommandClass || - J->getKind() == FallbackCommandClass; - } }; /// Like Command, but with a fallback which is executed in case @@ -154,18 +122,14 @@ public: int Execute(const StringRef **Redirects, std::string *ErrMsg, bool *ExecutionFailed) const override; - static bool classof(const Job *J) { - return J->getKind() == FallbackCommandClass; - } - private: std::unique_ptr<Command> Fallback; }; /// JobList - A sequence of jobs to perform. -class JobList : public Job { +class JobList { public: - typedef SmallVector<std::unique_ptr<Job>, 4> list_type; + typedef SmallVector<std::unique_ptr<Command>, 4> list_type; typedef list_type::size_type size_type; typedef llvm::pointee_iterator<list_type::iterator> iterator; typedef llvm::pointee_iterator<list_type::const_iterator> const_iterator; @@ -174,14 +138,11 @@ private: list_type Jobs; public: - JobList(); - ~JobList() override {} - void Print(llvm::raw_ostream &OS, const char *Terminator, - bool Quote, CrashReportInfo *CrashInfo = nullptr) const override; + bool Quote, CrashReportInfo *CrashInfo = nullptr) const; /// Add a job to the list (taking ownership). - void addJob(std::unique_ptr<Job> J) { Jobs.push_back(std::move(J)); } + void addJob(std::unique_ptr<Command> J) { Jobs.push_back(std::move(J)); } /// Clear the job list. void clear(); @@ -193,10 +154,6 @@ public: const_iterator begin() const { return Jobs.begin(); } iterator end() { return Jobs.end(); } const_iterator end() const { return Jobs.end(); } - - static bool classof(const Job *J) { - return J->getKind() == JobListClass; - } }; } // end namespace driver diff --git a/include/clang/Driver/Options.td b/include/clang/Driver/Options.td index aae377693551..6a75b7c2c157 100644 --- a/include/clang/Driver/Options.td +++ b/include/clang/Driver/Options.td @@ -1153,6 +1153,11 @@ def march_EQ : Joined<["-"], "march=">, Group<m_Group>; def masm_EQ : Joined<["-"], "masm=">, Group<m_Group>, Flags<[DriverOption]>; def mcmodel_EQ : Joined<["-"], "mcmodel=">, Group<m_Group>; def mconstant_cfstrings : Flag<["-"], "mconstant-cfstrings">, Group<clang_ignored_m_Group>; +def mconsole : Joined<["-"], "mconsole">, Group<m_Group>, Flags<[DriverOption]>; +def mwindows : Joined<["-"], "mwindows">, Group<m_Group>, Flags<[DriverOption]>; +def mdll : Joined<["-"], "mdll">, Group<m_Group>, Flags<[DriverOption]>; +def municode : Joined<["-"], "municode">, Group<m_Group>, Flags<[DriverOption]>; +def mthreads : Joined<["-"], "mthreads">, Group<m_Group>, Flags<[DriverOption]>; def mcpu_EQ : Joined<["-"], "mcpu=">, Group<m_Group>; def mdynamic_no_pic : Joined<["-"], "mdynamic-no-pic">, Group<m_Group>; def mfix_and_continue : Flag<["-"], "mfix-and-continue">, Group<clang_ignored_m_Group>; @@ -1170,6 +1175,7 @@ def miphoneos_version_min_EQ : Joined<["-"], "miphoneos-version-min=">, Group<m_ def mios_version_min_EQ : Joined<["-"], "mios-version-min=">, Alias<miphoneos_version_min_EQ>, HelpText<"Set iOS deployment target">; def mios_simulator_version_min_EQ : Joined<["-"], "mios-simulator-version-min=">, Alias<miphoneos_version_min_EQ>; +def miphonesimulator_version_min_EQ : Joined<["-"], "miphonesimulator-version-min=">, Alias<miphoneos_version_min_EQ>; def mkernel : Flag<["-"], "mkernel">, Group<m_Group>; def mlinker_version_EQ : Joined<["-"], "mlinker-version=">, Flags<[DriverOption]>; @@ -1742,6 +1748,7 @@ def _warn_ : Joined<["--"], "warn-">, Alias<W_Joined>; def _write_dependencies : Flag<["--"], "write-dependencies">, Alias<MD>; def _write_user_dependencies : Flag<["--"], "write-user-dependencies">, Alias<MMD>; def _ : Joined<["--"], "">, Flags<[Unsupported]>; + def mieee_rnd_near : Flag<["-"], "mieee-rnd-near">, Group<m_hexagon_Features_Group>; def mv1 : Flag<["-"], "mv1">, Group<m_hexagon_Features_Group>, Alias<march_EQ>, AliasArgs<["v1"]>; diff --git a/include/clang/Driver/SanitizerArgs.h b/include/clang/Driver/SanitizerArgs.h index ceba912dad13..11bfd417e1ea 100644 --- a/include/clang/Driver/SanitizerArgs.h +++ b/include/clang/Driver/SanitizerArgs.h @@ -10,6 +10,7 @@ #define LLVM_CLANG_DRIVER_SANITIZERARGS_H #include "clang/Basic/Sanitizers.h" +#include "clang/Driver/Types.h" #include "llvm/Option/Arg.h" #include "llvm/Option/ArgList.h" #include <string> @@ -54,8 +55,8 @@ class SanitizerArgs { bool requiresPIE() const; bool needsUnwindTables() const; bool linkCXXRuntimes() const { return LinkCXXRuntimes; } - void addArgs(const llvm::opt::ArgList &Args, - llvm::opt::ArgStringList &CmdArgs) const; + void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const; private: void clear(); diff --git a/include/clang/Format/Format.h b/include/clang/Format/Format.h index ad87a057a6a7..6f9523cdc1ba 100644 --- a/include/clang/Format/Format.h +++ b/include/clang/Format/Format.h @@ -40,168 +40,50 @@ std::error_code make_error_code(ParseError e); /// \brief The \c FormatStyle is used to configure the formatting to follow /// specific guidelines. struct FormatStyle { - /// \brief Supported languages. When stored in a configuration file, specifies - /// the language, that the configuration targets. When passed to the - /// reformat() function, enables syntax features specific to the language. - enum LanguageKind { - /// Do not use. - LK_None, - /// Should be used for C, C++, ObjectiveC, ObjectiveC++. - LK_Cpp, - /// Should be used for Java. - LK_Java, - /// Should be used for JavaScript. - LK_JavaScript, - /// Should be used for Protocol Buffers - /// (https://developers.google.com/protocol-buffers/). - LK_Proto - }; - - /// \brief Language, this format style is targeted at. - LanguageKind Language; - - /// \brief The column limit. - /// - /// A column limit of \c 0 means that there is no column limit. In this case, - /// clang-format will respect the input's line breaking decisions within - /// statements unless they contradict other rules. - unsigned ColumnLimit; - - /// \brief The maximum number of consecutive empty lines to keep. - unsigned MaxEmptyLinesToKeep; - - /// \brief If true, empty lines at the start of blocks are kept. - bool KeepEmptyLinesAtTheStartOfBlocks; - - /// \brief The penalty for each line break introduced inside a comment. - unsigned PenaltyBreakComment; - - /// \brief The penalty for each line break introduced inside a string literal. - unsigned PenaltyBreakString; - - /// \brief The penalty for each character outside of the column limit. - unsigned PenaltyExcessCharacter; - - /// \brief The penalty for breaking before the first \c <<. - unsigned PenaltyBreakFirstLessLess; - - /// \brief The penalty for breaking a function call after "call(". - unsigned PenaltyBreakBeforeFirstCallParameter; - - /// \brief The & and * alignment style. - enum PointerAlignmentStyle { - /// Align pointer to the left. - PAS_Left, - /// Align pointer to the right. - PAS_Right, - /// Align pointer in the middle. - PAS_Middle - }; - - /// Pointer and reference alignment style. - PointerAlignmentStyle PointerAlignment; - - /// \brief If \c true, analyze the formatted file for the most common - /// alignment of & and *. \c PointerAlignment is then used only as fallback. - bool DerivePointerAlignment; - /// \brief The extra indent or outdent of access modifiers, e.g. \c public:. int AccessModifierOffset; - /// \brief Supported language standards. - enum LanguageStandard { - /// Use C++03-compatible syntax. - LS_Cpp03, - /// Use features of C++11 (e.g. \c A<A<int>> instead of - /// <tt>A<A<int> ></tt>). - LS_Cpp11, - /// Automatic detection based on the input. - LS_Auto - }; - - /// \brief Format compatible with this standard, e.g. use - /// <tt>A<A<int> ></tt> instead of \c A<A<int>> for LS_Cpp03. - LanguageStandard Standard; - - /// \brief Indent case labels one level from the switch statement. + /// \brief If \c true, horizontally aligns arguments after an open bracket. /// - /// When \c false, use the same indentation level as for the switch statement. - /// Switch statement body is always indented one level more than case labels. - bool IndentCaseLabels; - - /// \brief Indent if a function definition or declaration is wrapped after the - /// type. - bool IndentWrappedFunctionNames; - - /// \brief Different ways to indent namespace contents. - enum NamespaceIndentationKind { - /// Don't indent in namespaces. - NI_None, - /// Indent only in inner namespaces (nested in other namespaces). - NI_Inner, - /// Indent in all namespaces. - NI_All - }; - - /// \brief The indentation used for namespaces. - NamespaceIndentationKind NamespaceIndentation; + /// This applies to round brackets (parentheses), angle brackets and square + /// brackets. This will result in formattings like + /// \code + /// someLongFunction(argument1, + /// argument2); + /// \endcode + bool AlignAfterOpenBracket; - /// \brief The number of spaces before trailing line comments - /// (\c // - comments). + /// \brief If \c true, aligns consecutive assignments. /// - /// This does not affect trailing block comments (\c /**/ - comments) as those - /// commonly have different usage patterns and a number of special cases. - unsigned SpacesBeforeTrailingComments; + /// This will align the assignment operators of consecutive lines. This + /// will result in formattings like + /// \code + /// int aaaa = 12; + /// int b = 23; + /// int ccc = 23; + /// \endcode + bool AlignConsecutiveAssignments; - /// \brief If \c false, a function declaration's or function definition's - /// parameters will either all be on the same line or will have one line each. - bool BinPackParameters; + /// \brief If \c true, aligns escaped newlines as far left as possible. + /// Otherwise puts them into the right-most column. + bool AlignEscapedNewlinesLeft; - /// \brief If \c false, a function call's arguments will either be all on the - /// same line or will have one line each. - bool BinPackArguments; + /// \brief If \c true, horizontally align operands of binary and ternary + /// expressions. + bool AlignOperands; - /// \brief If \c true, clang-format detects whether function calls and - /// definitions are formatted with one parameter per line. - /// - /// Each call can be bin-packed, one-per-line or inconclusive. If it is - /// inconclusive, e.g. completely on one line, but a decision needs to be - /// made, clang-format analyzes whether there are other bin-packed cases in - /// the input file and act accordingly. - /// - /// NOTE: This is an experimental flag, that might go away or be renamed. Do - /// not use this in config files, etc. Use at your own risk. - bool ExperimentalAutoDetectBinPacking; + /// \brief If \c true, aligns trailing comments. + bool AlignTrailingComments; /// \brief Allow putting all parameters of a function declaration onto /// the next line even if \c BinPackParameters is \c false. bool AllowAllParametersOfDeclarationOnNextLine; - /// \brief Penalty for putting the return type of a function onto its own - /// line. - unsigned PenaltyReturnTypeOnItsOwnLine; - - /// \brief If the constructor initializers don't fit on a line, put each - /// initializer on its own line. - bool ConstructorInitializerAllOnOneLineOrOnePerLine; - - /// \brief Always break constructor initializers before commas and align - /// the commas with the colon. - bool BreakConstructorInitializersBeforeComma; - /// \brief Allows contracting simple braced statements to a single line. /// /// E.g., this allows <tt>if (a) { return; }</tt> to be put on a single line. bool AllowShortBlocksOnASingleLine; - /// \brief If \c true, <tt>if (a) return;</tt> can be put on a single - /// line. - bool AllowShortIfStatementsOnASingleLine; - - /// \brief If \c true, <tt>while (true) continue;</tt> can be put on a - /// single line. - bool AllowShortLoopsOnASingleLine; - /// \brief If \c true, short case labels will be contracted to a single line. bool AllowShortCaseLabelsOnASingleLine; @@ -222,69 +104,27 @@ struct FormatStyle { /// on a single line. ShortFunctionStyle AllowShortFunctionsOnASingleLine; - /// \brief Add a space after \c @property in Objective-C, i.e. use - /// <tt>\@property (readonly)</tt> instead of <tt>\@property(readonly)</tt>. - bool ObjCSpaceAfterProperty; - - /// \brief Add a space in front of an Objective-C protocol list, i.e. use - /// <tt>Foo <Protocol></tt> instead of \c Foo<Protocol>. - bool ObjCSpaceBeforeProtocolList; - - /// \brief If \c true, horizontally aligns arguments after an open bracket. - /// - /// This applies to round brackets (parentheses), angle brackets and square - /// brackets. This will result in formattings like - /// \code - /// someLongFunction(argument1, - /// argument2); - /// \endcode - bool AlignAfterOpenBracket; - - /// \brief If \c true, horizontally align operands of binary and ternary - /// expressions. - bool AlignOperands; - - /// \brief If \c true, aligns trailing comments. - bool AlignTrailingComments; - - /// \brief If \c true, aligns consecutive assignments. - /// - /// This will align the assignment operators of consecutive lines. This - /// will result in formattings like - /// \code - /// int aaaa = 12; - /// int b = 23; - /// int ccc = 23; - /// \endcode - bool AlignConsecutiveAssignments; - - /// \brief If \c true, aligns escaped newlines as far left as possible. - /// Otherwise puts them into the right-most column. - bool AlignEscapedNewlinesLeft; - - /// \brief The number of columns to use for indentation. - unsigned IndentWidth; - - /// \brief The number of columns used for tab stops. - unsigned TabWidth; - - /// \brief The number of characters to use for indentation of constructor - /// initializer lists. - unsigned ConstructorInitializerIndentWidth; + /// \brief If \c true, <tt>if (a) return;</tt> can be put on a single + /// line. + bool AllowShortIfStatementsOnASingleLine; - /// \brief The number of characters to use for indentation of ObjC blocks. - unsigned ObjCBlockIndentWidth; + /// \brief If \c true, <tt>while (true) continue;</tt> can be put on a + /// single line. + bool AllowShortLoopsOnASingleLine; - /// \brief If \c true, always break after function definition return types. - /// - /// More truthfully called 'break before the identifier following the type - /// in a function definition'. PenaltyReturnTypeOnItsOwnLine becomes - /// irrelevant. - bool AlwaysBreakAfterDefinitionReturnType; + /// \brief Different ways to break after the function definition return type. + enum DefinitionReturnTypeBreakingStyle { + /// Break after return type automatically. + /// \c PenaltyReturnTypeOnItsOwnLine is taken into account. + DRTBS_None, + /// Always break after the return type. + DRTBS_All, + /// Always break after the return types of top level functions. + DRTBS_TopLevel, + }; - /// \brief If \c true, always break after the <tt>template<...></tt> of a - /// template declaration. - bool AlwaysBreakTemplateDeclarations; + /// \brief The function definition return type breaking style to use. + DefinitionReturnTypeBreakingStyle AlwaysBreakAfterDefinitionReturnType; /// \brief If \c true, always break before multiline string literals. /// @@ -294,19 +134,17 @@ struct FormatStyle { /// \c ContinuationIndentWidth spaces from the start of the line. bool AlwaysBreakBeforeMultilineStrings; - /// \brief Different ways to use tab in formatting. - enum UseTabStyle { - /// Never use tab. - UT_Never, - /// Use tabs only for indentation. - UT_ForIndentation, - /// Use tabs whenever we need to fill whitespace that spans at least from - /// one tab stop to the next one. - UT_Always - }; + /// \brief If \c true, always break after the <tt>template<...></tt> of a + /// template declaration. + bool AlwaysBreakTemplateDeclarations; - /// \brief The way to use tab characters in the resulting file. - UseTabStyle UseTab; + /// \brief If \c false, a function call's arguments will either be all on the + /// same line or will have one line each. + bool BinPackArguments; + + /// \brief If \c false, a function declaration's or function definition's + /// parameters will either all be on the same line or will have one line each. + bool BinPackParameters; /// \brief The style of breaking before or after binary operators. enum BinaryOperatorStyle { @@ -321,9 +159,6 @@ struct FormatStyle { /// \brief The way to wrap binary operators. BinaryOperatorStyle BreakBeforeBinaryOperators; - /// \brief If \c true, ternary operators will be placed after line breaks. - bool BreakBeforeTernaryOperators; - /// \brief Different ways to attach braces to their surrounding context. enum BraceBreakingStyle { /// Always attach braces to surrounding context. @@ -344,6 +179,35 @@ struct FormatStyle { /// \brief The brace breaking style to use. BraceBreakingStyle BreakBeforeBraces; + /// \brief If \c true, ternary operators will be placed after line breaks. + bool BreakBeforeTernaryOperators; + + /// \brief Always break constructor initializers before commas and align + /// the commas with the colon. + bool BreakConstructorInitializersBeforeComma; + + /// \brief The column limit. + /// + /// A column limit of \c 0 means that there is no column limit. In this case, + /// clang-format will respect the input's line breaking decisions within + /// statements unless they contradict other rules. + unsigned ColumnLimit; + + /// \brief A regular expression that describes comments with special meaning, + /// which should not be split into lines or otherwise changed. + std::string CommentPragmas; + + /// \brief If the constructor initializers don't fit on a line, put each + /// initializer on its own line. + bool ConstructorInitializerAllOnOneLineOrOnePerLine; + + /// \brief The number of characters to use for indentation of constructor + /// initializer lists. + unsigned ConstructorInitializerIndentWidth; + + /// \brief Indent width for line continuations. + unsigned ContinuationIndentWidth; + /// \brief If \c true, format braced lists as best suited for C++11 braced /// lists. /// @@ -359,29 +223,138 @@ struct FormatStyle { /// a zero-length name is assumed. bool Cpp11BracedListStyle; - /// \brief If \c true, spaces will be inserted after '(' and before ')'. - bool SpacesInParentheses; + /// \brief If \c true, analyze the formatted file for the most common + /// alignment of & and *. \c PointerAlignment is then used only as fallback. + bool DerivePointerAlignment; - /// \brief If \c true, spaces will be inserted after '<' and before '>' in - /// template argument lists - bool SpacesInAngles; + /// \brief Disables formatting completely. + bool DisableFormat; - /// \brief If \c true, spaces will be inserted after '[' and before ']'. - bool SpacesInSquareBrackets; + /// \brief If \c true, clang-format detects whether function calls and + /// definitions are formatted with one parameter per line. + /// + /// Each call can be bin-packed, one-per-line or inconclusive. If it is + /// inconclusive, e.g. completely on one line, but a decision needs to be + /// made, clang-format analyzes whether there are other bin-packed cases in + /// the input file and act accordingly. + /// + /// NOTE: This is an experimental flag, that might go away or be renamed. Do + /// not use this in config files, etc. Use at your own risk. + bool ExperimentalAutoDetectBinPacking; - /// \brief If \c true, spaces may be inserted into '()'. - bool SpaceInEmptyParentheses; + /// \brief A vector of macros that should be interpreted as foreach loops + /// instead of as function calls. + /// + /// These are expected to be macros of the form: + /// \code + /// FOREACH(<variable-declaration>, ...) + /// <loop-body> + /// \endcode + /// + /// For example: BOOST_FOREACH. + std::vector<std::string> ForEachMacros; - /// \brief If \c true, spaces are inserted inside container literals (e.g. - /// ObjC and Javascript array and dict literals). - bool SpacesInContainerLiterals; + /// \brief Indent case labels one level from the switch statement. + /// + /// When \c false, use the same indentation level as for the switch statement. + /// Switch statement body is always indented one level more than case labels. + bool IndentCaseLabels; - /// \brief If \c true, spaces may be inserted into C style casts. - bool SpacesInCStyleCastParentheses; + /// \brief The number of columns to use for indentation. + unsigned IndentWidth; + + /// \brief Indent if a function definition or declaration is wrapped after the + /// type. + bool IndentWrappedFunctionNames; + + /// \brief If true, empty lines at the start of blocks are kept. + bool KeepEmptyLinesAtTheStartOfBlocks; + + /// \brief Supported languages. When stored in a configuration file, specifies + /// the language, that the configuration targets. When passed to the + /// reformat() function, enables syntax features specific to the language. + enum LanguageKind { + /// Do not use. + LK_None, + /// Should be used for C, C++, ObjectiveC, ObjectiveC++. + LK_Cpp, + /// Should be used for Java. + LK_Java, + /// Should be used for JavaScript. + LK_JavaScript, + /// Should be used for Protocol Buffers + /// (https://developers.google.com/protocol-buffers/). + LK_Proto + }; + + /// \brief Language, this format style is targeted at. + LanguageKind Language; + + /// \brief The maximum number of consecutive empty lines to keep. + unsigned MaxEmptyLinesToKeep; + + /// \brief Different ways to indent namespace contents. + enum NamespaceIndentationKind { + /// Don't indent in namespaces. + NI_None, + /// Indent only in inner namespaces (nested in other namespaces). + NI_Inner, + /// Indent in all namespaces. + NI_All + }; + + /// \brief The indentation used for namespaces. + NamespaceIndentationKind NamespaceIndentation; + + /// \brief The number of characters to use for indentation of ObjC blocks. + unsigned ObjCBlockIndentWidth; + + /// \brief Add a space after \c @property in Objective-C, i.e. use + /// <tt>\@property (readonly)</tt> instead of <tt>\@property(readonly)</tt>. + bool ObjCSpaceAfterProperty; + + /// \brief Add a space in front of an Objective-C protocol list, i.e. use + /// <tt>Foo <Protocol></tt> instead of \c Foo<Protocol>. + bool ObjCSpaceBeforeProtocolList; + + /// \brief The penalty for breaking a function call after "call(". + unsigned PenaltyBreakBeforeFirstCallParameter; + + /// \brief The penalty for each line break introduced inside a comment. + unsigned PenaltyBreakComment; + + /// \brief The penalty for breaking before the first \c <<. + unsigned PenaltyBreakFirstLessLess; + + /// \brief The penalty for each line break introduced inside a string literal. + unsigned PenaltyBreakString; + + /// \brief The penalty for each character outside of the column limit. + unsigned PenaltyExcessCharacter; + + /// \brief Penalty for putting the return type of a function onto its own + /// line. + unsigned PenaltyReturnTypeOnItsOwnLine; + + /// \brief The & and * alignment style. + enum PointerAlignmentStyle { + /// Align pointer to the left. + PAS_Left, + /// Align pointer to the right. + PAS_Right, + /// Align pointer in the middle. + PAS_Middle + }; + + /// Pointer and reference alignment style. + PointerAlignmentStyle PointerAlignment; /// \brief If \c true, a space may be inserted after C style casts. bool SpaceAfterCStyleCast; + /// \brief If \c false, spaces will be removed before assignment operators. + bool SpaceBeforeAssignmentOperators; + /// \brief Different ways to put a space before opening parentheses. enum SpaceBeforeParensOptions { /// Never put a space before opening parentheses. @@ -399,97 +372,139 @@ struct FormatStyle { /// \brief Defines in which cases to put a space before opening parentheses. SpaceBeforeParensOptions SpaceBeforeParens; - /// \brief If \c false, spaces will be removed before assignment operators. - bool SpaceBeforeAssignmentOperators; + /// \brief If \c true, spaces may be inserted into '()'. + bool SpaceInEmptyParentheses; - /// \brief Indent width for line continuations. - unsigned ContinuationIndentWidth; + /// \brief The number of spaces before trailing line comments + /// (\c // - comments). + /// + /// This does not affect trailing block comments (\c /**/ - comments) as those + /// commonly have different usage patterns and a number of special cases. + unsigned SpacesBeforeTrailingComments; - /// \brief A regular expression that describes comments with special meaning, - /// which should not be split into lines or otherwise changed. - std::string CommentPragmas; + /// \brief If \c true, spaces will be inserted after '<' and before '>' in + /// template argument lists + bool SpacesInAngles; - /// \brief Disables formatting at all. - bool DisableFormat; + /// \brief If \c true, spaces are inserted inside container literals (e.g. + /// ObjC and Javascript array and dict literals). + bool SpacesInContainerLiterals; - /// \brief A vector of macros that should be interpreted as foreach loops - /// instead of as function calls. - /// - /// These are expected to be macros of the form: - /// \code - /// FOREACH(<variable-declaration>, ...) - /// <loop-body> - /// \endcode - /// - /// For example: BOOST_FOREACH. - std::vector<std::string> ForEachMacros; + /// \brief If \c true, spaces may be inserted into C style casts. + bool SpacesInCStyleCastParentheses; + + /// \brief If \c true, spaces will be inserted after '(' and before ')'. + bool SpacesInParentheses; + + /// \brief If \c true, spaces will be inserted after '[' and before ']'. + bool SpacesInSquareBrackets; + + /// \brief Supported language standards. + enum LanguageStandard { + /// Use C++03-compatible syntax. + LS_Cpp03, + /// Use features of C++11 (e.g. \c A<A<int>> instead of + /// <tt>A<A<int> ></tt>). + LS_Cpp11, + /// Automatic detection based on the input. + LS_Auto + }; + + /// \brief Format compatible with this standard, e.g. use + /// <tt>A<A<int> ></tt> instead of \c A<A<int>> for LS_Cpp03. + LanguageStandard Standard; + + /// \brief The number of columns used for tab stops. + unsigned TabWidth; + + /// \brief Different ways to use tab in formatting. + enum UseTabStyle { + /// Never use tab. + UT_Never, + /// Use tabs only for indentation. + UT_ForIndentation, + /// Use tabs whenever we need to fill whitespace that spans at least from + /// one tab stop to the next one. + UT_Always + }; + + /// \brief The way to use tab characters in the resulting file. + UseTabStyle UseTab; bool operator==(const FormatStyle &R) const { return AccessModifierOffset == R.AccessModifierOffset && AlignAfterOpenBracket == R.AlignAfterOpenBracket && - AlignOperands == R.AlignOperands && + AlignConsecutiveAssignments == R.AlignConsecutiveAssignments && AlignEscapedNewlinesLeft == R.AlignEscapedNewlinesLeft && + AlignOperands == R.AlignOperands && AlignTrailingComments == R.AlignTrailingComments && AllowAllParametersOfDeclarationOnNextLine == R.AllowAllParametersOfDeclarationOnNextLine && + AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine && + AllowShortCaseLabelsOnASingleLine == + R.AllowShortCaseLabelsOnASingleLine && AllowShortFunctionsOnASingleLine == R.AllowShortFunctionsOnASingleLine && - AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine && AllowShortIfStatementsOnASingleLine == R.AllowShortIfStatementsOnASingleLine && AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine && AlwaysBreakAfterDefinitionReturnType == R.AlwaysBreakAfterDefinitionReturnType && - AlwaysBreakTemplateDeclarations == - R.AlwaysBreakTemplateDeclarations && AlwaysBreakBeforeMultilineStrings == R.AlwaysBreakBeforeMultilineStrings && - BinPackParameters == R.BinPackParameters && + AlwaysBreakTemplateDeclarations == + R.AlwaysBreakTemplateDeclarations && BinPackArguments == R.BinPackArguments && + BinPackParameters == R.BinPackParameters && BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators && - BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators && BreakBeforeBraces == R.BreakBeforeBraces && + BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators && BreakConstructorInitializersBeforeComma == R.BreakConstructorInitializersBeforeComma && ColumnLimit == R.ColumnLimit && + CommentPragmas == R.CommentPragmas && ConstructorInitializerAllOnOneLineOrOnePerLine == R.ConstructorInitializerAllOnOneLineOrOnePerLine && ConstructorInitializerIndentWidth == R.ConstructorInitializerIndentWidth && + ContinuationIndentWidth == R.ContinuationIndentWidth && + Cpp11BracedListStyle == R.Cpp11BracedListStyle && DerivePointerAlignment == R.DerivePointerAlignment && + DisableFormat == R.DisableFormat && ExperimentalAutoDetectBinPacking == R.ExperimentalAutoDetectBinPacking && + ForEachMacros == R.ForEachMacros && IndentCaseLabels == R.IndentCaseLabels && - IndentWrappedFunctionNames == R.IndentWrappedFunctionNames && IndentWidth == R.IndentWidth && Language == R.Language && - MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep && + IndentWrappedFunctionNames == R.IndentWrappedFunctionNames && KeepEmptyLinesAtTheStartOfBlocks == R.KeepEmptyLinesAtTheStartOfBlocks && + MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep && NamespaceIndentation == R.NamespaceIndentation && ObjCBlockIndentWidth == R.ObjCBlockIndentWidth && ObjCSpaceAfterProperty == R.ObjCSpaceAfterProperty && ObjCSpaceBeforeProtocolList == R.ObjCSpaceBeforeProtocolList && + PenaltyBreakBeforeFirstCallParameter == + R.PenaltyBreakBeforeFirstCallParameter && PenaltyBreakComment == R.PenaltyBreakComment && PenaltyBreakFirstLessLess == R.PenaltyBreakFirstLessLess && PenaltyBreakString == R.PenaltyBreakString && PenaltyExcessCharacter == R.PenaltyExcessCharacter && PenaltyReturnTypeOnItsOwnLine == R.PenaltyReturnTypeOnItsOwnLine && PointerAlignment == R.PointerAlignment && + SpaceAfterCStyleCast == R.SpaceAfterCStyleCast && + SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators && + SpaceBeforeParens == R.SpaceBeforeParens && + SpaceInEmptyParentheses == R.SpaceInEmptyParentheses && SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments && - Cpp11BracedListStyle == R.Cpp11BracedListStyle && - Standard == R.Standard && TabWidth == R.TabWidth && - UseTab == R.UseTab && SpacesInParentheses == R.SpacesInParentheses && - SpacesInSquareBrackets == R.SpacesInSquareBrackets && SpacesInAngles == R.SpacesInAngles && - SpaceInEmptyParentheses == R.SpaceInEmptyParentheses && SpacesInContainerLiterals == R.SpacesInContainerLiterals && SpacesInCStyleCastParentheses == R.SpacesInCStyleCastParentheses && - SpaceAfterCStyleCast == R.SpaceAfterCStyleCast && - SpaceBeforeParens == R.SpaceBeforeParens && - SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators && - ContinuationIndentWidth == R.ContinuationIndentWidth && - CommentPragmas == R.CommentPragmas && - ForEachMacros == R.ForEachMacros; + SpacesInParentheses == R.SpacesInParentheses && + SpacesInSquareBrackets == R.SpacesInSquareBrackets && + Standard == R.Standard && + TabWidth == R.TabWidth && + UseTab == R.UseTab; } }; diff --git a/include/clang/Lex/ExternalPreprocessorSource.h b/include/clang/Lex/ExternalPreprocessorSource.h index 33e7a2d84b88..adf8e713e99e 100644 --- a/include/clang/Lex/ExternalPreprocessorSource.h +++ b/include/clang/Lex/ExternalPreprocessorSource.h @@ -23,7 +23,7 @@ class Module; /// information. /// /// This abstract class allows an external sources (such as the \c ASTReader) -/// to provide additional macro definitions. +/// to provide additional preprocessing information. class ExternalPreprocessorSource { public: virtual ~ExternalPreprocessorSource(); @@ -34,6 +34,11 @@ public: /// \brief Update an out-of-date identifier. virtual void updateOutOfDateIdentifier(IdentifierInfo &II) = 0; + /// \brief Return the identifier associated with the given ID number. + /// + /// The ID 0 is associated with the NULL identifier. + virtual IdentifierInfo *GetIdentifier(unsigned ID) = 0; + /// \brief Map a module ID to a module. virtual Module *getModule(unsigned ModuleID) = 0; }; diff --git a/include/clang/Lex/HeaderSearch.h b/include/clang/Lex/HeaderSearch.h index 0406c6d586ff..4c1338010078 100644 --- a/include/clang/Lex/HeaderSearch.h +++ b/include/clang/Lex/HeaderSearch.h @@ -27,7 +27,7 @@ namespace clang { class DiagnosticsEngine; -class ExternalIdentifierLookup; +class ExternalPreprocessorSource; class FileEntry; class FileManager; class HeaderSearchOptions; @@ -111,8 +111,9 @@ struct HeaderFileInfo { /// \brief Retrieve the controlling macro for this header file, if /// any. - const IdentifierInfo *getControllingMacro(ExternalIdentifierLookup *External); - + const IdentifierInfo * + getControllingMacro(ExternalPreprocessorSource *External); + /// \brief Determine whether this is a non-default header file info, e.g., /// it corresponds to an actual header we've included or tried to include. bool isNonDefault() const { @@ -242,8 +243,9 @@ class HeaderSearch { llvm::StringSet<llvm::BumpPtrAllocator> FrameworkNames; /// \brief Entity used to resolve the identifier IDs of controlling - /// macros into IdentifierInfo pointers, as needed. - ExternalIdentifierLookup *ExternalLookup; + /// macros into IdentifierInfo pointers, and keep the identifire up to date, + /// as needed. + ExternalPreprocessorSource *ExternalLookup; /// \brief Entity used to look up stored header file information. ExternalHeaderFileInfoSource *ExternalSource; @@ -345,11 +347,11 @@ public: FileInfo.clear(); } - void SetExternalLookup(ExternalIdentifierLookup *EIL) { - ExternalLookup = EIL; + void SetExternalLookup(ExternalPreprocessorSource *EPS) { + ExternalLookup = EPS; } - ExternalIdentifierLookup *getExternalLookup() const { + ExternalPreprocessorSource *getExternalLookup() const { return ExternalLookup; } @@ -421,7 +423,7 @@ public: /// \return false if \#including the file will have no effect or true /// if we should include it. bool ShouldEnterIncludeFile(Preprocessor &PP, const FileEntry *File, - bool isImport); + bool isImport, Module *CorrespondingModule); /// \brief Return whether the specified file is a normal header, /// a system header, or a C++ friendly system header. diff --git a/include/clang/Lex/ModuleMap.h b/include/clang/Lex/ModuleMap.h index 0bbcfac3b81b..2b18a7df53dd 100644 --- a/include/clang/Lex/ModuleMap.h +++ b/include/clang/Lex/ModuleMap.h @@ -231,8 +231,7 @@ private: return static_cast<bool>(findHeaderInUmbrellaDirs(File, IntermediateDirs)); } - Module *inferFrameworkModule(StringRef ModuleName, - const DirectoryEntry *FrameworkDir, + Module *inferFrameworkModule(const DirectoryEntry *FrameworkDir, Attributes Attrs, Module *Parent); public: @@ -344,10 +343,9 @@ public: /// \brief Infer the contents of a framework module map from the given /// framework directory. - Module *inferFrameworkModule(StringRef ModuleName, - const DirectoryEntry *FrameworkDir, + Module *inferFrameworkModule(const DirectoryEntry *FrameworkDir, bool IsSystem, Module *Parent); - + /// \brief Retrieve the module map file containing the definition of the given /// module. /// diff --git a/include/clang/Lex/Preprocessor.h b/include/clang/Lex/Preprocessor.h index 439a28041e2d..bba0c38cec77 100644 --- a/include/clang/Lex/Preprocessor.h +++ b/include/clang/Lex/Preprocessor.h @@ -394,7 +394,9 @@ class Preprocessor : public RefCountedBase<Preprocessor> { const IdentifierInfo *II) const { // FIXME: Find a spare bit on IdentifierInfo and store a // HasModuleMacros flag. - if (!II->hasMacroDefinition() || !PP.getLangOpts().Modules || + if (!II->hasMacroDefinition() || + (!PP.getLangOpts().Modules && + !PP.getLangOpts().ModulesLocalVisibility) || !PP.CurSubmoduleState->VisibleModules.getGeneration()) return nullptr; @@ -454,7 +456,9 @@ class Preprocessor : public RefCountedBase<Preprocessor> { MacroDirective::DefInfo findDirectiveAtLoc(SourceLocation Loc, SourceManager &SourceMgr) const { // FIXME: Incorporate module macros into the result of this. - return getLatest()->findDirectiveAtLoc(Loc, SourceMgr); + if (auto *Latest = getLatest()) + return Latest->findDirectiveAtLoc(Loc, SourceMgr); + return MacroDirective::DefInfo(); } void overrideActiveModuleMacros(Preprocessor &PP, IdentifierInfo *II) { diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h index 7042a1ef6e29..97a0aa482d2b 100644 --- a/include/clang/Parse/Parser.h +++ b/include/clang/Parse/Parser.h @@ -303,7 +303,7 @@ public: return true; } - /// Retrieve the underscored keyword (__nonnull, __nullable) that corresponds + /// Retrieve the underscored keyword (_Nonnull, _Nullable) that corresponds /// to the given nullability kind. IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability) { return Actions.getNullabilityKeyword(nullability); @@ -1182,7 +1182,7 @@ private: ParsingDeclarator &D, const ParsedTemplateInfo &TemplateInfo, const VirtSpecifiers& VS, - ExprResult& Init); + SourceLocation PureSpecLoc); void ParseCXXNonStaticMemberInitializer(Decl *VarD); void ParseLexedAttributes(ParsingClass &Class); void ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D, @@ -1331,6 +1331,7 @@ public: ExprResult ParseExpression(TypeCastState isTypeCast = NotTypeCast); ExprResult ParseConstantExpression(TypeCastState isTypeCast = NotTypeCast); + ExprResult ParseConstraintExpression(); // Expr that doesn't include commas. ExprResult ParseAssignmentExpression(TypeCastState isTypeCast = NotTypeCast); @@ -1704,6 +1705,7 @@ private: DSC_top_level, // top-level/namespace declaration context DSC_template_type_arg, // template type argument context DSC_objc_method_result, // ObjC method result context, enables 'instancetype' + DSC_condition // condition declaration context }; /// Is this a context in which we are parsing just a type-specifier (or @@ -1714,6 +1716,7 @@ private: case DSC_class: case DSC_top_level: case DSC_objc_method_result: + case DSC_condition: return false; case DSC_template_type_arg: diff --git a/include/clang/Sema/DeclSpec.h b/include/clang/Sema/DeclSpec.h index 2ec3286ad799..d375ec303785 100644 --- a/include/clang/Sema/DeclSpec.h +++ b/include/clang/Sema/DeclSpec.h @@ -358,6 +358,9 @@ private: // constexpr-specifier unsigned Constexpr_specified : 1; + // concept-specifier + unsigned Concept_specified : 1; + union { UnionParsedType TypeRep; Decl *DeclRep; @@ -393,7 +396,7 @@ private: SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc; SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc; SourceLocation FS_forceinlineLoc; - SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc; + SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc, ConceptLoc; WrittenBuiltinSpecs writtenBS; void SaveWrittenBuiltinSpecs(); @@ -437,6 +440,7 @@ public: FS_noreturn_specified(false), Friend_specified(false), Constexpr_specified(false), + Concept_specified(false), Attrs(attrFactory), ProtocolQualifiers(nullptr), NumProtocolQualifiers(0), @@ -688,6 +692,8 @@ public: unsigned &DiagID); bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID); + bool SetConceptSpec(SourceLocation Loc, const char *&PrevSpec, + unsigned &DiagID); bool isFriendSpecified() const { return Friend_specified; } SourceLocation getFriendSpecLoc() const { return FriendLoc; } @@ -698,11 +704,19 @@ public: bool isConstexprSpecified() const { return Constexpr_specified; } SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; } + bool isConceptSpecified() const { return Concept_specified; } + SourceLocation getConceptSpecLoc() const { return ConceptLoc; } + void ClearConstexprSpec() { Constexpr_specified = false; ConstexprLoc = SourceLocation(); } + void ClearConceptSpec() { + Concept_specified = false; + ConceptLoc = SourceLocation(); + } + AttributePool &getAttributePool() const { return Attrs.getPool(); } diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h index cb75b969f116..72a0e0b19e3d 100644 --- a/include/clang/Sema/Sema.h +++ b/include/clang/Sema/Sema.h @@ -277,7 +277,9 @@ class Sema { // it will keep having external linkage. If it has internal linkage, we // will not link it. Since it has no previous decls, it will remain // with internal linkage. - return isVisible(Old) || New->isExternallyVisible(); + if (getLangOpts().ModulesHideInternalLinkage) + return isVisible(Old) || New->isExternallyVisible(); + return true; } public: @@ -700,9 +702,15 @@ public: /// \brief The declaration of the Objective-C NSNumber class. ObjCInterfaceDecl *NSNumberDecl; + /// \brief The declaration of the Objective-C NSValue class. + ObjCInterfaceDecl *NSValueDecl; + /// \brief Pointer to NSNumber type (NSNumber *). QualType NSNumberPointer; + /// \brief Pointer to NSValue type (NSValue *). + QualType NSValuePointer; + /// \brief The Objective-C NSNumber methods used to create NSNumber literals. ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods]; @@ -715,6 +723,9 @@ public: /// \brief The declaration of the stringWithUTF8String: method. ObjCMethodDecl *StringWithUTF8StringMethod; + /// \brief The declaration of the valueWithBytes:objCType: method. + ObjCMethodDecl *ValueWithBytesObjCTypeMethod; + /// \brief The declaration of the Objective-C NSArray class. ObjCInterfaceDecl *NSArrayDecl; @@ -1679,6 +1690,7 @@ public: bool TypeMayContainAuto); void ActOnUninitializedDecl(Decl *dcl, bool TypeMayContainAuto); void ActOnInitializerError(Decl *Dcl); + void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc); void ActOnCXXForRangeDecl(Decl *D); StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, IdentifierInfo *Ident, @@ -2976,7 +2988,7 @@ public: bool SynthesizeProperties); /// Diagnose any null-resettable synthesized setters. - void diagnoseNullResettableSynthesizedSetters(ObjCImplDecl *impDecl); + void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl); /// DefaultSynthesizeProperties - This routine default synthesizes all /// properties which must be synthesized in the class's \@implementation. @@ -5025,9 +5037,9 @@ public: /// BuildObjCBoxedExpr - builds an ObjCBoxedExpr AST node for the /// '@' prefixed parenthesized expression. The type of the expression will - /// either be "NSNumber *" or "NSString *" depending on the type of - /// ValueType, which is allowed to be a built-in numeric type or - /// "char *" or "const char *". + /// either be "NSNumber *", "NSString *" or "NSValue *" depending on the type + /// of ValueType, which is allowed to be a built-in numeric type, "char *", + /// "const char *" or C structure with attribute 'objc_boxable'. ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr); ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr, @@ -7603,6 +7615,12 @@ private: bool IsOpenMPCapturedVar(VarDecl *VD); public: + /// \brief Check if the specified variable is used in one of the private + /// clauses in OpenMP constructs. + /// \param Level Relative level of nested OpenMP construct for that the check + /// is performed. + bool isOpenMPPrivateVar(VarDecl *VD, unsigned Level); + ExprResult PerformOpenMPImplicitIntegerConversion(SourceLocation OpLoc, Expr *Op); /// \brief Called on start of new data sharing attribute block. @@ -7610,9 +7628,9 @@ public: const DeclarationNameInfo &DirName, Scope *CurScope, SourceLocation Loc); /// \brief Start analysis of clauses. - void StartOpenMPClauses(); + void StartOpenMPClause(OpenMPClauseKind K); /// \brief End analysis of clauses. - void EndOpenMPClauses(); + void EndOpenMPClause(); /// \brief Called on end of data sharing attribute block. void EndOpenMPDSABlock(Stmt *CurDirective); @@ -7646,12 +7664,10 @@ public: /// /// \returns Statement for finished OpenMP region. StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses); - StmtResult ActOnOpenMPExecutableDirective(OpenMPDirectiveKind Kind, - const DeclarationNameInfo &DirName, - ArrayRef<OMPClause *> Clauses, - Stmt *AStmt, - SourceLocation StartLoc, - SourceLocation EndLoc); + StmtResult ActOnOpenMPExecutableDirective( + OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, + OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses, + Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc); /// \brief Called on well-formed '\#pragma omp parallel' after parsing /// of the associated statement. StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses, @@ -7757,6 +7773,15 @@ public: StmtResult ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc); + /// \brief Called on well-formed '\#pragma omp cancellation point'. + StmtResult + ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc, + SourceLocation EndLoc, + OpenMPDirectiveKind CancelRegion); + /// \brief Called on well-formed '\#pragma omp cancel'. + StmtResult ActOnOpenMPCancelDirective(SourceLocation StartLoc, + SourceLocation EndLoc, + OpenMPDirectiveKind CancelRegion); OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr, @@ -7851,13 +7876,13 @@ public: OMPClause *ActOnOpenMPSeqCstClause(SourceLocation StartLoc, SourceLocation EndLoc); - OMPClause * - ActOnOpenMPVarListClause(OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, - Expr *TailExpr, SourceLocation StartLoc, - SourceLocation LParenLoc, SourceLocation ColonLoc, - SourceLocation EndLoc, - CXXScopeSpec &ReductionIdScopeSpec, - const DeclarationNameInfo &ReductionId); + OMPClause *ActOnOpenMPVarListClause( + OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, Expr *TailExpr, + SourceLocation StartLoc, SourceLocation LParenLoc, + SourceLocation ColonLoc, SourceLocation EndLoc, + CXXScopeSpec &ReductionIdScopeSpec, + const DeclarationNameInfo &ReductionId, OpenMPDependClauseKind DepKind, + SourceLocation DepLoc); /// \brief Called on well-formed 'private' clause. OMPClause *ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc, @@ -7914,6 +7939,12 @@ public: SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc); + /// \brief Called on well-formed 'depend' clause. + OMPClause * + ActOnOpenMPDependClause(OpenMPDependClauseKind DepKind, SourceLocation DepLoc, + SourceLocation ColonLoc, ArrayRef<Expr *> VarList, + SourceLocation StartLoc, SourceLocation LParenLoc, + SourceLocation EndLoc); /// \brief The kind of conversion being performed. enum CheckedConversionKind { @@ -8711,6 +8742,7 @@ private: bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall, int ArgNum, unsigned ExpectedFieldNum, bool AllowName); + bool SemaBuiltinCpuSupports(CallExpr *TheCall); public: enum FormatStringType { FST_Scanf, @@ -8840,9 +8872,9 @@ private: mutable IdentifierInfo *Ident___float128; /// Nullability type specifiers. - IdentifierInfo *Ident___nonnull = nullptr; - IdentifierInfo *Ident___nullable = nullptr; - IdentifierInfo *Ident___null_unspecified = nullptr; + IdentifierInfo *Ident__Nonnull = nullptr; + IdentifierInfo *Ident__Nullable = nullptr; + IdentifierInfo *Ident__Null_unspecified = nullptr; IdentifierInfo *Ident_NSError = nullptr; diff --git a/include/clang/Serialization/ASTBitCodes.h b/include/clang/Serialization/ASTBitCodes.h index 83185a870ab1..ee8e3f4c6712 100644 --- a/include/clang/Serialization/ASTBitCodes.h +++ b/include/clang/Serialization/ASTBitCodes.h @@ -1397,6 +1397,8 @@ namespace clang { STMT_OMP_TARGET_DIRECTIVE, STMT_OMP_TEAMS_DIRECTIVE, STMT_OMP_TASKGROUP_DIRECTIVE, + STMT_OMP_CANCELLATION_POINT_DIRECTIVE, + STMT_OMP_CANCEL_DIRECTIVE, // ARC EXPR_OBJC_BRIDGED_CAST, // ObjCBridgedCastExpr diff --git a/include/clang/Serialization/ASTReader.h b/include/clang/Serialization/ASTReader.h index 429f00f852bb..ef5b107a2fda 100644 --- a/include/clang/Serialization/ASTReader.h +++ b/include/clang/Serialization/ASTReader.h @@ -304,7 +304,6 @@ class ASTReader public ExternalHeaderFileInfoSource, public ExternalSemaSource, public IdentifierInfoLookup, - public ExternalIdentifierLookup, public ExternalSLocEntrySource { public: @@ -1846,6 +1845,11 @@ public: /// Note: overrides method in ExternalASTSource Module *getModule(unsigned ID) override; + /// \brief Return a descriptor for the corresponding module. + llvm::Optional<ASTSourceDescriptor> getSourceDescriptor(unsigned ID) override; + /// \brief Return a descriptor for the module. + ASTSourceDescriptor getSourceDescriptor(const Module &M) override; + /// \brief Retrieve a selector from the given module with its local ID /// number. Selector getLocalSelector(ModuleFile &M, unsigned LocalID); diff --git a/include/clang/Serialization/ASTWriter.h b/include/clang/Serialization/ASTWriter.h index decd07a00ed5..c966d3edeb9f 100644 --- a/include/clang/Serialization/ASTWriter.h +++ b/include/clang/Serialization/ASTWriter.h @@ -42,6 +42,7 @@ namespace llvm { namespace clang { class ASTContext; +class Attr; class NestedNameSpecifier; class CXXBaseSpecifier; class CXXCtorInitializer; @@ -60,6 +61,7 @@ class Module; class PreprocessedEntity; class PreprocessingRecord; class Preprocessor; +class RecordDecl; class Sema; class SourceManager; struct StoredDeclsList; @@ -302,6 +304,7 @@ private: unsigned Loc; unsigned Val; Module *Mod; + const Attr *Attribute; }; public: @@ -315,6 +318,8 @@ private: : Kind(Kind), Val(Val) {} DeclUpdate(unsigned Kind, Module *M) : Kind(Kind), Mod(M) {} + DeclUpdate(unsigned Kind, const Attr *Attribute) + : Kind(Kind), Attribute(Attribute) {} unsigned getKind() const { return Kind; } const Decl *getDecl() const { return Dcl; } @@ -324,6 +329,7 @@ private: } unsigned getNumber() const { return Val; } Module *getModule() const { return Mod; } + const Attr *getAttr() const { return Attribute; } }; typedef SmallVector<DeclUpdate, 1> UpdateRecord; @@ -860,6 +866,8 @@ public: void DeclarationMarkedUsed(const Decl *D) override; void DeclarationMarkedOpenMPThreadPrivate(const Decl *D) override; void RedefinedHiddenDefinition(const NamedDecl *D, Module *M) override; + void AddedAttributeToRecord(const Attr *Attr, + const RecordDecl *Record) override; }; /// \brief AST and semantic-analysis consumer that generates a diff --git a/include/clang/Serialization/Module.h b/include/clang/Serialization/Module.h index 5571d91a5411..c98ced41aae5 100644 --- a/include/clang/Serialization/Module.h +++ b/include/clang/Serialization/Module.h @@ -20,6 +20,7 @@ #include "clang/Serialization/ContinuousRangeMap.h" #include "llvm/ADT/SetVector.h" #include "llvm/Bitcode/BitstreamReader.h" +#include "llvm/Support/Endian.h" #include <memory> #include <string> @@ -206,7 +207,7 @@ public: llvm::BitstreamCursor InputFilesCursor; /// \brief Offsets for all of the input file entries in the AST file. - const uint64_t *InputFileOffsets; + const llvm::support::unaligned_uint64_t *InputFileOffsets; /// \brief The input files that have been loaded from this AST file. std::vector<InputFile> InputFilesLoaded; diff --git a/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h b/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h index 308ac8363bea..57c73fd6eca1 100644 --- a/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h +++ b/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h @@ -464,7 +464,7 @@ public: /// The reports are usually generated by the checkers. Further, they are /// folded based on the profile value, which is done to coalesce similar /// reports. - void emitReport(BugReport *R); + void emitReport(std::unique_ptr<BugReport> R); void EmitBasicReport(const Decl *DeclWithIssue, const CheckerBase *Checker, StringRef BugName, StringRef BugCategory, diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h b/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h index 68274f52a60c..a4ff133b4b93 100644 --- a/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h +++ b/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h @@ -232,9 +232,9 @@ public: } /// \brief Emit the diagnostics report. - void emitReport(BugReport *R) { + void emitReport(std::unique_ptr<BugReport> R) { Changed = true; - Eng.getBugReporter().emitReport(R); + Eng.getBugReporter().emitReport(std::move(R)); } /// \brief Get the declaration of the called function (path-sensitive). diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h b/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h index 6a42df20d1cb..e7ec1f497b2b 100644 --- a/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h +++ b/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h @@ -28,10 +28,9 @@ template <class T> bool containsStmt(const Stmt *S) { if (isa<T>(S)) return true; - for (Stmt::const_child_range I = S->children(); I; ++I) - if (const Stmt *child = *I) - if (containsStmt<T>(child)) - return true; + for (const Stmt *Child : S->children()) + if (Child && containsStmt<T>(Child)) + return true; return false; } diff --git a/lib/ARCMigrate/ObjCMT.cpp b/lib/ARCMigrate/ObjCMT.cpp index 8c2e0f4de808..b61a421ce415 100644 --- a/lib/ARCMigrate/ObjCMT.cpp +++ b/lib/ARCMigrate/ObjCMT.cpp @@ -355,8 +355,8 @@ public: bool TraverseObjCMessageExpr(ObjCMessageExpr *E) { // Do depth first; we want to rewrite the subexpressions first so that if // we have to move expressions we will move them already rewritten. - for (Stmt::child_range range = E->children(); range; ++range) - if (!TraverseStmt(*range)) + for (Stmt *SubStmt : E->children()) + if (!TraverseStmt(SubStmt)) return false; return WalkUpFromObjCMessageExpr(E); diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp index 049eebd82b66..5a91f074c4e1 100644 --- a/lib/AST/ASTContext.cpp +++ b/lib/AST/ASTContext.cpp @@ -1786,6 +1786,17 @@ TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const { return TypeInfo(Width, Align, AlignIsRequired); } +unsigned ASTContext::getOpenMPDefaultSimdAlign(QualType T) const { + unsigned SimdAlign = getTargetInfo().getSimdDefaultAlign(); + // Target ppc64 with QPX: simd default alignment for pointer to double is 32. + if ((getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64 || + getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64le) && + getTargetInfo().getABI() == "elfv1-qpx" && + T->isSpecificBuiltinType(BuiltinType::Double)) + SimdAlign = 256; + return SimdAlign; +} + /// toCharUnitsFromBits - Convert a size in bits to a size in characters. CharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const { return CharUnits::fromQuantity(BitSize / getCharWidth()); @@ -1866,6 +1877,16 @@ CharUnits ASTContext::getAlignOfGlobalVarInChars(QualType T) const { return toCharUnitsFromBits(getAlignOfGlobalVar(T)); } +CharUnits ASTContext::getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const { + CharUnits Offset = CharUnits::Zero(); + const ASTRecordLayout *Layout = &getASTRecordLayout(RD); + while (const CXXRecordDecl *Base = Layout->getBaseSharingVBPtr()) { + Offset += Layout->getBaseClassOffset(Base); + Layout = &getASTRecordLayout(Base); + } + return Offset; +} + /// DeepCollectObjCIvars - /// This routine first collects all declared, but not synthesized, ivars in /// super class and then collects all ivars, including those synthesized for diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp index 60cbb0601138..90da4167197a 100644 --- a/lib/AST/ASTDumper.cpp +++ b/lib/AST/ASTDumper.cpp @@ -981,6 +981,10 @@ void ASTDumper::dumpDecl(const Decl *D) { OS << " in " << M->getFullModuleName(); else if (Module *M = D->getLocalOwningModule()) OS << " in (local) " << M->getFullModuleName(); + if (auto *ND = dyn_cast<NamedDecl>(D)) + for (Module *M : D->getASTContext().getModulesWithMergedDefinition( + const_cast<NamedDecl *>(ND))) + dumpChild([=] { OS << "also in " << M->getFullModuleName(); }); if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) if (ND->isHidden()) OS << " hidden"; @@ -1595,8 +1599,8 @@ void ASTDumper::dumpStmt(const Stmt *S) { ConstStmtVisitor<ASTDumper>::Visit(S); - for (Stmt::const_child_range CI = S->children(); CI; ++CI) - dumpStmt(*CI); + for (const Stmt *SubStmt : S->children()) + dumpStmt(SubStmt); }); } @@ -1825,6 +1829,9 @@ void ASTDumper::VisitUnaryExprOrTypeTraitExpr( case UETT_VecStep: OS << " vec_step"; break; + case UETT_OpenMPRequiredSimdAlign: + OS << " __builtin_omp_required_simd_align"; + break; } if (Node->isArgumentType()) dumpType(Node->getArgumentType()); diff --git a/lib/AST/DeclBase.cpp b/lib/AST/DeclBase.cpp index 70bd16ffdd5d..d20451d1badc 100644 --- a/lib/AST/DeclBase.cpp +++ b/lib/AST/DeclBase.cpp @@ -236,6 +236,7 @@ void Decl::setLexicalDeclContext(DeclContext *DC) { } else { getMultipleDC()->LexicalDC = DC; } + Hidden = cast<Decl>(DC)->Hidden; } void Decl::setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC, diff --git a/lib/AST/DeclPrinter.cpp b/lib/AST/DeclPrinter.cpp index c3ce47600972..d33093b8b5e1 100644 --- a/lib/AST/DeclPrinter.cpp +++ b/lib/AST/DeclPrinter.cpp @@ -954,9 +954,8 @@ void DeclPrinter::PrintObjCMethodType(ASTContext &Ctx, 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) << ' '; - } + if (auto nullability = AttributedType::stripOuterNullability(T)) + Out << getNullabilitySpelling(*nullability, true) << ' '; } Out << Ctx.getUnqualifiedObjCPointerType(T).getAsString(Policy); @@ -1207,7 +1206,7 @@ void DeclPrinter::VisitObjCPropertyDecl(ObjCPropertyDecl *PDecl) { Out << (first ? ' ' : ',') << "null_resettable"; } else { Out << (first ? ' ' : ',') - << getNullabilitySpelling(*nullability).substr(2); + << getNullabilitySpelling(*nullability, true); } first = false; } diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp index 36f4139f8352..87f9ffba78e3 100644 --- a/lib/AST/Expr.cpp +++ b/lib/AST/Expr.cpp @@ -3154,10 +3154,10 @@ bool Expr::HasSideEffects(const ASTContext &Ctx, } // Recurse to children. - for (const_child_range SubStmts = children(); SubStmts; ++SubStmts) - if (const Stmt *S = *SubStmts) - if (cast<Expr>(S)->HasSideEffects(Ctx, IncludePossibleEffects)) - return true; + for (const Stmt *SubStmt : children()) + if (SubStmt && + cast<Expr>(SubStmt)->HasSideEffects(Ctx, IncludePossibleEffects)) + return true; return false; } diff --git a/lib/AST/ExprConstant.cpp b/lib/AST/ExprConstant.cpp index 8e472f174140..ed749cc56f1e 100644 --- a/lib/AST/ExprConstant.cpp +++ b/lib/AST/ExprConstant.cpp @@ -7251,6 +7251,13 @@ bool IntExprEvaluator::VisitUnaryExprOrTypeTraitExpr( return false; return Success(Sizeof, E); } + case UETT_OpenMPRequiredSimdAlign: + assert(E->isArgumentType()); + return Success( + Info.Ctx.toCharUnitsFromBits( + Info.Ctx.getOpenMPDefaultSimdAlign(E->getArgumentType())) + .getQuantity(), + E); } llvm_unreachable("unknown expr/type trait"); diff --git a/lib/AST/ExternalASTSource.cpp b/lib/AST/ExternalASTSource.cpp index 730842a28f6a..1c82c355134e 100644 --- a/lib/AST/ExternalASTSource.cpp +++ b/lib/AST/ExternalASTSource.cpp @@ -22,6 +22,16 @@ using namespace clang; ExternalASTSource::~ExternalASTSource() { } +llvm::Optional<ExternalASTSource::ASTSourceDescriptor> +ExternalASTSource::getSourceDescriptor(unsigned ID) { + return None; +} + +ExternalASTSource::ASTSourceDescriptor +ExternalASTSource::getSourceDescriptor(const Module &M) { + return ASTSourceDescriptor(); +} + void ExternalASTSource::FindFileRegionDecls(FileID File, unsigned Offset, unsigned Length, SmallVectorImpl<Decl *> &Decls) {} diff --git a/lib/AST/ItaniumMangle.cpp b/lib/AST/ItaniumMangle.cpp index e5a31f879b76..0134c090d67e 100644 --- a/lib/AST/ItaniumMangle.cpp +++ b/lib/AST/ItaniumMangle.cpp @@ -3018,13 +3018,21 @@ recurse: case UETT_AlignOf: Out << 'a'; break; - case UETT_VecStep: + case UETT_VecStep: { DiagnosticsEngine &Diags = Context.getDiags(); unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, "cannot yet mangle vec_step expression"); Diags.Report(DiagID); return; } + case UETT_OpenMPRequiredSimdAlign: + DiagnosticsEngine &Diags = Context.getDiags(); + unsigned DiagID = Diags.getCustomDiagID( + DiagnosticsEngine::Error, + "cannot yet mangle __builtin_omp_required_simd_align expression"); + Diags.Report(DiagID); + return; + } if (SAE->isArgumentType()) { Out << 't'; mangleType(SAE->getArgumentType()); diff --git a/lib/AST/MicrosoftMangle.cpp b/lib/AST/MicrosoftMangle.cpp index 29a95a5103ce..48a8fa541a69 100644 --- a/lib/AST/MicrosoftMangle.cpp +++ b/lib/AST/MicrosoftMangle.cpp @@ -115,6 +115,9 @@ public: void mangleCXXVBTable(const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath, raw_ostream &Out) override; + void mangleCXXVirtualDisplacementMap(const CXXRecordDecl *SrcRD, + const CXXRecordDecl *DstRD, + raw_ostream &Out) override; void mangleCXXThrowInfo(QualType T, bool IsConst, bool IsVolatile, uint32_t NumEntries, raw_ostream &Out) override; void mangleCXXCatchableTypeArray(QualType T, uint32_t NumEntries, @@ -499,6 +502,9 @@ void MicrosoftCXXNameMangler::mangleMemberDataPointer(const CXXRecordDecl *RD, FieldOffset /= getASTContext().getCharWidth(); VBTableOffset = 0; + + if (IM == MSInheritanceAttr::Keyword_virtual_inheritance) + FieldOffset -= getASTContext().getOffsetOfBaseWithVBPtr(RD).getQuantity(); } else { FieldOffset = RD->nullFieldOffsetIsZero() ? 0 : -1; @@ -567,6 +573,10 @@ MicrosoftCXXNameMangler::mangleMemberFunctionPointer(const CXXRecordDecl *RD, mangleName(MD); mangleFunctionEncoding(MD, /*ShouldMangle=*/true); } + + if (VBTableOffset == 0 && + IM == MSInheritanceAttr::Keyword_virtual_inheritance) + NVOffset -= getASTContext().getOffsetOfBaseWithVBPtr(RD).getQuantity(); } else { // Null single inheritance member functions are encoded as a simple nullptr. if (IM == MSInheritanceAttr::Keyword_single_inheritance) { @@ -579,7 +589,7 @@ MicrosoftCXXNameMangler::mangleMemberFunctionPointer(const CXXRecordDecl *RD, } if (MSInheritanceAttr::hasNVOffsetField(/*IsMemberFunction=*/true, IM)) - mangleNumber(NVOffset); + mangleNumber(static_cast<uint32_t>(NVOffset)); if (MSInheritanceAttr::hasVBPtrOffsetField(IM)) mangleNumber(VBPtrOffset); if (MSInheritanceAttr::hasVBTableOffsetField(IM)) @@ -1205,11 +1215,23 @@ void MicrosoftCXXNameMangler::mangleTemplateArg(const TemplateDecl *TD, return; } if (MPT->isMemberDataPointer()) { - mangleMemberDataPointer(RD, nullptr); - return; + if (isa<ClassTemplateDecl>(TD)) { + mangleMemberDataPointer(RD, nullptr); + return; + } + // nullptr data pointers are always represented with a single field + // which is initialized with either 0 or -1. Why -1? Well, we need to + // distinguish the case where the data member is at offset zero in the + // record. + // However, we are free to use 0 *if* we would use multiple fields for + // non-nullptr member pointers. + if (!RD->nullFieldOffsetIsZero()) { + mangleIntegerLiteral(llvm::APSInt::get(-1), /*IsBoolean=*/false); + return; + } } } - Out << "$0A@"; + mangleIntegerLiteral(llvm::APSInt::getUnsigned(0), /*IsBoolean=*/false); break; } case TemplateArgument::Expression: @@ -2395,6 +2417,15 @@ void MicrosoftMangleContextImpl::mangleCXXCatchHandlerType(QualType T, Mangler.getStream() << '.' << Flags; } +void MicrosoftMangleContextImpl::mangleCXXVirtualDisplacementMap( + const CXXRecordDecl *SrcRD, const CXXRecordDecl *DstRD, raw_ostream &Out) { + MicrosoftCXXNameMangler Mangler(*this, Out); + Mangler.getStream() << "\01??_K"; + Mangler.mangleName(SrcRD); + Mangler.getStream() << "$C"; + Mangler.mangleName(DstRD); +} + void MicrosoftMangleContextImpl::mangleCXXThrowInfo(QualType T, bool IsConst, bool IsVolatile, diff --git a/lib/AST/NSAPI.cpp b/lib/AST/NSAPI.cpp index 2749100e14a2..a9b10ed451c0 100644 --- a/lib/AST/NSAPI.cpp +++ b/lib/AST/NSAPI.cpp @@ -30,7 +30,8 @@ IdentifierInfo *NSAPI::getNSClassId(NSClassIdKindKind K) const { "NSNumber", "NSMutableSet", "NSCountedSet", - "NSMutableOrderedSet" + "NSMutableOrderedSet", + "NSValue" }; if (!ClassIds[K]) diff --git a/lib/AST/ParentMap.cpp b/lib/AST/ParentMap.cpp index a991302a2540..d7d5f9c69205 100644 --- a/lib/AST/ParentMap.cpp +++ b/lib/AST/ParentMap.cpp @@ -36,8 +36,8 @@ static void BuildParentMap(MapTy& M, Stmt* S, // If we are rebuilding the map, clear out any existing state. if (M[POE->getSyntacticForm()]) - for (Stmt::child_range I = S->children(); I; ++I) - M[*I] = nullptr; + for (Stmt *SubStmt : S->children()) + M[SubStmt] = nullptr; M[POE->getSyntacticForm()] = S; BuildParentMap(M, POE->getSyntacticForm(), OV_Transparent); @@ -82,10 +82,10 @@ static void BuildParentMap(MapTy& M, Stmt* S, break; } default: - for (Stmt::child_range I = S->children(); I; ++I) { - if (*I) { - M[*I] = S; - BuildParentMap(M, *I, OVMode); + for (Stmt *SubStmt : S->children()) { + if (SubStmt) { + M[SubStmt] = S; + BuildParentMap(M, SubStmt, OVMode); } } break; diff --git a/lib/AST/Stmt.cpp b/lib/AST/Stmt.cpp index 6f4a89fee39c..c0aab4c4db7d 100644 --- a/lib/AST/Stmt.cpp +++ b/lib/AST/Stmt.cpp @@ -1579,6 +1579,30 @@ OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) { return new (Mem) OMPFlushClause(N); } +OMPDependClause * +OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc, + SourceLocation LParenLoc, SourceLocation EndLoc, + OpenMPDependClauseKind DepKind, SourceLocation DepLoc, + SourceLocation ColonLoc, ArrayRef<Expr *> VL) { + void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPDependClause), + llvm::alignOf<Expr *>()) + + sizeof(Expr *) * VL.size()); + OMPDependClause *Clause = + new (Mem) OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size()); + Clause->setVarRefs(VL); + Clause->setDependencyKind(DepKind); + Clause->setDependencyLoc(DepLoc); + Clause->setColonLoc(ColonLoc); + return Clause; +} + +OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N) { + void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPDependClause), + llvm::alignOf<Expr *>()) + + sizeof(Expr *) * N); + return new (Mem) OMPDependClause(N); +} + const OMPClause * OMPExecutableDirective::getSingleClause(OpenMPClauseKind K) const { auto &&I = getClausesOfKind(K); @@ -2062,6 +2086,46 @@ OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C, return new (Mem) OMPTaskgroupDirective(); } +OMPCancellationPointDirective *OMPCancellationPointDirective::Create( + const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, + OpenMPDirectiveKind CancelRegion) { + unsigned Size = llvm::RoundUpToAlignment( + sizeof(OMPCancellationPointDirective), llvm::alignOf<Stmt *>()); + void *Mem = C.Allocate(Size); + OMPCancellationPointDirective *Dir = + new (Mem) OMPCancellationPointDirective(StartLoc, EndLoc); + Dir->setCancelRegion(CancelRegion); + return Dir; +} + +OMPCancellationPointDirective * +OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) { + unsigned Size = llvm::RoundUpToAlignment( + sizeof(OMPCancellationPointDirective), llvm::alignOf<Stmt *>()); + void *Mem = C.Allocate(Size); + return new (Mem) OMPCancellationPointDirective(); +} + +OMPCancelDirective * +OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc, + SourceLocation EndLoc, + OpenMPDirectiveKind CancelRegion) { + unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCancelDirective), + llvm::alignOf<Stmt *>()); + void *Mem = C.Allocate(Size); + OMPCancelDirective *Dir = new (Mem) OMPCancelDirective(StartLoc, EndLoc); + Dir->setCancelRegion(CancelRegion); + return Dir; +} + +OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C, + EmptyShell) { + unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCancelDirective), + llvm::alignOf<Stmt *>()); + void *Mem = C.Allocate(Size); + return new (Mem) OMPCancelDirective(); +} + OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, diff --git a/lib/AST/StmtIterator.cpp b/lib/AST/StmtIterator.cpp index 1ccba04d9f5b..732756fbec9a 100644 --- a/lib/AST/StmtIterator.cpp +++ b/lib/AST/StmtIterator.cpp @@ -93,12 +93,12 @@ bool StmtIteratorBase::HandleDecl(Decl* D) { } StmtIteratorBase::StmtIteratorBase(Decl** dgi, Decl** dge) - : stmt(nullptr), DGI(dgi), RawVAPtr(DeclGroupMode), DGE(dge) { + : DGI(dgi), RawVAPtr(DeclGroupMode), DGE(dge) { NextDecl(false); } StmtIteratorBase::StmtIteratorBase(const VariableArrayType* t) - : stmt(nullptr), DGI(nullptr), RawVAPtr(SizeOfTypeVAMode) { + : DGI(nullptr), RawVAPtr(SizeOfTypeVAMode) { RawVAPtr |= reinterpret_cast<uintptr_t>(t); } diff --git a/lib/AST/StmtPrinter.cpp b/lib/AST/StmtPrinter.cpp index 658e3dfdeed4..79600773f567 100644 --- a/lib/AST/StmtPrinter.cpp +++ b/lib/AST/StmtPrinter.cpp @@ -799,6 +799,17 @@ void OMPClausePrinter::VisitOMPFlushClause(OMPFlushClause *Node) { OS << ")"; } } + +void OMPClausePrinter::VisitOMPDependClause(OMPDependClause *Node) { + if (!Node->varlist_empty()) { + OS << "depend("; + OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(), + Node->getDependencyKind()) + << " :"; + VisitOMPClauseList(Node, ' '); + OS << ")"; + } +} } //===----------------------------------------------------------------------===// @@ -940,6 +951,18 @@ void StmtPrinter::VisitOMPTeamsDirective(OMPTeamsDirective *Node) { PrintOMPExecutableDirective(Node); } +void StmtPrinter::VisitOMPCancellationPointDirective( + OMPCancellationPointDirective *Node) { + Indent() << "#pragma omp cancellation point " + << getOpenMPDirectiveName(Node->getCancelRegion()); + PrintOMPExecutableDirective(Node); +} + +void StmtPrinter::VisitOMPCancelDirective(OMPCancelDirective *Node) { + Indent() << "#pragma omp cancel " + << getOpenMPDirectiveName(Node->getCancelRegion()); + PrintOMPExecutableDirective(Node); +} //===----------------------------------------------------------------------===// // Expr printing methods. //===----------------------------------------------------------------------===// @@ -1206,6 +1229,9 @@ void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node){ case UETT_VecStep: OS << "vec_step"; break; + case UETT_OpenMPRequiredSimdAlign: + OS << "__builtin_omp_required_simd_align"; + break; } if (Node->isArgumentType()) { OS << '('; diff --git a/lib/AST/StmtProfile.cpp b/lib/AST/StmtProfile.cpp index 23f8d0c8be7a..da996920c420 100644 --- a/lib/AST/StmtProfile.cpp +++ b/lib/AST/StmtProfile.cpp @@ -69,9 +69,9 @@ namespace { void StmtProfiler::VisitStmt(const Stmt *S) { ID.AddInteger(S->getStmtClass()); - for (Stmt::const_child_range C = S->children(); C; ++C) { - if (*C) - Visit(*C); + for (const Stmt *SubStmt : S->children()) { + if (SubStmt) + Visit(SubStmt); else ID.AddInteger(0); } @@ -425,6 +425,9 @@ OMPClauseProfiler::VisitOMPCopyprivateClause(const OMPCopyprivateClause *C) { void OMPClauseProfiler::VisitOMPFlushClause(const OMPFlushClause *C) { VisitOMPClauseList(C); } +void OMPClauseProfiler::VisitOMPDependClause(const OMPDependClause *C) { + VisitOMPClauseList(C); +} } void @@ -534,6 +537,15 @@ void StmtProfiler::VisitOMPTeamsDirective(const OMPTeamsDirective *S) { VisitOMPExecutableDirective(S); } +void StmtProfiler::VisitOMPCancellationPointDirective( + const OMPCancellationPointDirective *S) { + VisitOMPExecutableDirective(S); +} + +void StmtProfiler::VisitOMPCancelDirective(const OMPCancelDirective *S) { + VisitOMPExecutableDirective(S); +} + void StmtProfiler::VisitExpr(const Expr *S) { VisitStmt(S); } diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp index 3ac117194099..541bd1ebdf88 100644 --- a/lib/AST/Type.cpp +++ b/lib/AST/Type.cpp @@ -364,6 +364,11 @@ bool Type::isStructureType() const { return RT->getDecl()->isStruct(); return false; } +bool Type::isObjCBoxableRecordType() const { + if (const RecordType *RT = getAs<RecordType>()) + return RT->getDecl()->hasAttr<ObjCBoxableAttr>(); + return false; +} bool Type::isInterfaceType() const { if (const RecordType *RT = getAs<RecordType>()) return RT->getDecl()->isInterface(); diff --git a/lib/AST/TypePrinter.cpp b/lib/AST/TypePrinter.cpp index ebe09d85495e..9938170c321a 100644 --- a/lib/AST/TypePrinter.cpp +++ b/lib/AST/TypePrinter.cpp @@ -1147,11 +1147,11 @@ void TypePrinter::printAttributedBefore(const AttributedType *T, T->getAttrKind() == AttributedType::attr_nullable || T->getAttrKind() == AttributedType::attr_null_unspecified) { if (T->getAttrKind() == AttributedType::attr_nonnull) - OS << " __nonnull"; + OS << " _Nonnull"; else if (T->getAttrKind() == AttributedType::attr_nullable) - OS << " __nullable"; + OS << " _Nullable"; else if (T->getAttrKind() == AttributedType::attr_null_unspecified) - OS << " __null_unspecified"; + OS << " _Null_unspecified"; else llvm_unreachable("unhandled nullability"); spaceBeforePlaceHolder(OS); @@ -1186,11 +1186,11 @@ void TypePrinter::printAttributedAfter(const AttributedType *T, T->getAttrKind() == AttributedType::attr_nullable || T->getAttrKind() == AttributedType::attr_null_unspecified) { if (T->getAttrKind() == AttributedType::attr_nonnull) - OS << " __nonnull"; + OS << " _Nonnull"; else if (T->getAttrKind() == AttributedType::attr_nullable) - OS << " __nullable"; + OS << " _Nullable"; else if (T->getAttrKind() == AttributedType::attr_null_unspecified) - OS << " __null_unspecified"; + OS << " _Null_unspecified"; else llvm_unreachable("unhandled nullability"); diff --git a/lib/ASTMatchers/ASTMatchersInternal.cpp b/lib/ASTMatchers/ASTMatchersInternal.cpp index 2c482e38dc08..b6ef8226a9a9 100644 --- a/lib/ASTMatchers/ASTMatchersInternal.cpp +++ b/lib/ASTMatchers/ASTMatchersInternal.cpp @@ -114,9 +114,9 @@ DynTypedMatcher DynTypedMatcher::constructVariadic( assert(InnerMatchers.size() > 0 && "Array must not be empty."); assert(std::all_of(InnerMatchers.begin(), InnerMatchers.end(), [&InnerMatchers](const DynTypedMatcher &M) { - return InnerMatchers[0].SupportedKind.isSame(M.SupportedKind); + return InnerMatchers[0].canConvertTo(M.SupportedKind); }) && - "SupportedKind must match!"); + "SupportedKind must be convertible to a common type!"); auto SupportedKind = InnerMatchers[0].SupportedKind; // We must relax the restrict kind here. diff --git a/lib/ASTMatchers/Dynamic/Registry.cpp b/lib/ASTMatchers/Dynamic/Registry.cpp index 59c204d370a6..72713dda03c7 100644 --- a/lib/ASTMatchers/Dynamic/Registry.cpp +++ b/lib/ASTMatchers/Dynamic/Registry.cpp @@ -240,6 +240,7 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(innerType); REGISTER_MATCHER(integerLiteral); REGISTER_MATCHER(isArrow); + REGISTER_MATCHER(isCatchAll); REGISTER_MATCHER(isConst); REGISTER_MATCHER(isConstQualified); REGISTER_MATCHER(isDefinition); diff --git a/lib/Analysis/AnalysisDeclContext.cpp b/lib/Analysis/AnalysisDeclContext.cpp index 4e623c8d6c39..d7fb7e95d758 100644 --- a/lib/Analysis/AnalysisDeclContext.cpp +++ b/lib/Analysis/AnalysisDeclContext.cpp @@ -472,9 +472,9 @@ public: : BEVals(bevals), BC(bc) {} void VisitStmt(Stmt *S) { - for (Stmt::child_range I = S->children(); I; ++I) - if (Stmt *child = *I) - Visit(child); + for (Stmt *Child : S->children()) + if (Child) + Visit(Child); } void VisitDeclRefExpr(DeclRefExpr *DR) { diff --git a/lib/Analysis/CFG.cpp b/lib/Analysis/CFG.cpp index 19b3f5a47654..54d15bd232a1 100644 --- a/lib/Analysis/CFG.cpp +++ b/lib/Analysis/CFG.cpp @@ -270,9 +270,8 @@ reverse_children::reverse_children(Stmt *S) { } // Default case for all other statements. - for (Stmt::child_range I = S->children(); I; ++I) { - childrenBuf.push_back(*I); - } + for (Stmt *SubStmt : S->children()) + childrenBuf.push_back(SubStmt); // This needs to be done *after* childrenBuf has been populated. children = childrenBuf; @@ -3641,11 +3640,11 @@ CFGBlock *CFGBuilder::VisitChildrenForTemporaryDtors(Stmt *E, // bottom-up, this means we visit them in their natural order, which // reverses them in the CFG. CFGBlock *B = Block; - for (Stmt::child_range I = E->children(); I; ++I) { - if (Stmt *Child = *I) + for (Stmt *Child : E->children()) + if (Child) if (CFGBlock *R = VisitForTemporaryDtors(Child, false, Context)) B = R; - } + return B; } diff --git a/lib/Analysis/CallGraph.cpp b/lib/Analysis/CallGraph.cpp index 91a8492eaa54..d06603469dd0 100644 --- a/lib/Analysis/CallGraph.cpp +++ b/lib/Analysis/CallGraph.cpp @@ -83,9 +83,9 @@ public: } void VisitChildren(Stmt *S) { - for (Stmt::child_range I = S->children(); I; ++I) - if (*I) - static_cast<CGBuilder*>(this)->Visit(*I); + for (Stmt *SubStmt : S->children()) + if (SubStmt) + this->Visit(SubStmt); } }; diff --git a/lib/Analysis/LiveVariables.cpp b/lib/Analysis/LiveVariables.cpp index 0ab158036d84..5e0a9a0d73c8 100644 --- a/lib/Analysis/LiveVariables.cpp +++ b/lib/Analysis/LiveVariables.cpp @@ -322,11 +322,10 @@ void TransferFunctions::Visit(Stmt *S) { return; } } - - for (Stmt::child_iterator it = S->child_begin(), ei = S->child_end(); - it != ei; ++it) { - if (Stmt *child = *it) - AddLiveStmt(val.liveStmts, LV.SSetFact, child); + + for (Stmt *Child : S->children()) { + if (Child) + AddLiveStmt(val.liveStmts, LV.SSetFact, Child); } } diff --git a/lib/Analysis/PrintfFormatString.cpp b/lib/Analysis/PrintfFormatString.cpp index b8d3ec18016a..f0976bce9720 100644 --- a/lib/Analysis/PrintfFormatString.cpp +++ b/lib/Analysis/PrintfFormatString.cpp @@ -49,6 +49,24 @@ static bool ParsePrecision(FormatStringHandler &H, PrintfSpecifier &FS, return false; } +static bool ParseObjCFlags(FormatStringHandler &H, PrintfSpecifier &FS, + const char *FlagBeg, const char *E, bool Warn) { + StringRef Flag(FlagBeg, E - FlagBeg); + // Currently there is only one flag. + if (Flag == "tt") { + FS.setHasObjCTechnicalTerm(FlagBeg); + return false; + } + // Handle either the case of no flag or an invalid flag. + if (Warn) { + if (Flag == "") + H.HandleEmptyObjCModifierFlag(FlagBeg, E - FlagBeg); + else + H.HandleInvalidObjCModifierFlag(FlagBeg, E - FlagBeg); + } + return true; +} + static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H, const char *&Beg, const char *E, @@ -168,6 +186,38 @@ static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H, return true; } + // Look for the Objective-C modifier flags, if any. + // We parse these here, even if they don't apply to + // the conversion specifier, and then emit an error + // later if the conversion specifier isn't '@'. This + // enables better recovery, and we don't know if + // these flags are applicable until later. + const char *ObjCModifierFlagsStart = nullptr, + *ObjCModifierFlagsEnd = nullptr; + if (*I == '[') { + ObjCModifierFlagsStart = I; + ++I; + auto flagStart = I; + for (;; ++I) { + ObjCModifierFlagsEnd = I; + if (I == E) { + if (Warn) + H.HandleIncompleteSpecifier(Start, E - Start); + return true; + } + // Did we find the closing ']'? + if (*I == ']') { + if (ParseObjCFlags(H, FS, flagStart, I, Warn)) + return true; + ++I; + break; + } + // There are no separators defined yet for multiple + // Objective-C modifier flags. When those are + // defined, this is the place to check. + } + } + if (*I == '\0') { // Detect spurious null characters, which are likely errors. H.HandleNullChar(I); @@ -240,6 +290,18 @@ static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H, if (Target.getTriple().isOSMSVCRT()) k = ConversionSpecifier::ZArg; } + + // Check to see if we used the Objective-C modifier flags with + // a conversion specifier other than '@'. + if (k != ConversionSpecifier::ObjCObjArg && + k != ConversionSpecifier::InvalidSpecifier && + ObjCModifierFlagsStart) { + H.HandleObjCFlagsWithNonObjCConversion(ObjCModifierFlagsStart, + ObjCModifierFlagsEnd + 1, + conversionPosition); + return true; + } + PrintfConversionSpecifier CS(conversionPosition, k); FS.setConversionSpecifier(CS); if (CS.consumesDataArgument() && !FS.usesPositionalArg()) diff --git a/lib/Analysis/PseudoConstantAnalysis.cpp b/lib/Analysis/PseudoConstantAnalysis.cpp index 3f96ca877f19..5b917a7a27f5 100644 --- a/lib/Analysis/PseudoConstantAnalysis.cpp +++ b/lib/Analysis/PseudoConstantAnalysis.cpp @@ -220,8 +220,8 @@ void PseudoConstantAnalysis::RunAnalysis() { } // switch (head->getStmtClass()) // Add all substatements to the worklist - for (Stmt::const_child_range I = Head->children(); I; ++I) - if (*I) - WorkList.push_back(*I); + for (const Stmt *SubStmt : Head->children()) + if (SubStmt) + WorkList.push_back(SubStmt); } // while (!WorkList.empty()) } diff --git a/lib/Basic/Diagnostic.cpp b/lib/Basic/Diagnostic.cpp index 7f5a15dab6b2..f89caf7b248f 100644 --- a/lib/Basic/Diagnostic.cpp +++ b/lib/Basic/Diagnostic.cpp @@ -24,6 +24,27 @@ using namespace clang; +const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB, + DiagNullabilityKind nullability) { + StringRef string; + switch (nullability.first) { + case NullabilityKind::NonNull: + string = nullability.second ? "'nonnull'" : "'_Nonnull'"; + break; + + case NullabilityKind::Nullable: + string = nullability.second ? "'nullable'" : "'_Nullable'"; + break; + + case NullabilityKind::Unspecified: + string = nullability.second ? "'null_unspecified'" : "'_Null_unspecified'"; + break; + } + + DB.AddString(string); + return DB; +} + static void DummyArgToStringFn(DiagnosticsEngine::ArgumentKind AK, intptr_t QT, StringRef Modifier, StringRef Argument, ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs, diff --git a/lib/Basic/IdentifierTable.cpp b/lib/Basic/IdentifierTable.cpp index b29500810003..36fba994f1e7 100644 --- a/lib/Basic/IdentifierTable.cpp +++ b/lib/Basic/IdentifierTable.cpp @@ -71,8 +71,6 @@ IdentifierIterator *IdentifierInfoLookup::getIdentifiers() { return new EmptyLookupIterator(); } -ExternalIdentifierLookup::~ExternalIdentifierLookup() {} - IdentifierTable::IdentifierTable(const LangOptions &LangOpts, IdentifierInfoLookup* externalLookup) : HashTable(8192), // Start with space for 8K identifiers. @@ -647,16 +645,17 @@ const char *clang::getOperatorSpelling(OverloadedOperatorKind Operator) { llvm_unreachable("Invalid OverloadedOperatorKind!"); } -StringRef clang::getNullabilitySpelling(NullabilityKind kind) { +StringRef clang::getNullabilitySpelling(NullabilityKind kind, + bool isContextSensitive) { switch (kind) { case NullabilityKind::NonNull: - return "__nonnull"; + return isContextSensitive ? "nonnull" : "_Nonnull"; case NullabilityKind::Nullable: - return "__nullable"; + return isContextSensitive ? "nullable" : "_Nullable"; case NullabilityKind::Unspecified: - return "__null_unspecified"; + return isContextSensitive ? "null_unspecified" : "_Null_unspecified"; } llvm_unreachable("Unknown nullability kind."); } diff --git a/lib/Basic/Module.cpp b/lib/Basic/Module.cpp index 7308665bd2d8..1a48a6c6a8d1 100644 --- a/lib/Basic/Module.cpp +++ b/lib/Basic/Module.cpp @@ -27,7 +27,7 @@ using namespace clang; Module::Module(StringRef Name, SourceLocation DefinitionLoc, Module *Parent, bool IsFramework, bool IsExplicit, unsigned VisibilityID) : Name(Name), DefinitionLoc(DefinitionLoc), Parent(Parent), Directory(), - Umbrella(), ASTFile(nullptr), VisibilityID(VisibilityID), + Umbrella(), Signature(0), ASTFile(nullptr), VisibilityID(VisibilityID), IsMissingRequirement(false), IsAvailable(true), IsFromModuleFile(false), IsFramework(IsFramework), IsExplicit(IsExplicit), IsSystem(false), IsExternC(false), IsInferred(false), InferSubmodules(false), diff --git a/lib/Basic/OpenMPKinds.cpp b/lib/Basic/OpenMPKinds.cpp index b2798b7f0fd3..b7407f60e6d1 100644 --- a/lib/Basic/OpenMPKinds.cpp +++ b/lib/Basic/OpenMPKinds.cpp @@ -91,6 +91,11 @@ unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind, #define OPENMP_SCHEDULE_KIND(Name) .Case(#Name, OMPC_SCHEDULE_##Name) #include "clang/Basic/OpenMPKinds.def" .Default(OMPC_SCHEDULE_unknown); + case OMPC_depend: + return llvm::StringSwitch<OpenMPDependClauseKind>(Str) +#define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name) +#include "clang/Basic/OpenMPKinds.def" + .Default(OMPC_DEPEND_unknown); case OMPC_unknown: case OMPC_threadprivate: case OMPC_if: @@ -154,6 +159,15 @@ const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, return #Name; #include "clang/Basic/OpenMPKinds.def" } + case OMPC_depend: + switch (Type) { + case OMPC_DEPEND_unknown: + return "unknown"; +#define OPENMP_DEPEND_KIND(Name) \ + case OMPC_DEPEND_##Name: \ + return #Name; +#include "clang/Basic/OpenMPKinds.def" + } llvm_unreachable("Invalid OpenMP 'schedule' clause type"); case OMPC_unknown: case OMPC_threadprivate: @@ -333,6 +347,8 @@ bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, case OMPD_barrier: case OMPD_taskwait: case OMPD_taskgroup: + case OMPD_cancellation_point: + case OMPD_cancel: case OMPD_ordered: break; } diff --git a/lib/Basic/TargetInfo.cpp b/lib/Basic/TargetInfo.cpp index 330258b025b5..856ad50d3782 100644 --- a/lib/Basic/TargetInfo.cpp +++ b/lib/Basic/TargetInfo.cpp @@ -50,6 +50,7 @@ TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) { LargeArrayAlign = 0; MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 0; MaxVectorAlign = 0; + SimdDefaultAlign = 0; SizeType = UnsignedLong; PtrDiffType = SignedLong; IntMaxType = SignedLongLong; diff --git a/lib/Basic/Targets.cpp b/lib/Basic/Targets.cpp index 076b04bf342c..8f2bca051b67 100644 --- a/lib/Basic/Targets.cpp +++ b/lib/Basic/Targets.cpp @@ -759,6 +759,7 @@ public: HasP8Crypto(false), HasDirectMove(false), HasQPX(false), HasHTM(false), HasBPERMD(false), HasExtDiv(false) { BigEndian = (Triple.getArch() != llvm::Triple::ppc64le); + SimdDefaultAlign = 128; LongDoubleWidth = LongDoubleAlign = 128; LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble; } @@ -2215,6 +2216,7 @@ public: Names = AddlRegNames; NumNames = llvm::array_lengthof(AddlRegNames); } + bool validateCpuSupports(StringRef Name) const override; bool validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &info) const override; @@ -2249,7 +2251,9 @@ public: bool handleTargetFeatures(std::vector<std::string> &Features, DiagnosticsEngine &Diags) override; StringRef getABI() const override { - if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX) + if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX512F) + return "avx512"; + else if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX) return "avx"; else if (getTriple().getArch() == llvm::Triple::x86 && MMX3DNowLevel == NoMMX3DNow) @@ -2725,7 +2729,11 @@ void X86TargetInfo::setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level, void X86TargetInfo::setFeatureEnabledImpl(llvm::StringMap<bool> &Features, StringRef Name, bool Enabled) { - Features[Name] = Enabled; + // This is a bit of a hack to deal with the sse4 target feature when used + // as part of the target attribute. We handle sse4 correctly everywhere + // else. See below for more information on how we handle the sse4 options. + if (Name != "sse4") + Features[Name] = Enabled; if (Name == "mmx") { setMMXLevel(Features, MMX, Enabled); @@ -2776,6 +2784,15 @@ void X86TargetInfo::setFeatureEnabledImpl(llvm::StringMap<bool> &Features, } else if (Name == "sha") { if (Enabled) setSSELevel(Features, SSE2, Enabled); + } else if (Name == "sse4") { + // We can get here via the __target__ attribute since that's not controlled + // via the -msse4/-mno-sse4 command line alias. Handle this the same way + // here - turn on the sse4.2 if enabled, turn off the sse4.1 level if + // disabled. + if (Enabled) + setSSELevel(Features, SSE42, Enabled); + else + setSSELevel(Features, SSE41, Enabled); } } @@ -2972,6 +2989,9 @@ bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, Features.erase(it); else if (SSELevel > NoSSE) MMX3DNowLevel = std::max(MMX3DNowLevel, MMX); + + SimdDefaultAlign = + (getABI() == "avx512") ? 512 : (getABI() == "avx") ? 256 : 128; return true; } @@ -3336,6 +3356,33 @@ bool X86TargetInfo::hasFeature(StringRef Feature) const { .Default(false); } +// We can't use a generic validation scheme for the features accepted here +// versus subtarget features accepted in the target attribute because the +// bitfield structure that's initialized in the runtime only supports the +// below currently rather than the full range of subtarget features. (See +// X86TargetInfo::hasFeature for a somewhat comprehensive list). +bool X86TargetInfo::validateCpuSupports(StringRef FeatureStr) const { + return llvm::StringSwitch<bool>(FeatureStr) + .Case("cmov", true) + .Case("mmx", true) + .Case("popcnt", true) + .Case("sse", true) + .Case("sse2", true) + .Case("sse3", true) + .Case("sse4.1", true) + .Case("sse4.2", true) + .Case("avx", true) + .Case("avx2", true) + .Case("sse4a", true) + .Case("fma4", true) + .Case("xop", true) + .Case("fma", true) + .Case("avx512f", true) + .Case("bmi", true) + .Case("bmi2", true) + .Default(false); +} + bool X86TargetInfo::validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &Info) const { @@ -3949,8 +3996,14 @@ class ARMTargetInfo : public TargetInfo { FP_Neon } FPMath; + unsigned ArchISA; + unsigned ArchKind; + unsigned ArchProfile; + unsigned ArchVersion; + unsigned FPU : 5; + unsigned ShouldUseInlineAtomic : 1; unsigned IsAAPCS : 1; unsigned IsThumb : 1; unsigned HWDiv : 2; @@ -3972,37 +4025,6 @@ class ARMTargetInfo : public TargetInfo { static const Builtin::Info BuiltinInfo[]; - static bool shouldUseInlineAtomic(const llvm::Triple &T) { - StringRef ArchName = T.getArchName(); - if (T.getArch() == llvm::Triple::arm || - T.getArch() == llvm::Triple::armeb) { - StringRef VersionStr; - if (ArchName.startswith("armv")) - VersionStr = ArchName.substr(4, 1); - else if (ArchName.startswith("armebv")) - VersionStr = ArchName.substr(6, 1); - else - return false; - unsigned Version; - if (VersionStr.getAsInteger(10, Version)) - return false; - return Version >= 6; - } - assert(T.getArch() == llvm::Triple::thumb || - T.getArch() == llvm::Triple::thumbeb); - StringRef VersionStr; - if (ArchName.startswith("thumbv")) - VersionStr = ArchName.substr(6, 1); - else if (ArchName.startswith("thumbebv")) - VersionStr = ArchName.substr(8, 1); - else - return false; - unsigned Version; - if (VersionStr.getAsInteger(10, Version)) - return false; - return Version >= 7; - } - void setABIAAPCS() { IsAAPCS = true; @@ -4101,6 +4123,27 @@ class ARMTargetInfo : public TargetInfo { // FIXME: Override "preferred align" for double and long long. } + void setArchInfo(StringRef ArchName) { + ArchISA = llvm::ARMTargetParser::parseArchISA(ArchName); + ArchKind = llvm::ARMTargetParser::parseArch(ArchName); + ArchProfile = llvm::ARMTargetParser::parseArchProfile(ArchName); + ArchVersion = llvm::ARMTargetParser::parseArchVersion(ArchName); + } + + void setAtomic() { + // Cortex M does not support 8 byte atomics, while general Thumb2 does. + if (ArchProfile == llvm::ARM::PK_M) { + MaxAtomicPromoteWidth = 32; + if (ShouldUseInlineAtomic) + MaxAtomicInlineWidth = 32; + } + else { + MaxAtomicPromoteWidth = 64; + if (ShouldUseInlineAtomic) + MaxAtomicInlineWidth = 64; + } + } + public: ARMTargetInfo(const llvm::Triple &Triple, bool IsBigEndian) : TargetInfo(Triple), CPU("arm1136j-s"), FPMath(FP_Default), @@ -4116,12 +4159,27 @@ public: break; } + // if subArch is not specified Arc Info is based on the default CPU + if (Triple.getSubArch() == llvm::Triple::SubArchType::NoSubArch) { + unsigned ArchKind = llvm::ARMTargetParser::parseCPUArch(CPU); + setArchInfo(llvm::ARMTargetParser::getArchName(ArchKind)); + ShouldUseInlineAtomic = false; + } + else { + setArchInfo(Triple.getArchName()); + // FIXME: Should't this be updated also when calling setCPU() ? + // Doing so currently causes regressions + ShouldUseInlineAtomic = (ArchISA == llvm::ARM::IK_ARM && ArchVersion >= 6) || + (ArchISA == llvm::ARM::IK_THUMB && ArchVersion >= 7); + } + // {} in inline assembly are neon specifiers, not assembly variant // specifiers. NoAsmVariants = true; - // FIXME: Should we just treat this as a feature? - IsThumb = getTriple().getArchName().startswith("thumb"); + // FIXME: Should't this be updated also when calling setCPU() ? + // Doing so currently causes regressions + IsThumb = (ArchISA == llvm::ARM::IK_THUMB); // FIXME: This duplicates code from the driver that sets the -target-abi // option - this code is used if -target-abi isn't passed and should @@ -4166,10 +4224,7 @@ public: // ARM targets default to using the ARM C++ ABI. TheCXXABI.set(TargetCXXABI::GenericARM); - // ARM has atomics up to 8 bytes - MaxAtomicPromoteWidth = 64; - if (shouldUseInlineAtomic(getTriple())) - MaxAtomicInlineWidth = 64; + setAtomic(); // Do force alignment of members that follow zero length bitfields. If // the alignment of the zero-length bitfield is greater than the member @@ -4177,7 +4232,9 @@ public: // zero length bitfield. UseZeroLengthBitfieldAlignment = true; } + StringRef getABI() const override { return ABI; } + bool setABI(const std::string &Name) override { ABI = Name; @@ -4198,11 +4255,6 @@ public: // FIXME: This should be based on Arch attributes, not CPU names. void getDefaultFeatures(llvm::StringMap<bool> &Features) const override { - StringRef ArchName = getTriple().getArchName(); - unsigned ArchKind = llvm::ARMTargetParser::parseArch(ArchName); - bool IsV8 = (ArchKind == llvm::ARM::AK_ARMV8A || - ArchKind == llvm::ARM::AK_ARMV8_1A); - if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore") Features["vfp2"] = true; else if (CPU == "cortex-a8" || CPU == "cortex-a9") { @@ -4227,7 +4279,7 @@ public: Features["hwdiv-arm"] = true; Features["crc"] = true; Features["crypto"] = true; - } else if (CPU == "cortex-r5" || CPU == "cortex-r7" || IsV8) { + } else if (CPU == "cortex-r5" || CPU == "cortex-r7" || ArchVersion == 8) { Features["hwdiv"] = true; Features["hwdiv-arm"] = true; } else if (CPU == "cortex-m3" || CPU == "cortex-m4" || CPU == "cortex-m7" || @@ -4244,6 +4296,9 @@ public: SoftFloat = SoftFloatABI = false; HWDiv = 0; + // This does not diagnose illegal cases like having both + // "+vfpv2" and "+vfpv3" or having "+neon" and "+fp-only-sp". + uint32_t HW_FP_remove = 0; for (const auto &Feature : Features) { if (Feature == "+soft-float") { SoftFloat = true; @@ -4251,19 +4306,19 @@ public: SoftFloatABI = true; } else if (Feature == "+vfp2") { FPU |= VFP2FPU; - HW_FP = HW_FP_SP | HW_FP_DP; + HW_FP |= HW_FP_SP | HW_FP_DP; } else if (Feature == "+vfp3") { FPU |= VFP3FPU; - HW_FP = HW_FP_SP | HW_FP_DP; + HW_FP |= HW_FP_SP | HW_FP_DP; } else if (Feature == "+vfp4") { FPU |= VFP4FPU; - HW_FP = HW_FP_SP | HW_FP_DP | HW_FP_HP; + HW_FP |= HW_FP_SP | HW_FP_DP | HW_FP_HP; } else if (Feature == "+fp-armv8") { FPU |= FPARMV8; - HW_FP = HW_FP_SP | HW_FP_DP | HW_FP_HP; + HW_FP |= HW_FP_SP | HW_FP_DP | HW_FP_HP; } else if (Feature == "+neon") { FPU |= NeonFPU; - HW_FP = HW_FP_SP | HW_FP_DP; + HW_FP |= HW_FP_SP | HW_FP_DP; } else if (Feature == "+hwdiv") { HWDiv |= HWDivThumb; } else if (Feature == "+hwdiv-arm") { @@ -4273,9 +4328,10 @@ public: } else if (Feature == "+crypto") { Crypto = 1; } else if (Feature == "+fp-only-sp") { - HW_FP &= ~HW_FP_DP; + HW_FP_remove |= HW_FP_DP | HW_FP_HP; } } + HW_FP &= ~HW_FP_remove; if (!(FPU & NeonFPU) && FPMath == FP_Neon) { Diags.Report(diag::err_target_unsupported_fpmath) << "neon"; @@ -4306,26 +4362,14 @@ public: .Case("hwdiv-arm", HWDiv & HWDivARM) .Default(false); } - const char *getCPUDefineSuffix(StringRef Name) const { - if(Name == "generic") { - auto subarch = getTriple().getSubArch(); - switch (subarch) { - case llvm::Triple::SubArchType::ARMSubArch_v8_1a: - return "8_1A"; - default: - break; - } - } - - unsigned ArchKind = llvm::ARMTargetParser::parseCPUArch(Name); - if (ArchKind == llvm::ARM::AK_INVALID) - return ""; - + const char *getCPUAttr() const { + const char *CPUAttr; // For most sub-arches, the build attribute CPU name is enough. // For Cortex variants, it's slightly different. switch(ArchKind) { default: - return llvm::ARMTargetParser::getCPUAttr(ArchKind); + CPUAttr = llvm::ARMTargetParser::getCPUAttr(ArchKind); + return CPUAttr ? CPUAttr : "" ; case llvm::ARM::AK_ARMV6M: case llvm::ARM::AK_ARMV6SM: return "6M"; @@ -4345,23 +4389,8 @@ public: return "8_1A"; } } - const char *getCPUProfile(StringRef Name) const { - if(Name == "generic") { - auto subarch = getTriple().getSubArch(); - switch (subarch) { - case llvm::Triple::SubArchType::ARMSubArch_v8_1a: - return "A"; - default: - break; - } - } - - unsigned CPUArch = llvm::ARMTargetParser::parseCPUArch(Name); - if (CPUArch == llvm::ARM::AK_INVALID) - return ""; - - StringRef ArchName = llvm::ARMTargetParser::getArchName(CPUArch); - switch(llvm::ARMTargetParser::parseArchProfile(ArchName)) { + const char *getCPUProfile() const { + switch(ArchProfile) { case llvm::ARM::PK_A: return "A"; case llvm::ARM::PK_R: @@ -4373,35 +4402,26 @@ public: } } bool setCPU(const std::string &Name) override { - if (!getCPUDefineSuffix(Name)) + unsigned ArchKind = llvm::ARMTargetParser::parseCPUArch(Name); + if (ArchKind == llvm::ARM::AK_INVALID) return false; - - // Cortex M does not support 8 byte atomics, while general Thumb2 does. - StringRef Profile = getCPUProfile(Name); - if (Profile == "M" && MaxAtomicInlineWidth) { - MaxAtomicPromoteWidth = 32; - MaxAtomicInlineWidth = 32; - } - + setArchInfo(llvm::ARMTargetParser::getArchName(ArchKind)); + setAtomic(); CPU = Name; return true; } bool setFPMath(StringRef Name) override; - bool supportsThumb(StringRef ArchName, StringRef CPUArch, - unsigned CPUArchVer) const { - return CPUArchVer >= 7 || (CPUArch.find('T') != StringRef::npos) || - (CPUArch.find('M') != StringRef::npos); - } - bool supportsThumb2(StringRef ArchName, StringRef CPUArch, - unsigned CPUArchVer) const { - // We check both CPUArchVer and ArchName because when only triple is - // specified, the default CPU is arm1136j-s. - return ArchName.endswith("v6t2") || ArchName.endswith("v7") || - ArchName.endswith("v8.1a") || - ArchName.endswith("v8") || CPUArch == "6T2" || CPUArchVer >= 7; + bool supportsThumb(StringRef CPUAttr) const { + return CPUAttr.count('T') || ArchVersion >= 6; + } + bool supportsThumb2(StringRef CPUAttr) const { + return CPUAttr.equals("6T2") || ArchVersion >= 7; } void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override { + StringRef CPUAttr = getCPUAttr(); + StringRef CPUProfile = getCPUProfile(); + // Target identification. Builder.defineMacro("__arm"); Builder.defineMacro("__arm__"); @@ -4409,19 +4429,12 @@ public: // Target properties. Builder.defineMacro("__REGISTER_PREFIX__", ""); - StringRef CPUArch = getCPUDefineSuffix(CPU); - unsigned int CPUArchVer; - if (CPUArch.substr(0, 1).getAsInteger<unsigned int>(10, CPUArchVer)) - llvm_unreachable("Invalid char for architecture version number"); - Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__"); + Builder.defineMacro("__ARM_ARCH_" + CPUAttr + "__"); // ACLE 6.4.1 ARM/Thumb instruction set architecture - StringRef CPUProfile = getCPUProfile(CPU); - StringRef ArchName = getTriple().getArchName(); - // __ARM_ARCH is defined as an integer value indicating the current ARM ISA - Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1)); - if (CPUArch[0] >= '8') { + Builder.defineMacro("__ARM_ARCH", std::to_string(ArchVersion)); + if (ArchVersion >= 8) { Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN"); Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING"); } @@ -4435,9 +4448,9 @@ public: // __ARM_ARCH_ISA_THUMB is defined to 1 if the core supporst the original // Thumb ISA (including v6-M). It is set to 2 if the core supports the // Thumb-2 ISA as found in the v6T2 architecture and all v7 architecture. - if (supportsThumb2(ArchName, CPUArch, CPUArchVer)) + if (supportsThumb2(CPUAttr)) Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "2"); - else if (supportsThumb(ArchName, CPUArch, CPUArchVer)) + else if (supportsThumb(CPUAttr)) Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "1"); // __ARM_32BIT_STATE is defined to 1 if code is being generated for a 32-bit @@ -4462,7 +4475,7 @@ public: // FIXME: It's more complicated than this and we don't really support // interworking. // Windows on ARM does not "support" interworking - if (5 <= CPUArchVer && CPUArchVer <= 8 && !getTriple().isOSWindows()) + if (5 <= ArchVersion && ArchVersion <= 8 && !getTriple().isOSWindows()) Builder.defineMacro("__THUMB_INTERWORK__"); if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") { @@ -4485,7 +4498,7 @@ public: if (IsThumb) { Builder.defineMacro("__THUMBEL__"); Builder.defineMacro("__thumb__"); - if (supportsThumb2(ArchName, CPUArch, CPUArchVer)) + if (supportsThumb2(CPUAttr)) Builder.defineMacro("__thumb2__"); } if (((HWDiv & HWDivThumb) && IsThumb) || ((HWDiv & HWDivARM) && !IsThumb)) @@ -4508,7 +4521,7 @@ public: // the VFP define, hence the soft float and arch check. This is subtly // different from gcc, we follow the intent which was that it should be set // when Neon instructions are actually available. - if ((FPU & NeonFPU) && !SoftFloat && CPUArchVer >= 7) { + if ((FPU & NeonFPU) && !SoftFloat && ArchVersion >= 7) { Builder.defineMacro("__ARM_NEON"); Builder.defineMacro("__ARM_NEON__"); } @@ -4525,18 +4538,18 @@ public: if (Crypto) Builder.defineMacro("__ARM_FEATURE_CRYPTO"); - if (CPUArchVer >= 6 && CPUArch != "6M") { + if (ArchVersion >= 6 && CPUAttr != "6M") { Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"); Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"); } - bool is5EOrAbove = (CPUArchVer >= 6 || - (CPUArchVer == 5 && - CPUArch.find('E') != StringRef::npos)); - bool is32Bit = (!IsThumb || supportsThumb2(ArchName, CPUArch, CPUArchVer)); - if (is5EOrAbove && is32Bit && (CPUProfile != "M" || CPUArch == "7EM")) + bool is5EOrAbove = (ArchVersion >= 6 || + (ArchVersion == 5 && CPUAttr.count('E'))); + // FIXME: We are not getting all 32-bit ARM architectures + bool is32Bit = (!IsThumb || supportsThumb2(CPUAttr)); + if (is5EOrAbove && is32Bit && (CPUProfile != "M" || CPUAttr == "7EM")) Builder.defineMacro("__ARM_FEATURE_DSP"); } void getTargetBuiltins(const Builtin::Info *&Records, diff --git a/lib/Basic/VirtualFileSystem.cpp b/lib/Basic/VirtualFileSystem.cpp index 8a882e13f7a5..a36102cf0f5a 100644 --- a/lib/Basic/VirtualFileSystem.cpp +++ b/lib/Basic/VirtualFileSystem.cpp @@ -324,20 +324,6 @@ directory_iterator OverlayFileSystem::dir_begin(const Twine &Dir, // VFSFromYAML implementation //===-----------------------------------------------------------------------===/ -// Allow DenseMap<StringRef, ...>. This is useful below because we know all the -// strings are literals and will outlive the map, and there is no reason to -// store them. -namespace llvm { - template<> - struct DenseMapInfo<StringRef> { - // This assumes that "" will never be a valid key. - static inline StringRef getEmptyKey() { return StringRef(""); } - static inline StringRef getTombstoneKey() { return StringRef(); } - static unsigned getHashValue(StringRef Val) { return HashString(Val); } - static bool isEqual(StringRef LHS, StringRef RHS) { return LHS == RHS; } - }; -} - namespace { enum EntryKind { diff --git a/lib/CodeGen/BackendUtil.cpp b/lib/CodeGen/BackendUtil.cpp index f5edea7810ab..0bccad0570da 100644 --- a/lib/CodeGen/BackendUtil.cpp +++ b/lib/CodeGen/BackendUtil.cpp @@ -536,7 +536,6 @@ TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) { Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS; Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath; Options.StackAlignmentOverride = CodeGenOpts.StackAlignment; - Options.TrapFuncName = CodeGenOpts.TrapFuncName; Options.PositionIndependentExecutable = LangOpts.PIELevel != 0; Options.FunctionSections = CodeGenOpts.FunctionSections; Options.DataSections = CodeGenOpts.DataSections; @@ -604,7 +603,10 @@ void EmitAssemblyHelper::EmitAssembly(BackendAction Action, if (!TM) TM.reset(CreateTargetMachine(UsesCodeGen)); - if (UsesCodeGen && !TM) return; + if (UsesCodeGen && !TM) + return; + if (TM) + TheModule->setDataLayout(*TM->getDataLayout()); CreatePasses(); switch (Action) { diff --git a/lib/CodeGen/CGBuiltin.cpp b/lib/CodeGen/CGBuiltin.cpp index a14daac596f5..2ec909b9aac5 100644 --- a/lib/CodeGen/CGBuiltin.cpp +++ b/lib/CodeGen/CGBuiltin.cpp @@ -82,9 +82,9 @@ static Value *EmitFromInt(CodeGenFunction &CGF, llvm::Value *V, /// Utility to insert an atomic instruction based on Instrinsic::ID /// and the expression node. -static RValue EmitBinaryAtomic(CodeGenFunction &CGF, - llvm::AtomicRMWInst::BinOp Kind, - const CallExpr *E) { +static Value *MakeBinaryAtomicValue(CodeGenFunction &CGF, + llvm::AtomicRMWInst::BinOp Kind, + const CallExpr *E) { QualType T = E->getType(); assert(E->getArg(0)->getType()->isPointerType()); assert(CGF.getContext().hasSameUnqualifiedType(T, @@ -108,8 +108,13 @@ static RValue EmitBinaryAtomic(CodeGenFunction &CGF, llvm::Value *Result = CGF.Builder.CreateAtomicRMW(Kind, Args[0], Args[1], llvm::SequentiallyConsistent); - Result = EmitFromInt(CGF, Result, T, ValueType); - return RValue::get(Result); + return EmitFromInt(CGF, Result, T, ValueType); +} + +static RValue EmitBinaryAtomic(CodeGenFunction &CGF, + llvm::AtomicRMWInst::BinOp Kind, + const CallExpr *E) { + return RValue::get(MakeBinaryAtomicValue(CGF, Kind, E)); } /// Utility to insert an atomic instruction based Instrinsic::ID and @@ -151,6 +156,47 @@ static RValue EmitBinaryAtomicPost(CodeGenFunction &CGF, return RValue::get(Result); } +/// @brief Utility to insert an atomic cmpxchg instruction. +/// +/// @param CGF The current codegen function. +/// @param E Builtin call expression to convert to cmpxchg. +/// arg0 - address to operate on +/// arg1 - value to compare with +/// arg2 - new value +/// @param ReturnBool Specifies whether to return success flag of +/// cmpxchg result or the old value. +/// +/// @returns result of cmpxchg, according to ReturnBool +static Value *MakeAtomicCmpXchgValue(CodeGenFunction &CGF, const CallExpr *E, + bool ReturnBool) { + QualType T = ReturnBool ? E->getArg(1)->getType() : E->getType(); + llvm::Value *DestPtr = CGF.EmitScalarExpr(E->getArg(0)); + unsigned AddrSpace = DestPtr->getType()->getPointerAddressSpace(); + + llvm::IntegerType *IntType = llvm::IntegerType::get( + CGF.getLLVMContext(), CGF.getContext().getTypeSize(T)); + llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace); + + Value *Args[3]; + Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType); + Args[1] = CGF.EmitScalarExpr(E->getArg(1)); + llvm::Type *ValueType = Args[1]->getType(); + Args[1] = EmitToInt(CGF, Args[1], T, IntType); + Args[2] = EmitToInt(CGF, CGF.EmitScalarExpr(E->getArg(2)), T, IntType); + + Value *Pair = CGF.Builder.CreateAtomicCmpXchg(Args[0], Args[1], Args[2], + llvm::SequentiallyConsistent, + llvm::SequentiallyConsistent); + if (ReturnBool) + // Extract boolean success flag and zext it to int. + return CGF.Builder.CreateZExt(CGF.Builder.CreateExtractValue(Pair, 1), + CGF.ConvertType(E->getType())); + else + // Extract old value and emit it using the same type as compare value. + return EmitFromInt(CGF, CGF.Builder.CreateExtractValue(Pair, 0), T, + ValueType); +} + /// EmitFAbs - Emit a call to @llvm.fabs(). static Value *EmitFAbs(CodeGenFunction &CGF, Value *V) { Value *F = CGF.CGM.getIntrinsic(Intrinsic::fabs, V->getType()); @@ -497,14 +543,10 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD, Value *F = CGM.getIntrinsic(Intrinsic::clear_cache); return RValue::get(Builder.CreateCall(F, {Begin, End})); } - case Builtin::BI__builtin_trap: { - Value *F = CGM.getIntrinsic(Intrinsic::trap); - return RValue::get(Builder.CreateCall(F, {})); - } - case Builtin::BI__debugbreak: { - Value *F = CGM.getIntrinsic(Intrinsic::debugtrap); - return RValue::get(Builder.CreateCall(F, {})); - } + case Builtin::BI__builtin_trap: + return RValue::get(EmitTrapCall(Intrinsic::trap)); + case Builtin::BI__debugbreak: + return RValue::get(EmitTrapCall(Intrinsic::debugtrap)); case Builtin::BI__builtin_unreachable: { if (SanOpts.has(SanitizerKind::Unreachable)) { SanitizerScope SanScope(this); @@ -1057,58 +1099,15 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD, case Builtin::BI__sync_val_compare_and_swap_2: case Builtin::BI__sync_val_compare_and_swap_4: case Builtin::BI__sync_val_compare_and_swap_8: - case Builtin::BI__sync_val_compare_and_swap_16: { - QualType T = E->getType(); - llvm::Value *DestPtr = EmitScalarExpr(E->getArg(0)); - unsigned AddrSpace = DestPtr->getType()->getPointerAddressSpace(); - - llvm::IntegerType *IntType = - llvm::IntegerType::get(getLLVMContext(), - getContext().getTypeSize(T)); - llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace); - - Value *Args[3]; - Args[0] = Builder.CreateBitCast(DestPtr, IntPtrType); - Args[1] = EmitScalarExpr(E->getArg(1)); - llvm::Type *ValueType = Args[1]->getType(); - Args[1] = EmitToInt(*this, Args[1], T, IntType); - Args[2] = EmitToInt(*this, EmitScalarExpr(E->getArg(2)), T, IntType); - - Value *Result = Builder.CreateAtomicCmpXchg(Args[0], Args[1], Args[2], - llvm::SequentiallyConsistent, - llvm::SequentiallyConsistent); - Result = Builder.CreateExtractValue(Result, 0); - Result = EmitFromInt(*this, Result, T, ValueType); - return RValue::get(Result); - } + case Builtin::BI__sync_val_compare_and_swap_16: + return RValue::get(MakeAtomicCmpXchgValue(*this, E, false)); case Builtin::BI__sync_bool_compare_and_swap_1: case Builtin::BI__sync_bool_compare_and_swap_2: case Builtin::BI__sync_bool_compare_and_swap_4: case Builtin::BI__sync_bool_compare_and_swap_8: - case Builtin::BI__sync_bool_compare_and_swap_16: { - QualType T = E->getArg(1)->getType(); - llvm::Value *DestPtr = EmitScalarExpr(E->getArg(0)); - unsigned AddrSpace = DestPtr->getType()->getPointerAddressSpace(); - - llvm::IntegerType *IntType = - llvm::IntegerType::get(getLLVMContext(), - getContext().getTypeSize(T)); - llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace); - - Value *Args[3]; - Args[0] = Builder.CreateBitCast(DestPtr, IntPtrType); - Args[1] = EmitToInt(*this, EmitScalarExpr(E->getArg(1)), T, IntType); - Args[2] = EmitToInt(*this, EmitScalarExpr(E->getArg(2)), T, IntType); - - Value *Pair = Builder.CreateAtomicCmpXchg(Args[0], Args[1], Args[2], - llvm::SequentiallyConsistent, - llvm::SequentiallyConsistent); - Value *Result = Builder.CreateExtractValue(Pair, 1); - // zext bool to int. - Result = Builder.CreateZExt(Result, ConvertType(E->getType())); - return RValue::get(Result); - } + case Builtin::BI__sync_bool_compare_and_swap_16: + return RValue::get(MakeAtomicCmpXchgValue(*this, E, true)); case Builtin::BI__sync_swap_1: case Builtin::BI__sync_swap_2: @@ -1880,6 +1879,9 @@ Value *CodeGenFunction::EmitTargetBuiltinExpr(unsigned BuiltinID, return EmitAMDGPUBuiltinExpr(BuiltinID, E); case llvm::Triple::systemz: return EmitSystemZBuiltinExpr(BuiltinID, E); + case llvm::Triple::nvptx: + case llvm::Triple::nvptx64: + return EmitNVPTXBuiltinExpr(BuiltinID, E); default: return nullptr; } @@ -3339,6 +3341,42 @@ static Value *EmitSpecialRegisterBuiltin(CodeGenFunction &CGF, return Builder.CreateCall(F, { Metadata, ArgValue }); } +/// Return true if BuiltinID is an overloaded Neon intrinsic with an extra +/// argument that specifies the vector type. +static bool HasExtraNeonArgument(unsigned BuiltinID) { + switch (BuiltinID) { + default: break; + case NEON::BI__builtin_neon_vget_lane_i8: + case NEON::BI__builtin_neon_vget_lane_i16: + case NEON::BI__builtin_neon_vget_lane_i32: + case NEON::BI__builtin_neon_vget_lane_i64: + case NEON::BI__builtin_neon_vget_lane_f32: + case NEON::BI__builtin_neon_vgetq_lane_i8: + case NEON::BI__builtin_neon_vgetq_lane_i16: + case NEON::BI__builtin_neon_vgetq_lane_i32: + case NEON::BI__builtin_neon_vgetq_lane_i64: + case NEON::BI__builtin_neon_vgetq_lane_f32: + case NEON::BI__builtin_neon_vset_lane_i8: + case NEON::BI__builtin_neon_vset_lane_i16: + case NEON::BI__builtin_neon_vset_lane_i32: + case NEON::BI__builtin_neon_vset_lane_i64: + case NEON::BI__builtin_neon_vset_lane_f32: + case NEON::BI__builtin_neon_vsetq_lane_i8: + case NEON::BI__builtin_neon_vsetq_lane_i16: + case NEON::BI__builtin_neon_vsetq_lane_i32: + case NEON::BI__builtin_neon_vsetq_lane_i64: + case NEON::BI__builtin_neon_vsetq_lane_f32: + case NEON::BI__builtin_neon_vsha1h_u32: + case NEON::BI__builtin_neon_vsha1cq_u32: + case NEON::BI__builtin_neon_vsha1pq_u32: + case NEON::BI__builtin_neon_vsha1mq_u32: + case ARM::BI_MoveToCoprocessor: + case ARM::BI_MoveToCoprocessor2: + return false; + } + return true; +} + Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E) { if (auto Hint = GetValueForARMHint(BuiltinID)) @@ -3591,7 +3629,9 @@ Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID, SmallVector<Value*, 4> Ops; llvm::Value *Align = nullptr; - for (unsigned i = 0, e = E->getNumArgs() - 1; i != e; i++) { + bool HasExtraArg = HasExtraNeonArgument(BuiltinID); + unsigned NumArgs = E->getNumArgs() - (HasExtraArg ? 1 : 0); + for (unsigned i = 0, e = NumArgs; i != e; i++) { if (i == 0) { switch (BuiltinID) { case NEON::BI__builtin_neon_vld1_v: @@ -3666,8 +3706,7 @@ Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID, switch (BuiltinID) { default: break; - // vget_lane and vset_lane are not overloaded and do not have an extra - // argument that specifies the vector type. + case NEON::BI__builtin_neon_vget_lane_i8: case NEON::BI__builtin_neon_vget_lane_i16: case NEON::BI__builtin_neon_vget_lane_i32: @@ -3678,8 +3717,8 @@ Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID, case NEON::BI__builtin_neon_vgetq_lane_i32: case NEON::BI__builtin_neon_vgetq_lane_i64: case NEON::BI__builtin_neon_vgetq_lane_f32: - return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)), - "vget_lane"); + return Builder.CreateExtractElement(Ops[0], Ops[1], "vget_lane"); + case NEON::BI__builtin_neon_vset_lane_i8: case NEON::BI__builtin_neon_vset_lane_i16: case NEON::BI__builtin_neon_vset_lane_i32: @@ -3690,29 +3729,34 @@ Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID, case NEON::BI__builtin_neon_vsetq_lane_i32: case NEON::BI__builtin_neon_vsetq_lane_i64: case NEON::BI__builtin_neon_vsetq_lane_f32: - Ops.push_back(EmitScalarExpr(E->getArg(2))); return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane"); - // Non-polymorphic crypto instructions also not overloaded case NEON::BI__builtin_neon_vsha1h_u32: - Ops.push_back(EmitScalarExpr(E->getArg(0))); return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_sha1h), Ops, "vsha1h"); case NEON::BI__builtin_neon_vsha1cq_u32: - Ops.push_back(EmitScalarExpr(E->getArg(2))); return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_sha1c), Ops, "vsha1h"); case NEON::BI__builtin_neon_vsha1pq_u32: - Ops.push_back(EmitScalarExpr(E->getArg(2))); return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_sha1p), Ops, "vsha1h"); case NEON::BI__builtin_neon_vsha1mq_u32: - Ops.push_back(EmitScalarExpr(E->getArg(2))); return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_sha1m), Ops, "vsha1h"); + + // The ARM _MoveToCoprocessor builtins put the input register value as + // the first argument, but the LLVM intrinsic expects it as the third one. + case ARM::BI_MoveToCoprocessor: + case ARM::BI_MoveToCoprocessor2: { + Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI_MoveToCoprocessor ? + Intrinsic::arm_mcr : Intrinsic::arm_mcr2); + return Builder.CreateCall(F, {Ops[1], Ops[2], Ops[0], + Ops[3], Ops[4], Ops[5]}); + } } // Get the last argument, which specifies the vector type. + assert(HasExtraArg); llvm::APSInt Result; const Expr *Arg = E->getArg(E->getNumArgs()-1); if (!Arg->isIntegerConstantExpr(Result, getContext())) @@ -6053,6 +6097,83 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID, switch (BuiltinID) { default: return nullptr; + case X86::BI__builtin_cpu_supports: { + const Expr *FeatureExpr = E->getArg(0)->IgnoreParenCasts(); + StringRef FeatureStr = cast<StringLiteral>(FeatureExpr)->getString(); + + // TODO: When/if this becomes more than x86 specific then use a TargetInfo + // based mapping. + // Processor features and mapping to processor feature value. + enum X86Features { + CMOV = 0, + MMX, + POPCNT, + SSE, + SSE2, + SSE3, + SSSE3, + SSE4_1, + SSE4_2, + AVX, + AVX2, + SSE4_A, + FMA4, + XOP, + FMA, + AVX512F, + BMI, + BMI2, + MAX + }; + + X86Features Feature = StringSwitch<X86Features>(FeatureStr) + .Case("cmov", X86Features::CMOV) + .Case("mmx", X86Features::MMX) + .Case("popcnt", X86Features::POPCNT) + .Case("sse", X86Features::SSE) + .Case("sse2", X86Features::SSE2) + .Case("sse3", X86Features::SSE3) + .Case("sse4.1", X86Features::SSE4_1) + .Case("sse4.2", X86Features::SSE4_2) + .Case("avx", X86Features::AVX) + .Case("avx2", X86Features::AVX2) + .Case("sse4a", X86Features::SSE4_A) + .Case("fma4", X86Features::FMA4) + .Case("xop", X86Features::XOP) + .Case("fma", X86Features::FMA) + .Case("avx512f", X86Features::AVX512F) + .Case("bmi", X86Features::BMI) + .Case("bmi2", X86Features::BMI2) + .Default(X86Features::MAX); + assert(Feature != X86Features::MAX && "Invalid feature!"); + + // Matching the struct layout from the compiler-rt/libgcc structure that is + // filled in: + // unsigned int __cpu_vendor; + // unsigned int __cpu_type; + // unsigned int __cpu_subtype; + // unsigned int __cpu_features[1]; + llvm::Type *STy = llvm::StructType::get( + Int32Ty, Int32Ty, Int32Ty, llvm::ArrayType::get(Int32Ty, 1), nullptr); + + // Grab the global __cpu_model. + llvm::Constant *CpuModel = CGM.CreateRuntimeVariable(STy, "__cpu_model"); + + // Grab the first (0th) element from the field __cpu_features off of the + // global in the struct STy. + Value *Idxs[] = { + ConstantInt::get(Int32Ty, 0), + ConstantInt::get(Int32Ty, 3), + ConstantInt::get(Int32Ty, 0) + }; + Value *CpuFeatures = Builder.CreateGEP(STy, CpuModel, Idxs); + Value *Features = Builder.CreateLoad(CpuFeatures); + + // Check the value of the bit corresponding to the feature requested. + Value *Bitset = Builder.CreateAnd( + Features, llvm::ConstantInt::get(Int32Ty, 1 << Feature)); + return Builder.CreateICmpNE(Bitset, llvm::ConstantInt::get(Int32Ty, 0)); + } case X86::BI_mm_prefetch: { Value *Address = EmitScalarExpr(E->getArg(0)); Value *RW = ConstantInt::get(Int32Ty, 0); @@ -6512,6 +6633,13 @@ Value *CodeGenFunction::EmitPPCBuiltinExpr(unsigned BuiltinID, llvm::Function *F = CGM.getIntrinsic(ID); return Builder.CreateCall(F, Ops, ""); } + case PPC::BI__builtin_vsx_xvrspip: + case PPC::BI__builtin_vsx_xvrdpip: + llvm::Type *ResultType = ConvertType(E->getType()); + Value *X = EmitScalarExpr(E->getArg(0)); + ID = Intrinsic::ceil; + llvm::Function *F = CGM.getIntrinsic(ID, ResultType); + return Builder.CreateCall(F, X); } } @@ -6859,3 +6987,72 @@ Value *CodeGenFunction::EmitSystemZBuiltinExpr(unsigned BuiltinID, return nullptr; } } + +Value *CodeGenFunction::EmitNVPTXBuiltinExpr(unsigned BuiltinID, + const CallExpr *E) { + switch (BuiltinID) { + case NVPTX::BI__nvvm_atom_add_gen_i: + case NVPTX::BI__nvvm_atom_add_gen_l: + case NVPTX::BI__nvvm_atom_add_gen_ll: + return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Add, E); + + case NVPTX::BI__nvvm_atom_sub_gen_i: + case NVPTX::BI__nvvm_atom_sub_gen_l: + case NVPTX::BI__nvvm_atom_sub_gen_ll: + return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Sub, E); + + case NVPTX::BI__nvvm_atom_and_gen_i: + case NVPTX::BI__nvvm_atom_and_gen_l: + case NVPTX::BI__nvvm_atom_and_gen_ll: + return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::And, E); + + case NVPTX::BI__nvvm_atom_or_gen_i: + case NVPTX::BI__nvvm_atom_or_gen_l: + case NVPTX::BI__nvvm_atom_or_gen_ll: + return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Or, E); + + case NVPTX::BI__nvvm_atom_xor_gen_i: + case NVPTX::BI__nvvm_atom_xor_gen_l: + case NVPTX::BI__nvvm_atom_xor_gen_ll: + return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Xor, E); + + case NVPTX::BI__nvvm_atom_xchg_gen_i: + case NVPTX::BI__nvvm_atom_xchg_gen_l: + case NVPTX::BI__nvvm_atom_xchg_gen_ll: + return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Xchg, E); + + case NVPTX::BI__nvvm_atom_max_gen_i: + case NVPTX::BI__nvvm_atom_max_gen_l: + case NVPTX::BI__nvvm_atom_max_gen_ll: + case NVPTX::BI__nvvm_atom_max_gen_ui: + case NVPTX::BI__nvvm_atom_max_gen_ul: + case NVPTX::BI__nvvm_atom_max_gen_ull: + return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Max, E); + + case NVPTX::BI__nvvm_atom_min_gen_i: + case NVPTX::BI__nvvm_atom_min_gen_l: + case NVPTX::BI__nvvm_atom_min_gen_ll: + case NVPTX::BI__nvvm_atom_min_gen_ui: + case NVPTX::BI__nvvm_atom_min_gen_ul: + case NVPTX::BI__nvvm_atom_min_gen_ull: + return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Min, E); + + case NVPTX::BI__nvvm_atom_cas_gen_i: + case NVPTX::BI__nvvm_atom_cas_gen_l: + case NVPTX::BI__nvvm_atom_cas_gen_ll: + return MakeAtomicCmpXchgValue(*this, E, true); + + case NVPTX::BI__nvvm_atom_add_gen_f: { + Value *Ptr = EmitScalarExpr(E->getArg(0)); + Value *Val = EmitScalarExpr(E->getArg(1)); + // atomicrmw only deals with integer arguments so we need to use + // LLVM's nvvm_atomic_load_add_f32 intrinsic for that. + Value *FnALAF32 = + CGM.getIntrinsic(Intrinsic::nvvm_atomic_load_add_f32, Ptr->getType()); + return Builder.CreateCall(FnALAF32, {Ptr, Val}); + } + + default: + return nullptr; + } +} diff --git a/lib/CodeGen/CGCXXABI.cpp b/lib/CodeGen/CGCXXABI.cpp index cb7e6dfca1c5..dc16616df9c5 100644 --- a/lib/CodeGen/CGCXXABI.cpp +++ b/lib/CodeGen/CGCXXABI.cpp @@ -130,10 +130,9 @@ CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) { return GetBogusMemberPointer(QualType(MPT, 0)); } -llvm::Constant *CGCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) { - return GetBogusMemberPointer( - CGM.getContext().getMemberPointerType(MD->getType(), - MD->getParent()->getTypeForDecl())); +llvm::Constant *CGCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) { + return GetBogusMemberPointer(CGM.getContext().getMemberPointerType( + MD->getType(), MD->getParent()->getTypeForDecl())); } llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT, diff --git a/lib/CodeGen/CGCXXABI.h b/lib/CodeGen/CGCXXABI.h index b6b4ee6850ac..436b96a615ef 100644 --- a/lib/CodeGen/CGCXXABI.h +++ b/lib/CodeGen/CGCXXABI.h @@ -172,7 +172,7 @@ public: virtual llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT); /// Create a member pointer for the given method. - virtual llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD); + virtual llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD); /// Create a member pointer for the given field. virtual llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT, diff --git a/lib/CodeGen/CGCall.cpp b/lib/CodeGen/CGCall.cpp index 58ef171df0d7..0535c05da5d5 100644 --- a/lib/CodeGen/CGCall.cpp +++ b/lib/CodeGen/CGCall.cpp @@ -32,7 +32,6 @@ #include "llvm/IR/Intrinsics.h" #include "llvm/IR/IntrinsicInst.h" #include "llvm/Transforms/Utils/Local.h" -#include <sstream> using namespace clang; using namespace CodeGen; @@ -1453,6 +1452,8 @@ void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI, // Attributes that should go on the call site only. if (!CodeGenOpts.SimplifyLibCalls) FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin); + if (!CodeGenOpts.TrapFuncName.empty()) + FuncAttrs.addAttribute("trap-func-name", CodeGenOpts.TrapFuncName); } else { // Attributes that should go on the function, but not the call site. if (!CodeGenOpts.DisableFPElim) { @@ -1493,12 +1494,16 @@ void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI, // 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); + // Canonicalize the existing features in a new feature map. + // TODO: Migrate the existing backends to keep the map around rather than + // the vector. + llvm::StringMap<bool> FeatureMap; + for (auto F : getTarget().getTargetOpts().Features) { + const char *Name = F.c_str(); + bool Enabled = Name[0] == '+'; + getTarget().setFeatureEnabled(FeatureMap, Name + 1, Enabled); + } - // 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>()) { @@ -1507,7 +1512,7 @@ void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI, 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. + // 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=")) @@ -1521,24 +1526,28 @@ void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI, // attributes on the function. ; else if (Feature.startswith("mno-")) - Features.push_back("-" + Feature.split("-").second.str()); + getTarget().setFeatureEnabled(FeatureMap, Feature.split("-").second, + false); else - Features.push_back("+" + Feature.str()); - } + getTarget().setFeatureEnabled(FeatureMap, Feature, true); + } } } + // Produce the canonical string for this set of features. + std::vector<std::string> Features; + for (llvm::StringMap<bool>::const_iterator it = FeatureMap.begin(), + ie = FeatureMap.end(); + it != ie; ++it) + Features.push_back((it->second ? "+" : "-") + it->first().str()); + // Now add the target-cpu and target-features to the function. if (TargetCPU != "") FuncAttrs.addAttribute("target-cpu", TargetCPU); if (!Features.empty()) { - std::stringstream TargetFeatures; - std::copy(Features.begin(), Features.end(), - std::ostream_iterator<std::string>(TargetFeatures, ",")); - - // The drop_back gets rid of the trailing space. + std::sort(Features.begin(), Features.end()); FuncAttrs.addAttribute("target-features", - StringRef(TargetFeatures.str()).drop_back(1)); + llvm::join(Features.begin(), Features.end(), ",")); } } diff --git a/lib/CodeGen/CGClass.cpp b/lib/CodeGen/CGClass.cpp index 1d2b7875d8f7..62df9820a6c3 100644 --- a/lib/CodeGen/CGClass.cpp +++ b/lib/CodeGen/CGClass.cpp @@ -29,13 +29,12 @@ using namespace clang; using namespace CodeGen; -static CharUnits -ComputeNonVirtualBaseClassOffset(ASTContext &Context, - const CXXRecordDecl *DerivedClass, - CastExpr::path_const_iterator Start, - CastExpr::path_const_iterator End) { +CharUnits CodeGenModule::computeNonVirtualBaseClassOffset( + const CXXRecordDecl *DerivedClass, CastExpr::path_const_iterator Start, + CastExpr::path_const_iterator End) { CharUnits Offset = CharUnits::Zero(); + const ASTContext &Context = getContext(); const CXXRecordDecl *RD = DerivedClass; for (CastExpr::path_const_iterator I = Start; I != End; ++I) { @@ -64,8 +63,7 @@ CodeGenModule::GetNonVirtualBaseClassOffset(const CXXRecordDecl *ClassDecl, assert(PathBegin != PathEnd && "Base path should not be empty!"); CharUnits Offset = - ComputeNonVirtualBaseClassOffset(getContext(), ClassDecl, - PathBegin, PathEnd); + computeNonVirtualBaseClassOffset(ClassDecl, PathBegin, PathEnd); if (Offset.isZero()) return nullptr; @@ -158,9 +156,8 @@ llvm::Value *CodeGenFunction::GetAddressOfBaseClass( // Compute the static offset of the ultimate destination within its // allocating subobject (the virtual base, if there is one, or else // the "complete" object that we see). - CharUnits NonVirtualOffset = - ComputeNonVirtualBaseClassOffset(getContext(), VBase ? VBase : Derived, - Start, PathEnd); + CharUnits NonVirtualOffset = CGM.computeNonVirtualBaseClassOffset( + VBase ? VBase : Derived, Start, PathEnd); // If there's a virtual step, we can sometimes "devirtualize" it. // For now, that's limited to when the derived type is final. @@ -1342,6 +1339,11 @@ FieldHasTrivialDestructorBody(ASTContext &Context, return true; CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl()); + + // The destructor for an implicit anonymous union member is never invoked. + if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion()) + return false; + return HasTrivialDestructorBody(Context, FieldClassDecl, FieldClassDecl); } diff --git a/lib/CodeGen/CGDebugInfo.cpp b/lib/CodeGen/CGDebugInfo.cpp index a20e39f3fc00..8c4b4b3d0617 100644 --- a/lib/CodeGen/CGDebugInfo.cpp +++ b/lib/CodeGen/CGDebugInfo.cpp @@ -27,6 +27,8 @@ #include "clang/Basic/SourceManager.h" #include "clang/Basic/Version.h" #include "clang/Frontend/CodeGenOptions.h" +#include "clang/Lex/HeaderSearchOptions.h" +#include "clang/Lex/PreprocessorOptions.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/Constants.h" @@ -1179,12 +1181,13 @@ void CGDebugInfo::CollectCXXMemberFunctions( // the member being added to type units by LLVM, while still allowing it // to be emitted into the type declaration/reference inside the compile // unit. + // Ditto 'nodebug' methods, for consistency with CodeGenFunction.cpp. // FIXME: Handle Using(Shadow?)Decls here to create // DW_TAG_imported_declarations inside the class for base decls brought into // derived classes. GDB doesn't seem to notice/leverage these when I tried // it, so I'm not rushing to fix this. (GCC seems to produce them, if // referenced) - if (!Method || Method->isImplicit()) + if (!Method || Method->isImplicit() || Method->hasAttr<NoDebugAttr>()) continue; if (Method->getType()->getAs<FunctionProtoType>()->getContainedAutoType()) @@ -1279,7 +1282,7 @@ CGDebugInfo::CollectTemplateParams(const TemplateParameterList *TPList, // Member function pointers have special support for building them, though // this is currently unsupported in LLVM CodeGen. else if ((MD = dyn_cast<CXXMethodDecl>(D)) && MD->isInstance()) - V = CGM.getCXXABI().EmitMemberPointer(MD); + V = CGM.getCXXABI().EmitMemberFunctionPointer(MD); else if (const auto *FD = dyn_cast<FunctionDecl>(D)) V = CGM.GetAddrOfFunction(FD); // Member data pointers have special handling too to compute the fixed @@ -1660,6 +1663,47 @@ llvm::DIType *CGDebugInfo::CreateType(const ObjCInterfaceType *Ty, return CreateTypeDefinition(Ty, Unit); } +llvm::DIModule * +CGDebugInfo::getOrCreateModuleRef(ExternalASTSource::ASTSourceDescriptor Mod) { + auto it = ModuleRefCache.find(Mod.Signature); + if (it != ModuleRefCache.end()) + return it->second; + + // Macro definitions that were defined with "-D" on the command line. + SmallString<128> ConfigMacros; + { + llvm::raw_svector_ostream OS(ConfigMacros); + const auto &PPOpts = CGM.getPreprocessorOpts(); + unsigned I = 0; + // Translate the macro definitions back into a commmand line. + for (auto &M : PPOpts.Macros) { + if (++I > 1) + OS << " "; + const std::string &Macro = M.first; + bool Undef = M.second; + OS << "\"-" << (Undef ? 'U' : 'D'); + for (char c : Macro) + switch (c) { + case '\\' : OS << "\\\\"; break; + case '"' : OS << "\\\""; break; + default: OS << c; + } + OS << '\"'; + } + } + llvm::DIBuilder DIB(CGM.getModule()); + auto *CU = DIB.createCompileUnit( + TheCU->getSourceLanguage(), internString(Mod.ModuleName), + internString(Mod.Path), TheCU->getProducer(), true, StringRef(), 0, + internString(Mod.ASTFile), llvm::DIBuilder::FullDebug, Mod.Signature); + llvm::DIModule *ModuleRef = + DIB.createModule(CU, Mod.ModuleName, ConfigMacros, internString(Mod.Path), + internString(CGM.getHeaderSearchOpts().Sysroot)); + DIB.finalize(); + ModuleRefCache.insert(std::make_pair(Mod.Signature, ModuleRef)); + return ModuleRef; +} + llvm::DIType *CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty, llvm::DIFile *Unit) { ObjCInterfaceDecl *ID = Ty->getDecl(); @@ -3303,6 +3347,15 @@ void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) { getLineNumber(USD.getLocation())); } +void CGDebugInfo::EmitImportDecl(const ImportDecl &ID) { + auto *Reader = CGM.getContext().getExternalSource(); + auto Info = Reader->getSourceDescriptor(*ID.getImportedModule()); + DBuilder.createImportedDeclaration( + getCurrentContextDescriptor(cast<Decl>(ID.getDeclContext())), + getOrCreateModuleRef(Info), + getLineNumber(ID.getLocation())); +} + llvm::DIImportedEntity * CGDebugInfo::EmitNamespaceAlias(const NamespaceAliasDecl &NA) { if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo) diff --git a/lib/CodeGen/CGDebugInfo.h b/lib/CodeGen/CGDebugInfo.h index 8509e0770db6..10d3b0d9ab02 100644 --- a/lib/CodeGen/CGDebugInfo.h +++ b/lib/CodeGen/CGDebugInfo.h @@ -83,6 +83,9 @@ class CGDebugInfo { /// which may change. llvm::SmallVector<ObjCInterfaceCacheEntry, 32> ObjCInterfaceCache; + /// \brief Cache of references to AST files such as PCHs or modules. + llvm::DenseMap<uint64_t, llvm::DIModule *> ModuleRefCache; + /// \brief list of interfaces we want to keep even if orphaned. std::vector<void *> RetainedTypes; @@ -289,6 +292,9 @@ public: /// \brief Emit C++ using declaration. void EmitUsingDecl(const UsingDecl &UD); + /// \brief Emit an @import declaration. + void EmitImportDecl(const ImportDecl &ID); + /// \brief Emit C++ namespace alias. llvm::DIImportedEntity *EmitNamespaceAlias(const NamespaceAliasDecl &NA); @@ -344,6 +350,10 @@ private: /// necessary. llvm::DIType *getOrCreateType(QualType Ty, llvm::DIFile *Fg); + /// \brief Get a reference to a clang module. + llvm::DIModule * + getOrCreateModuleRef(ExternalASTSource::ASTSourceDescriptor Mod); + /// \brief Get the type from the cache or create a new /// partial type if necessary. llvm::DIType *getOrCreateLimitedType(const RecordType *Ty, llvm::DIFile *F); diff --git a/lib/CodeGen/CGDecl.cpp b/lib/CodeGen/CGDecl.cpp index 07dbce4252fe..839c2e474ca3 100644 --- a/lib/CodeGen/CGDecl.cpp +++ b/lib/CodeGen/CGDecl.cpp @@ -579,9 +579,9 @@ static bool isAccessedBy(const VarDecl &var, const Stmt *s) { } } - for (Stmt::const_child_range children = s->children(); children; ++children) - // children might be null; as in missing decl or conditional of an if-stmt. - if ((*children) && isAccessedBy(var, *children)) + for (const Stmt *SubStmt : s->children()) + // SubStmt might be null; as in missing decl or conditional of an if-stmt. + if (SubStmt && isAccessedBy(var, SubStmt)) return true; return false; @@ -1074,8 +1074,8 @@ static bool isCapturedBy(const VarDecl &var, const Expr *e) { return false; } - for (Stmt::const_child_range children = e->children(); children; ++children) - if (isCapturedBy(var, cast<Expr>(*children))) + for (const Stmt *SubStmt : e->children()) + if (isCapturedBy(var, cast<Expr>(SubStmt))) return true; return false; diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp index 1a76afaf1158..175763c4e815 100644 --- a/lib/CodeGen/CGExpr.cpp +++ b/lib/CodeGen/CGExpr.cpp @@ -2403,8 +2403,7 @@ void CodeGenFunction::EmitTrapCheck(llvm::Value *Checked) { TrapBB = createBasicBlock("trap"); Builder.CreateCondBr(Checked, Cont, TrapBB); EmitBlock(TrapBB); - llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap); - llvm::CallInst *TrapCall = Builder.CreateCall(F, {}); + llvm::CallInst *TrapCall = EmitTrapCall(llvm::Intrinsic::trap); TrapCall->setDoesNotReturn(); TrapCall->setDoesNotThrow(); Builder.CreateUnreachable(); @@ -2415,6 +2414,18 @@ void CodeGenFunction::EmitTrapCheck(llvm::Value *Checked) { EmitBlock(Cont); } +llvm::CallInst *CodeGenFunction::EmitTrapCall(llvm::Intrinsic::ID IntrID) { + llvm::CallInst *TrapCall = + Builder.CreateCall(CGM.getIntrinsic(IntrID), {}); + + if (!CGM.getCodeGenOpts().TrapFuncName.empty()) + TrapCall->addAttribute(llvm::AttributeSet::FunctionIndex, + "trap-func-name", + CGM.getCodeGenOpts().TrapFuncName); + + return TrapCall; +} + /// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an /// array to pointer, return the array subexpression. static const Expr *isSimpleArrayDecayOperand(const Expr *E) { diff --git a/lib/CodeGen/CGExprCXX.cpp b/lib/CodeGen/CGExprCXX.cpp index f0f706d7b957..c7adccaeeaea 100644 --- a/lib/CodeGen/CGExprCXX.cpp +++ b/lib/CodeGen/CGExprCXX.cpp @@ -1548,7 +1548,8 @@ namespace { // The size of an element, multiplied by the number of elements. llvm::Value *Size = llvm::ConstantInt::get(SizeTy, ElementTypeSize.getQuantity()); - Size = CGF.Builder.CreateMul(Size, NumElements); + if (NumElements) + Size = CGF.Builder.CreateMul(Size, NumElements); // Plus the size of the cookie if applicable. if (!CookieSize.isZero()) { diff --git a/lib/CodeGen/CGExprConstant.cpp b/lib/CodeGen/CGExprConstant.cpp index acfb9b6dbb25..a15c151d6f9d 100644 --- a/lib/CodeGen/CGExprConstant.cpp +++ b/lib/CodeGen/CGExprConstant.cpp @@ -1452,7 +1452,7 @@ CodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) { // A member function pointer. if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl)) - return getCXXABI().EmitMemberPointer(method); + return getCXXABI().EmitMemberFunctionPointer(method); // Otherwise, a member data pointer. uint64_t fieldOffset = getContext().getFieldOffset(decl); diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp index 330a0dffb244..c73f1189314e 100644 --- a/lib/CodeGen/CGExprScalar.cpp +++ b/lib/CodeGen/CGExprScalar.cpp @@ -16,6 +16,7 @@ #include "CGDebugInfo.h" #include "CGObjCRuntime.h" #include "CodeGenModule.h" +#include "TargetInfo.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/RecordLayout.h" @@ -2037,6 +2038,13 @@ ScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr( return size; } + } else if (E->getKind() == UETT_OpenMPRequiredSimdAlign) { + auto Alignment = + CGF.getContext() + .toCharUnitsFromBits(CGF.getContext().getOpenMPDefaultSimdAlign( + E->getTypeOfArgument()->getPointeeType())) + .getQuantity(); + return llvm::ConstantInt::get(CGF.SizeTy, Alignment); } // If this isn't sizeof(vla), the result must be constant; use the constant diff --git a/lib/CodeGen/CGObjC.cpp b/lib/CodeGen/CGObjC.cpp index 9981fccb3e9d..747326e4c5bc 100644 --- a/lib/CodeGen/CGObjC.cpp +++ b/lib/CodeGen/CGObjC.cpp @@ -55,13 +55,15 @@ llvm::Value *CodeGenFunction::EmitObjCStringLiteral(const ObjCStringLiteral *E) /// EmitObjCBoxedExpr - This routine generates code to call /// the appropriate expression boxing method. This will either be -/// one of +[NSNumber numberWith<Type>:], or +[NSString stringWithUTF8String:]. +/// one of +[NSNumber numberWith<Type>:], or +[NSString stringWithUTF8String:], +/// or [NSValue valueWithBytes:objCType:]. /// llvm::Value * CodeGenFunction::EmitObjCBoxedExpr(const ObjCBoxedExpr *E) { // Generate the correct selector for this literal's concrete type. // Get the method. const ObjCMethodDecl *BoxingMethod = E->getBoxingMethod(); + const Expr *SubExpr = E->getSubExpr(); assert(BoxingMethod && "BoxingMethod is null"); assert(BoxingMethod->isClassMethod() && "BoxingMethod must be a class method"); Selector Sel = BoxingMethod->getSelector(); @@ -74,7 +76,35 @@ CodeGenFunction::EmitObjCBoxedExpr(const ObjCBoxedExpr *E) { llvm::Value *Receiver = Runtime.GetClass(*this, ClassDecl); CallArgList Args; - EmitCallArgs(Args, BoxingMethod, E->arg_begin(), E->arg_end()); + const ParmVarDecl *ArgDecl = *BoxingMethod->param_begin(); + QualType ArgQT = ArgDecl->getType().getUnqualifiedType(); + + // ObjCBoxedExpr supports boxing of structs and unions + // via [NSValue valueWithBytes:objCType:] + const QualType ValueType(SubExpr->getType().getCanonicalType()); + if (ValueType->isObjCBoxableRecordType()) { + // Emit CodeGen for first parameter + // and cast value to correct type + llvm::Value *Temporary = CreateMemTemp(SubExpr->getType()); + EmitAnyExprToMem(SubExpr, Temporary, Qualifiers(), /*isInit*/ true); + llvm::Value *BitCast = Builder.CreateBitCast(Temporary, + ConvertType(ArgQT)); + Args.add(RValue::get(BitCast), ArgQT); + + // Create char array to store type encoding + std::string Str; + getContext().getObjCEncodingForType(ValueType, Str); + llvm::GlobalVariable *GV = CGM.GetAddrOfConstantCString(Str); + + // Cast type encoding to correct type + const ParmVarDecl *EncodingDecl = BoxingMethod->parameters()[1]; + QualType EncodingQT = EncodingDecl->getType().getUnqualifiedType(); + llvm::Value *Cast = Builder.CreateBitCast(GV, ConvertType(EncodingQT)); + + Args.add(RValue::get(Cast), EncodingQT); + } else { + Args.add(EmitAnyExpr(SubExpr), ArgQT); + } RValue result = Runtime.GenerateMessageSend( *this, ReturnValueSlot(), BoxingMethod->getReturnType(), Sel, Receiver, diff --git a/lib/CodeGen/CGOpenMPRuntime.cpp b/lib/CodeGen/CGOpenMPRuntime.cpp index 3161af36c23e..534d148209ba 100644 --- a/lib/CodeGen/CGOpenMPRuntime.cpp +++ b/lib/CodeGen/CGOpenMPRuntime.cpp @@ -45,14 +45,14 @@ public: CGOpenMPRegionInfo(const CapturedStmt &CS, const CGOpenMPRegionKind RegionKind, - const RegionCodeGenTy &CodeGen) + const RegionCodeGenTy &CodeGen, OpenMPDirectiveKind Kind) : CGCapturedStmtInfo(CS, CR_OpenMP), RegionKind(RegionKind), - CodeGen(CodeGen) {} + CodeGen(CodeGen), Kind(Kind) {} CGOpenMPRegionInfo(const CGOpenMPRegionKind RegionKind, - const RegionCodeGenTy &CodeGen) - : CGCapturedStmtInfo(CR_OpenMP), RegionKind(RegionKind), - CodeGen(CodeGen) {} + const RegionCodeGenTy &CodeGen, OpenMPDirectiveKind Kind) + : CGCapturedStmtInfo(CR_OpenMP), RegionKind(RegionKind), CodeGen(CodeGen), + Kind(Kind) {} /// \brief Get a variable or parameter for storing global thread id /// inside OpenMP construct. @@ -67,6 +67,8 @@ public: CGOpenMPRegionKind getRegionKind() const { return RegionKind; } + OpenMPDirectiveKind getDirectiveKind() const { return Kind; } + static bool classof(const CGCapturedStmtInfo *Info) { return Info->getKind() == CR_OpenMP; } @@ -74,14 +76,16 @@ public: protected: CGOpenMPRegionKind RegionKind; const RegionCodeGenTy &CodeGen; + OpenMPDirectiveKind Kind; }; /// \brief API for captured statement code generation in OpenMP constructs. class CGOpenMPOutlinedRegionInfo : public CGOpenMPRegionInfo { public: CGOpenMPOutlinedRegionInfo(const CapturedStmt &CS, const VarDecl *ThreadIDVar, - const RegionCodeGenTy &CodeGen) - : CGOpenMPRegionInfo(CS, ParallelOutlinedRegion, CodeGen), + const RegionCodeGenTy &CodeGen, + OpenMPDirectiveKind Kind) + : CGOpenMPRegionInfo(CS, ParallelOutlinedRegion, CodeGen, Kind), ThreadIDVar(ThreadIDVar) { assert(ThreadIDVar != nullptr && "No ThreadID in OpenMP region."); } @@ -109,8 +113,9 @@ class CGOpenMPTaskOutlinedRegionInfo : public CGOpenMPRegionInfo { public: CGOpenMPTaskOutlinedRegionInfo(const CapturedStmt &CS, const VarDecl *ThreadIDVar, - const RegionCodeGenTy &CodeGen) - : CGOpenMPRegionInfo(CS, TaskOutlinedRegion, CodeGen), + const RegionCodeGenTy &CodeGen, + OpenMPDirectiveKind Kind) + : CGOpenMPRegionInfo(CS, TaskOutlinedRegion, CodeGen, Kind), ThreadIDVar(ThreadIDVar) { assert(ThreadIDVar != nullptr && "No ThreadID in OpenMP region."); } @@ -141,8 +146,9 @@ private: class CGOpenMPInlinedRegionInfo : public CGOpenMPRegionInfo { public: CGOpenMPInlinedRegionInfo(CodeGenFunction::CGCapturedStmtInfo *OldCSI, - const RegionCodeGenTy &CodeGen) - : CGOpenMPRegionInfo(InlinedRegion, CodeGen), OldCSI(OldCSI), + const RegionCodeGenTy &CodeGen, + OpenMPDirectiveKind Kind) + : CGOpenMPRegionInfo(InlinedRegion, CodeGen, Kind), OldCSI(OldCSI), OuterRegionInfo(dyn_cast_or_null<CGOpenMPRegionInfo>(OldCSI)) {} // \brief Retrieve the value of the context parameter. llvm::Value *getContextValue() const override { @@ -207,11 +213,12 @@ public: /// \param CodeGen Code generation sequence for combined directives. Includes /// a list of functions used for code generation of implicitly inlined /// regions. - InlinedOpenMPRegionRAII(CodeGenFunction &CGF, const RegionCodeGenTy &CodeGen) + InlinedOpenMPRegionRAII(CodeGenFunction &CGF, const RegionCodeGenTy &CodeGen, + OpenMPDirectiveKind Kind) : CGF(CGF) { // Start emission for the construct. CGF.CapturedStmtInfo = - new CGOpenMPInlinedRegionInfo(CGF.CapturedStmtInfo, CodeGen); + new CGOpenMPInlinedRegionInfo(CGF.CapturedStmtInfo, CodeGen, Kind); } ~InlinedOpenMPRegionRAII() { // Restore original CapturedStmtInfo only if we're done with code emission. @@ -273,29 +280,28 @@ void CGOpenMPRuntime::clear() { InternalVars.clear(); } -llvm::Value * -CGOpenMPRuntime::emitParallelOutlinedFunction(const OMPExecutableDirective &D, - const VarDecl *ThreadIDVar, - const RegionCodeGenTy &CodeGen) { +llvm::Value *CGOpenMPRuntime::emitParallelOutlinedFunction( + const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, + OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) { assert(ThreadIDVar->getType()->isPointerType() && "thread id variable must be of type kmp_int32 *"); const CapturedStmt *CS = cast<CapturedStmt>(D.getAssociatedStmt()); CodeGenFunction CGF(CGM, true); - CGOpenMPOutlinedRegionInfo CGInfo(*CS, ThreadIDVar, CodeGen); - CGF.CapturedStmtInfo = &CGInfo; + CGOpenMPOutlinedRegionInfo CGInfo(*CS, ThreadIDVar, CodeGen, InnermostKind); + CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo); return CGF.GenerateCapturedStmtFunction(*CS); } -llvm::Value * -CGOpenMPRuntime::emitTaskOutlinedFunction(const OMPExecutableDirective &D, - const VarDecl *ThreadIDVar, - const RegionCodeGenTy &CodeGen) { +llvm::Value *CGOpenMPRuntime::emitTaskOutlinedFunction( + const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, + OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) { assert(!ThreadIDVar->getType()->isPointerType() && "thread id variable must be of type kmp_int32 for tasks"); auto *CS = cast<CapturedStmt>(D.getAssociatedStmt()); CodeGenFunction CGF(CGM, true); - CGOpenMPTaskOutlinedRegionInfo CGInfo(*CS, ThreadIDVar, CodeGen); - CGF.CapturedStmtInfo = &CGInfo; + CGOpenMPTaskOutlinedRegionInfo CGInfo(*CS, ThreadIDVar, CodeGen, + InnermostKind); + CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo); return CGF.GenerateCapturedStmtFunction(*CS); } @@ -530,6 +536,14 @@ CGOpenMPRuntime::createRuntimeFunction(OpenMPRTLFunction Function) { RTLFn = CGM.CreateRuntimeFunction(FnTy, /*Name*/ "__kmpc_cancel_barrier"); break; } + case OMPRTL__kmpc_barrier: { + // Build void __kmpc_cancel_barrier(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, /*Name*/ "__kmpc_barrier"); + break; + } case OMPRTL__kmpc_for_static_fini: { // Build void __kmpc_for_static_fini(ident_t *loc, kmp_int32 global_tid); llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty}; @@ -781,6 +795,40 @@ CGOpenMPRuntime::createRuntimeFunction(OpenMPRTLFunction Function) { RTLFn = CGM.CreateRuntimeFunction(FnTy, "__kmpc_push_proc_bind"); break; } + case OMPRTL__kmpc_omp_task_with_deps: { + // Build kmp_int32 __kmpc_omp_task_with_deps(ident_t *, kmp_int32 gtid, + // kmp_task_t *new_task, kmp_int32 ndeps, kmp_depend_info_t *dep_list, + // kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list); + llvm::Type *TypeParams[] = { + getIdentTyPointerTy(), CGM.Int32Ty, CGM.VoidPtrTy, CGM.Int32Ty, + CGM.VoidPtrTy, CGM.Int32Ty, CGM.VoidPtrTy}; + llvm::FunctionType *FnTy = + llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg=*/false); + RTLFn = + CGM.CreateRuntimeFunction(FnTy, /*Name=*/"__kmpc_omp_task_with_deps"); + break; + } + case OMPRTL__kmpc_omp_wait_deps: { + // Build void __kmpc_omp_wait_deps(ident_t *, kmp_int32 gtid, + // kmp_int32 ndeps, kmp_depend_info_t *dep_list, kmp_int32 ndeps_noalias, + // kmp_depend_info_t *noalias_dep_list); + llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty, + CGM.Int32Ty, CGM.VoidPtrTy, + CGM.Int32Ty, CGM.VoidPtrTy}; + llvm::FunctionType *FnTy = + llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false); + RTLFn = CGM.CreateRuntimeFunction(FnTy, /*Name=*/"__kmpc_omp_wait_deps"); + break; + } + case OMPRTL__kmpc_cancellationpoint: { + // Build kmp_int32 __kmpc_cancellationpoint(ident_t *loc, kmp_int32 + // global_tid, kmp_int32 cncl_kind) + llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty, CGM.IntTy}; + llvm::FunctionType *FnTy = + llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false); + RTLFn = CGM.CreateRuntimeFunction(FnTy, "__kmpc_cancellationpoint"); + break; + } } return RTLFn; } @@ -1212,11 +1260,12 @@ void CGOpenMPRuntime::emitCriticalRegion(CodeGenFunction &CGF, CGF.EHStack.pushCleanup<CallEndCleanup<std::extent<decltype(Args)>::value>>( NormalAndEHCleanup, createRuntimeFunction(OMPRTL__kmpc_end_critical), llvm::makeArrayRef(Args)); - emitInlinedDirective(CGF, CriticalOpGen); + emitInlinedDirective(CGF, OMPD_critical, CriticalOpGen); } } static void emitIfStmt(CodeGenFunction &CGF, llvm::Value *IfCond, + OpenMPDirectiveKind Kind, const RegionCodeGenTy &BodyOpGen) { llvm::Value *CallBool = CGF.EmitScalarConversion( IfCond, @@ -1228,7 +1277,7 @@ static void emitIfStmt(CodeGenFunction &CGF, llvm::Value *IfCond, // Generate the branch (If-stmt) CGF.Builder.CreateCondBr(CallBool, ThenBlock, ContBlock); CGF.EmitBlock(ThenBlock); - CGF.CGM.getOpenMPRuntime().emitInlinedDirective(CGF, BodyOpGen); + CGF.CGM.getOpenMPRuntime().emitInlinedDirective(CGF, Kind, BodyOpGen); // Emit the rest of bblocks/branches CGF.EmitBranch(ContBlock); CGF.EmitBlock(ContBlock, true); @@ -1247,7 +1296,7 @@ void CGOpenMPRuntime::emitMasterRegion(CodeGenFunction &CGF, CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_master), Args); typedef CallEndCleanup<std::extent<decltype(Args)>::value> MasterCallEndCleanup; - emitIfStmt(CGF, IsMaster, [&](CodeGenFunction &CGF) -> void { + emitIfStmt(CGF, IsMaster, OMPD_master, [&](CodeGenFunction &CGF) -> void { CodeGenFunction::RunCleanupsScope Scope(CGF); CGF.EHStack.pushCleanup<MasterCallEndCleanup>( NormalAndEHCleanup, createRuntimeFunction(OMPRTL__kmpc_end_master), @@ -1280,7 +1329,7 @@ void CGOpenMPRuntime::emitTaskgroupRegion(CodeGenFunction &CGF, CGF.EHStack.pushCleanup<CallEndCleanup<std::extent<decltype(Args)>::value>>( NormalAndEHCleanup, createRuntimeFunction(OMPRTL__kmpc_end_taskgroup), llvm::makeArrayRef(Args)); - emitInlinedDirective(CGF, TaskgroupOpGen); + emitInlinedDirective(CGF, OMPD_taskgroup, TaskgroupOpGen); } } @@ -1376,7 +1425,7 @@ void CGOpenMPRuntime::emitSingleRegion(CodeGenFunction &CGF, CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_single), Args); typedef CallEndCleanup<std::extent<decltype(Args)>::value> SingleCallEndCleanup; - emitIfStmt(CGF, IsSingle, [&](CodeGenFunction &CGF) -> void { + emitIfStmt(CGF, IsSingle, OMPD_single, [&](CodeGenFunction &CGF) -> void { CodeGenFunction::RunCleanupsScope Scope(CGF); CGF.EHStack.pushCleanup<SingleCallEndCleanup>( NormalAndEHCleanup, createRuntimeFunction(OMPRTL__kmpc_end_single), @@ -1444,13 +1493,15 @@ void CGOpenMPRuntime::emitOrderedRegion(CodeGenFunction &CGF, CGF.EHStack.pushCleanup<CallEndCleanup<std::extent<decltype(Args)>::value>>( NormalAndEHCleanup, createRuntimeFunction(OMPRTL__kmpc_end_ordered), llvm::makeArrayRef(Args)); - emitInlinedDirective(CGF, OrderedOpGen); + emitInlinedDirective(CGF, OMPD_ordered, OrderedOpGen); } } void CGOpenMPRuntime::emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, - OpenMPDirectiveKind Kind) { + OpenMPDirectiveKind Kind, + bool CheckForCancel) { // Build call __kmpc_cancel_barrier(loc, thread_id); + // Build call __kmpc_barrier(loc, thread_id); OpenMPLocationFlags Flags = OMP_IDENT_KMPC; if (Kind == OMPD_for) { Flags = @@ -1466,15 +1517,34 @@ void CGOpenMPRuntime::emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, } else { Flags = static_cast<OpenMPLocationFlags>(Flags | OMP_IDENT_BARRIER_IMPL); } - // Build call __kmpc_cancel_barrier(loc, thread_id); - // Replace __kmpc_barrier() function by __kmpc_cancel_barrier() because this - // one provides the same functionality and adds initial support for - // cancellation constructs introduced in OpenMP 4.0. __kmpc_cancel_barrier() - // is provided default by the runtime library so it safe to make such - // replacement. + // Build call __kmpc_cancel_barrier(loc, thread_id) or __kmpc_barrier(loc, + // thread_id); llvm::Value *Args[] = {emitUpdateLocation(CGF, Loc, Flags), getThreadID(CGF, Loc)}; - CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_cancel_barrier), Args); + if (auto *OMPRegionInfo = + dyn_cast_or_null<CGOpenMPRegionInfo>(CGF.CapturedStmtInfo)) { + auto CancelDestination = + CGF.getOMPCancelDestination(OMPRegionInfo->getDirectiveKind()); + if (CancelDestination.isValid()) { + auto *Result = CGF.EmitRuntimeCall( + createRuntimeFunction(OMPRTL__kmpc_cancel_barrier), Args); + if (CheckForCancel) { + // if (__kmpc_cancel_barrier()) { + // exit from construct; + // } + auto *ExitBB = CGF.createBasicBlock(".cancel.exit"); + auto *ContBB = CGF.createBasicBlock(".cancel.continue"); + auto *Cmp = CGF.Builder.CreateIsNotNull(Result); + CGF.Builder.CreateCondBr(Cmp, ExitBB, ContBB); + CGF.EmitBlock(ExitBB); + // exit from construct; + CGF.EmitBranchThroughCleanup(CancelDestination); + CGF.EmitBlock(ContBB, /*IsFinished=*/true); + } + return; + } + } + CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_barrier), Args); } /// \brief Schedule types for 'omp for' loops (these enumerators are taken from @@ -2009,11 +2079,12 @@ void CGOpenMPRuntime::emitTaskCall( CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, bool Tied, llvm::PointerIntPair<llvm::Value *, 1, bool> Final, llvm::Value *TaskFunction, QualType SharedsTy, llvm::Value *Shareds, - const Expr *IfCond, const ArrayRef<const Expr *> PrivateVars, - const ArrayRef<const Expr *> PrivateCopies, - const ArrayRef<const Expr *> FirstprivateVars, - const ArrayRef<const Expr *> FirstprivateCopies, - const ArrayRef<const Expr *> FirstprivateInits) { + const Expr *IfCond, ArrayRef<const Expr *> PrivateVars, + ArrayRef<const Expr *> PrivateCopies, + ArrayRef<const Expr *> FirstprivateVars, + ArrayRef<const Expr *> FirstprivateCopies, + ArrayRef<const Expr *> FirstprivateInits, + ArrayRef<std::pair<OpenMPDependClauseKind, const Expr *>> Dependences) { auto &C = CGM.getContext(); llvm::SmallVector<PrivateDataTy, 8> Privates; // Aggregate privates and sort them by the alignment. @@ -2169,12 +2240,11 @@ void CGOpenMPRuntime::emitTaskCall( }); (void)InitScope.Privatize(); // Emit initialization for single element. - auto *OldCapturedStmtInfo = CGF.CapturedStmtInfo; - CGF.CapturedStmtInfo = &CapturesInfo; + CodeGenFunction::CGCapturedStmtRAII CapInfoRAII( + CGF, &CapturesInfo); CGF.EmitAnyExprToMem(Init, DestElement, Init->getType().getQualifiers(), /*IsInitializer=*/false); - CGF.CapturedStmtInfo = OldCapturedStmtInfo; }); } } else { @@ -2183,11 +2253,9 @@ void CGOpenMPRuntime::emitTaskCall( return SharedRefLValue.getAddress(); }); (void)InitScope.Privatize(); - auto *OldCapturedStmtInfo = CGF.CapturedStmtInfo; - CGF.CapturedStmtInfo = &CapturesInfo; + CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CapturesInfo); CGF.EmitExprAsInit(Init, VD, PrivateLValue, /*capturedByInit=*/false); - CGF.CapturedStmtInfo = OldCapturedStmtInfo; } } else { CGF.EmitExprAsInit(Init, VD, PrivateLValue, /*capturedByInit=*/false); @@ -2209,35 +2277,139 @@ void CGOpenMPRuntime::emitTaskCall( CGF.EmitStoreOfScalar(CGF.Builder.CreatePointerBitCastOrAddrSpaceCast( DestructorFn, KmpRoutineEntryPtrTy), Destructor); + + // Process list of dependences. + llvm::Value *DependInfo = nullptr; + unsigned DependencesNumber = Dependences.size(); + if (!Dependences.empty()) { + // Dependence kind for RTL. + enum RTLDependenceKindTy { DepIn = 1, DepOut = 2, DepInOut = 3 }; + enum RTLDependInfoFieldsTy { BaseAddr, Len, Flags }; + RecordDecl *KmpDependInfoRD; + QualType FlagsTy = C.getIntTypeForBitwidth( + C.toBits(C.getTypeSizeInChars(C.BoolTy)), /*Signed=*/false); + llvm::Type *LLVMFlagsTy = CGF.ConvertTypeForMem(FlagsTy); + if (KmpDependInfoTy.isNull()) { + KmpDependInfoRD = C.buildImplicitRecord("kmp_depend_info"); + KmpDependInfoRD->startDefinition(); + addFieldToRecordDecl(C, KmpDependInfoRD, C.getIntPtrType()); + addFieldToRecordDecl(C, KmpDependInfoRD, C.getSizeType()); + addFieldToRecordDecl(C, KmpDependInfoRD, FlagsTy); + KmpDependInfoRD->completeDefinition(); + KmpDependInfoTy = C.getRecordType(KmpDependInfoRD); + } else { + KmpDependInfoRD = cast<RecordDecl>(KmpDependInfoTy->getAsTagDecl()); + } + // Define type kmp_depend_info[<Dependences.size()>]; + QualType KmpDependInfoArrayTy = C.getConstantArrayType( + KmpDependInfoTy, llvm::APInt(/*numBits=*/64, Dependences.size()), + ArrayType::Normal, /*IndexTypeQuals=*/0); + // kmp_depend_info[<Dependences.size()>] deps; + DependInfo = CGF.CreateMemTemp(KmpDependInfoArrayTy); + for (unsigned i = 0; i < DependencesNumber; ++i) { + auto Addr = CGF.EmitLValue(Dependences[i].second); + auto *Size = llvm::ConstantInt::get( + CGF.SizeTy, + C.getTypeSizeInChars(Dependences[i].second->getType()).getQuantity()); + auto Base = CGF.MakeNaturalAlignAddrLValue( + CGF.Builder.CreateStructGEP(/*Ty=*/nullptr, DependInfo, i), + KmpDependInfoTy); + // deps[i].base_addr = &<Dependences[i].second>; + auto BaseAddrLVal = CGF.EmitLValueForField( + Base, *std::next(KmpDependInfoRD->field_begin(), BaseAddr)); + CGF.EmitStoreOfScalar( + CGF.Builder.CreatePtrToInt(Addr.getAddress(), CGF.IntPtrTy), + BaseAddrLVal); + // deps[i].len = sizeof(<Dependences[i].second>); + auto LenLVal = CGF.EmitLValueForField( + Base, *std::next(KmpDependInfoRD->field_begin(), Len)); + CGF.EmitStoreOfScalar(Size, LenLVal); + // deps[i].flags = <Dependences[i].first>; + RTLDependenceKindTy DepKind; + switch (Dependences[i].first) { + case OMPC_DEPEND_in: + DepKind = DepIn; + break; + case OMPC_DEPEND_out: + DepKind = DepOut; + break; + case OMPC_DEPEND_inout: + DepKind = DepInOut; + break; + case OMPC_DEPEND_unknown: + llvm_unreachable("Unknown task dependence type"); + } + auto FlagsLVal = CGF.EmitLValueForField( + Base, *std::next(KmpDependInfoRD->field_begin(), Flags)); + CGF.EmitStoreOfScalar(llvm::ConstantInt::get(LLVMFlagsTy, DepKind), + FlagsLVal); + } + DependInfo = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast( + CGF.Builder.CreateStructGEP(/*Ty=*/nullptr, DependInfo, 0), + CGF.VoidPtrTy); + } + // NOTE: routine and part_id fields are intialized by __kmpc_omp_task_alloc() // libcall. // Build kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid, kmp_task_t // *new_task); + // Build kmp_int32 __kmpc_omp_task_with_deps(ident_t *, kmp_int32 gtid, + // kmp_task_t *new_task, kmp_int32 ndeps, kmp_depend_info_t *dep_list, + // kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list) if dependence + // list is not empty auto *ThreadID = getThreadID(CGF, Loc); - llvm::Value *TaskArgs[] = {emitUpdateLocation(CGF, Loc), ThreadID, NewTask}; - auto &&ThenCodeGen = [this, &TaskArgs](CodeGenFunction &CGF) { + auto *UpLoc = emitUpdateLocation(CGF, Loc); + llvm::Value *TaskArgs[] = {UpLoc, ThreadID, NewTask}; + llvm::Value *DepTaskArgs[] = { + UpLoc, + ThreadID, + NewTask, + DependInfo ? CGF.Builder.getInt32(DependencesNumber) : nullptr, + DependInfo, + DependInfo ? CGF.Builder.getInt32(0) : nullptr, + DependInfo ? llvm::ConstantPointerNull::get(CGF.VoidPtrTy) : nullptr}; + auto &&ThenCodeGen = [this, DependInfo, &TaskArgs, + &DepTaskArgs](CodeGenFunction &CGF) { // TODO: add check for untied tasks. - CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_omp_task), TaskArgs); + CGF.EmitRuntimeCall( + createRuntimeFunction(DependInfo ? OMPRTL__kmpc_omp_task_with_deps + : OMPRTL__kmpc_omp_task), + DependInfo ? makeArrayRef(DepTaskArgs) : makeArrayRef(TaskArgs)); }; typedef CallEndCleanup<std::extent<decltype(TaskArgs)>::value> IfCallEndCleanup; - auto &&ElseCodeGen = - [this, &TaskArgs, ThreadID, NewTaskNewTaskTTy, TaskEntry]( - CodeGenFunction &CGF) { - CodeGenFunction::RunCleanupsScope LocalScope(CGF); - CGF.EmitRuntimeCall( - createRuntimeFunction(OMPRTL__kmpc_omp_task_begin_if0), TaskArgs); - // Build void __kmpc_omp_task_complete_if0(ident_t *, kmp_int32 gtid, - // kmp_task_t *new_task); - CGF.EHStack.pushCleanup<IfCallEndCleanup>( - NormalAndEHCleanup, - createRuntimeFunction(OMPRTL__kmpc_omp_task_complete_if0), - llvm::makeArrayRef(TaskArgs)); - - // Call proxy_task_entry(gtid, new_task); - llvm::Value *OutlinedFnArgs[] = {ThreadID, NewTaskNewTaskTTy}; - CGF.EmitCallOrInvoke(TaskEntry, OutlinedFnArgs); - }; + llvm::Value *DepWaitTaskArgs[] = { + UpLoc, + ThreadID, + DependInfo ? CGF.Builder.getInt32(DependencesNumber) : nullptr, + DependInfo, + DependInfo ? CGF.Builder.getInt32(0) : nullptr, + DependInfo ? llvm::ConstantPointerNull::get(CGF.VoidPtrTy) : nullptr}; + auto &&ElseCodeGen = [this, &TaskArgs, ThreadID, NewTaskNewTaskTTy, TaskEntry, + DependInfo, &DepWaitTaskArgs](CodeGenFunction &CGF) { + CodeGenFunction::RunCleanupsScope LocalScope(CGF); + // Build void __kmpc_omp_wait_deps(ident_t *, kmp_int32 gtid, + // kmp_int32 ndeps, kmp_depend_info_t *dep_list, kmp_int32 + // ndeps_noalias, kmp_depend_info_t *noalias_dep_list); if dependence info + // is specified. + if (DependInfo) + CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_omp_wait_deps), + DepWaitTaskArgs); + // Build void __kmpc_omp_task_begin_if0(ident_t *, kmp_int32 gtid, + // kmp_task_t *new_task); + CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_omp_task_begin_if0), + TaskArgs); + // Build void __kmpc_omp_task_complete_if0(ident_t *, kmp_int32 gtid, + // kmp_task_t *new_task); + CGF.EHStack.pushCleanup<IfCallEndCleanup>( + NormalAndEHCleanup, + createRuntimeFunction(OMPRTL__kmpc_omp_task_complete_if0), + llvm::makeArrayRef(TaskArgs)); + + // Call proxy_task_entry(gtid, new_task); + llvm::Value *OutlinedFnArgs[] = {ThreadID, NewTaskNewTaskTTy}; + CGF.EmitCallOrInvoke(TaskEntry, OutlinedFnArgs); + }; if (IfCond) { emitOMPIfClause(CGF, IfCond, ThenCodeGen, ElseCodeGen); } else { @@ -2545,8 +2717,60 @@ void CGOpenMPRuntime::emitTaskwaitCall(CodeGenFunction &CGF, } void CGOpenMPRuntime::emitInlinedDirective(CodeGenFunction &CGF, + OpenMPDirectiveKind InnerKind, const RegionCodeGenTy &CodeGen) { - InlinedOpenMPRegionRAII Region(CGF, CodeGen); + InlinedOpenMPRegionRAII Region(CGF, CodeGen, InnerKind); CGF.CapturedStmtInfo->EmitBody(CGF, /*S=*/nullptr); } +void CGOpenMPRuntime::emitCancellationPointCall( + CodeGenFunction &CGF, SourceLocation Loc, + OpenMPDirectiveKind CancelRegion) { + // Build call kmp_int32 OMPRTL__kmpc_cancellationpoint(ident_t *loc, kmp_int32 + // global_tid, kmp_int32 cncl_kind); + enum { + CancelNoreq = 0, + CancelParallel = 1, + CancelLoop = 2, + CancelSections = 3, + CancelTaskgroup = 4 + } CancelKind = CancelNoreq; + if (CancelRegion == OMPD_parallel) + CancelKind = CancelParallel; + else if (CancelRegion == OMPD_for) + CancelKind = CancelLoop; + else if (CancelRegion == OMPD_sections) + CancelKind = CancelSections; + else { + assert(CancelRegion == OMPD_taskgroup); + CancelKind = CancelTaskgroup; + } + if (auto *OMPRegionInfo = + dyn_cast_or_null<CGOpenMPRegionInfo>(CGF.CapturedStmtInfo)) { + auto CancelDest = + CGF.getOMPCancelDestination(OMPRegionInfo->getDirectiveKind()); + if (CancelDest.isValid()) { + llvm::Value *Args[] = {emitUpdateLocation(CGF, Loc), + getThreadID(CGF, Loc), + CGF.Builder.getInt32(CancelKind)}; + // Ignore return result until untied tasks are supported. + auto *Result = CGF.EmitRuntimeCall( + createRuntimeFunction(OMPRTL__kmpc_cancellationpoint), Args); + // if (__kmpc_cancellationpoint()) { + // __kmpc_cancel_barrier(); + // exit from construct; + // } + auto *ExitBB = CGF.createBasicBlock(".cancel.exit"); + auto *ContBB = CGF.createBasicBlock(".cancel.continue"); + auto *Cmp = CGF.Builder.CreateIsNotNull(Result); + CGF.Builder.CreateCondBr(Cmp, ExitBB, ContBB); + CGF.EmitBlock(ExitBB); + // __kmpc_cancel_barrier(); + emitBarrierCall(CGF, Loc, OMPD_unknown, /*CheckForCancel=*/false); + // exit from construct; + CGF.EmitBranchThroughCleanup(CancelDest); + CGF.EmitBlock(ContBB, /*IsFinished=*/true); + } + } +} + diff --git a/lib/CodeGen/CGOpenMPRuntime.h b/lib/CodeGen/CGOpenMPRuntime.h index d1efde25d096..76bb3ae35931 100644 --- a/lib/CodeGen/CGOpenMPRuntime.h +++ b/lib/CodeGen/CGOpenMPRuntime.h @@ -68,6 +68,8 @@ private: // Call to kmp_int32 __kmpc_cancel_barrier(ident_t *loc, kmp_int32 // global_tid); OMPRTL__kmpc_cancel_barrier, + // Call to void __kmpc_barrier(ident_t *loc, kmp_int32 global_tid); + OMPRTL__kmpc_barrier, // Call to void __kmpc_for_static_fini(ident_t *loc, kmp_int32 global_tid); OMPRTL__kmpc_for_static_fini, // Call to void __kmpc_serialized_parallel(ident_t *loc, kmp_int32 @@ -138,6 +140,17 @@ private: // Call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid, // int proc_bind); OMPRTL__kmpc_push_proc_bind, + // Call to kmp_int32 __kmpc_omp_task_with_deps(ident_t *loc_ref, kmp_int32 + // gtid, kmp_task_t * new_task, kmp_int32 ndeps, kmp_depend_info_t + // *dep_list, kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list); + OMPRTL__kmpc_omp_task_with_deps, + // Call to void __kmpc_omp_wait_deps(ident_t *loc_ref, kmp_int32 + // gtid, kmp_int32 ndeps, kmp_depend_info_t *dep_list, kmp_int32 + // ndeps_noalias, kmp_depend_info_t *noalias_dep_list); + OMPRTL__kmpc_omp_wait_deps, + // Call to kmp_int32 __kmpc_cancellationpoint(ident_t *loc, kmp_int32 + // global_tid, kmp_int32 cncl_kind); + OMPRTL__kmpc_cancellationpoint, }; /// \brief Values for bit flags used in the ident_t to describe the fields. @@ -249,6 +262,16 @@ private: /// deconstructors of firstprivate C++ objects */ /// } kmp_task_t; QualType KmpTaskTQTy; + /// \brief Type typedef struct kmp_depend_info { + /// kmp_intptr_t base_addr; + /// size_t len; + /// struct { + /// bool in:1; + /// bool out:1; + /// } flags; + /// } kmp_depend_info_t; + QualType KmpDependInfoTy; + /// \brief Build type kmp_routine_entry_t (if not built yet). void emitKmpRoutineEntryT(QualType KmpInt32Ty); @@ -341,22 +364,25 @@ public: /// kmp_int32 BoundID, struct context_vars*). /// \param D OpenMP directive. /// \param ThreadIDVar Variable for thread id in the current OpenMP region. + /// \param InnermostKind Kind of innermost directive (for simple directives it + /// is a directive itself, for combined - its innermost directive). /// \param CodeGen Code generation sequence for the \a D directive. - virtual llvm::Value * - emitParallelOutlinedFunction(const OMPExecutableDirective &D, - const VarDecl *ThreadIDVar, - const RegionCodeGenTy &CodeGen); + virtual llvm::Value *emitParallelOutlinedFunction( + const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, + OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen); /// \brief Emits outlined function for the OpenMP task directive \a D. This /// outlined function has type void(*)(kmp_int32 ThreadID, kmp_int32 /// PartID, struct context_vars*). /// \param D OpenMP directive. /// \param ThreadIDVar Variable for thread id in the current OpenMP region. + /// \param InnermostKind Kind of innermost directive (for simple directives it + /// is a directive itself, for combined - its innermost directive). /// \param CodeGen Code generation sequence for the \a D directive. /// - virtual llvm::Value *emitTaskOutlinedFunction(const OMPExecutableDirective &D, - const VarDecl *ThreadIDVar, - const RegionCodeGenTy &CodeGen); + virtual llvm::Value *emitTaskOutlinedFunction( + const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, + OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen); /// \brief Cleans up references to the objects in finished function. /// @@ -423,9 +449,12 @@ public: /// \brief Emit an implicit/explicit barrier for OpenMP threads. /// \param Kind Directive for which this implicit barrier call must be /// generated. Must be OMPD_barrier for explicit barrier generation. + /// \param CheckForCancel true if check for possible cancellation must be + /// performed, false otherwise. /// virtual void emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, - OpenMPDirectiveKind Kind); + OpenMPDirectiveKind Kind, + bool CheckForCancel = true); /// \brief Check if the specified \a ScheduleKind is static non-chunked. /// This kind of worksharing directive is emitted without outer loop. @@ -580,7 +609,7 @@ public: /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32 /// /*part_id*/, captured_struct */*__context*/); /// \param SharedsTy A type which contains references the shared variables. - /// \param Shareds Context with the list of shared variables from the \a + /// \param Shareds Context with the list of shared variables from the \p /// TaskFunction. /// \param IfCond Not a nullptr if 'if' clause was specified, nullptr /// otherwise. @@ -595,21 +624,26 @@ public: /// \param FirstprivateInits List of references to auto generated variables /// used for initialization of a single array element. Used if firstprivate /// variable is of array type. - virtual void emitTaskCall(CodeGenFunction &CGF, SourceLocation Loc, - const OMPExecutableDirective &D, bool Tied, - llvm::PointerIntPair<llvm::Value *, 1, bool> Final, - llvm::Value *TaskFunction, QualType SharedsTy, - llvm::Value *Shareds, const Expr *IfCond, - const ArrayRef<const Expr *> PrivateVars, - const ArrayRef<const Expr *> PrivateCopies, - const ArrayRef<const Expr *> FirstprivateVars, - const ArrayRef<const Expr *> FirstprivateCopies, - const ArrayRef<const Expr *> FirstprivateInits); + /// \param Dependences List of dependences for the 'task' construct, including + /// original expression and dependency type. + virtual void emitTaskCall( + CodeGenFunction &CGF, SourceLocation Loc, const OMPExecutableDirective &D, + bool Tied, llvm::PointerIntPair<llvm::Value *, 1, bool> Final, + llvm::Value *TaskFunction, QualType SharedsTy, llvm::Value *Shareds, + const Expr *IfCond, ArrayRef<const Expr *> PrivateVars, + ArrayRef<const Expr *> PrivateCopies, + ArrayRef<const Expr *> FirstprivateVars, + ArrayRef<const Expr *> FirstprivateCopies, + ArrayRef<const Expr *> FirstprivateInits, + ArrayRef<std::pair<OpenMPDependClauseKind, const Expr *>> Dependences); /// \brief Emit code for the directive that does not require outlining. /// + /// \param InnermostKind Kind of innermost directive (for simple directives it + /// is a directive itself, for combined - its innermost directive). /// \param CodeGen Code generation sequence for the \a D directive. virtual void emitInlinedDirective(CodeGenFunction &CGF, + OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen); /// \brief Emit a code for reduction clause. Next code should be emitted for /// reduction: @@ -656,6 +690,14 @@ public: /// \brief Emit code for 'taskwait' directive. virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc); + + /// \brief Emit code for 'cancellation point' construct. + /// \param CancelRegion Region kind for which the cancellation point must be + /// emitted. + /// + virtual void emitCancellationPointCall(CodeGenFunction &CGF, + SourceLocation Loc, + OpenMPDirectiveKind CancelRegion); }; } // namespace CodeGen diff --git a/lib/CodeGen/CGStmt.cpp b/lib/CodeGen/CGStmt.cpp index 9286f0358926..a12f29534bfe 100644 --- a/lib/CodeGen/CGStmt.cpp +++ b/lib/CodeGen/CGStmt.cpp @@ -240,6 +240,12 @@ void CodeGenFunction::EmitStmt(const Stmt *S) { case Stmt::OMPTeamsDirectiveClass: EmitOMPTeamsDirective(cast<OMPTeamsDirective>(*S)); break; + case Stmt::OMPCancellationPointDirectiveClass: + EmitOMPCancellationPointDirective(cast<OMPCancellationPointDirective>(*S)); + break; + case Stmt::OMPCancelDirectiveClass: + EmitOMPCancelDirective(cast<OMPCancelDirective>(*S)); + break; } } @@ -2149,7 +2155,7 @@ CodeGenFunction::EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K) { // Emit the CapturedDecl CodeGenFunction CGF(CGM, true); - CGF.CapturedStmtInfo = new CGCapturedStmtInfo(S, K); + CGCapturedStmtRAII CapInfoRAII(CGF, new CGCapturedStmtInfo(S, K)); llvm::Function *F = CGF.GenerateCapturedStmtFunction(S); delete CGF.CapturedStmtInfo; diff --git a/lib/CodeGen/CGStmtOpenMP.cpp b/lib/CodeGen/CGStmtOpenMP.cpp index 5e94d56feb5f..b021c1275318 100644 --- a/lib/CodeGen/CGStmtOpenMP.cpp +++ b/lib/CodeGen/CGStmtOpenMP.cpp @@ -451,11 +451,12 @@ void CodeGenFunction::EmitOMPReductionClauseFinal( static void emitCommonOMPParallelDirective(CodeGenFunction &CGF, const OMPExecutableDirective &S, + OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) { auto CS = cast<CapturedStmt>(S.getAssociatedStmt()); auto CapturedStruct = CGF.GenerateCapturedStmtArgument(*CS); auto OutlinedFn = CGF.CGM.getOpenMPRuntime().emitParallelOutlinedFunction( - S, *CS->getCapturedDecl()->param_begin(), CodeGen); + S, *CS->getCapturedDecl()->param_begin(), InnermostKind, CodeGen); if (auto C = S.getSingleClause(OMPC_num_threads)) { CodeGenFunction::RunCleanupsScope NumThreadsScope(CGF); auto NumThreadsClause = cast<OMPNumThreadsClause>(C); @@ -502,10 +503,11 @@ void CodeGenFunction::EmitOMPParallelDirective(const OMPParallelDirective &S) { CGF.CGM.getOpenMPRuntime().emitBarrierCall(CGF, S.getLocStart(), OMPD_unknown); }; - emitCommonOMPParallelDirective(*this, S, CodeGen); + emitCommonOMPParallelDirective(*this, S, OMPD_parallel, CodeGen); } -void CodeGenFunction::EmitOMPLoopBody(const OMPLoopDirective &D) { +void CodeGenFunction::EmitOMPLoopBody(const OMPLoopDirective &D, + JumpDest LoopExit) { RunCleanupsScope BodyScope(*this); // Update counters values on current iteration. for (auto I : D.updates()) { @@ -521,7 +523,7 @@ void CodeGenFunction::EmitOMPLoopBody(const OMPLoopDirective &D) { // On a continue in the body, jump to the end. auto Continue = getJumpDestInCurrentScope("omp.body.continue"); - BreakContinueStack.push_back(BreakContinue(JumpDest(), Continue)); + BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); // Emit loop body. EmitStmt(D.getBody()); // The end (updates/cleanups). @@ -649,8 +651,10 @@ static void emitAlignedClause(CodeGenFunction &CGF, // 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()); + CGF.getContext() + .toCharUnitsFromBits(CGF.getContext().getOpenMPDefaultSimdAlign( + E->getType()->getPointeeType())) + .getQuantity(); } assert((Alignment == 0 || llvm::isPowerOf2_32(Alignment)) && "alignment is not power of 2"); @@ -825,10 +829,10 @@ void CodeGenFunction::EmitOMPSimdDirective(const OMPSimdDirective &S) { CGF.EmitOMPReductionClauseInit(S, LoopScope); HasLastprivateClause = CGF.EmitOMPLastprivateClauseInit(S, LoopScope); (void)LoopScope.Privatize(); - CGF.EmitOMPInnerLoop(S, LoopScope.requiresCleanups(), - S.getCond(), S.getInc(), + CGF.EmitOMPInnerLoop(S, LoopScope.requiresCleanups(), S.getCond(), + S.getInc(), [&S](CodeGenFunction &CGF) { - CGF.EmitOMPLoopBody(S); + CGF.EmitOMPLoopBody(S, JumpDest()); CGF.EmitStopPoint(&S); }, [](CodeGenFunction &) {}); @@ -845,7 +849,7 @@ void CodeGenFunction::EmitOMPSimdDirective(const OMPSimdDirective &S) { CGF.EmitBlock(ContBlock, true); } }; - CGM.getOpenMPRuntime().emitInlinedDirective(*this, CodeGen); + CGM.getOpenMPRuntime().emitInlinedDirective(*this, OMPD_simd, CodeGen); } void CodeGenFunction::EmitOMPForOuterLoop(OpenMPScheduleClauseKind ScheduleKind, @@ -977,19 +981,17 @@ void CodeGenFunction::EmitOMPForOuterLoop(OpenMPScheduleClauseKind ScheduleKind, } SourceLocation Loc = S.getLocStart(); - EmitOMPInnerLoop( - S, LoopScope.requiresCleanups(), S.getCond(), - S.getInc(), - [&S](CodeGenFunction &CGF) { - CGF.EmitOMPLoopBody(S); - CGF.EmitStopPoint(&S); - }, - [Ordered, IVSize, IVSigned, Loc](CodeGenFunction &CGF) { - if (Ordered) { - CGF.CGM.getOpenMPRuntime().emitForOrderedIterationEnd( - CGF, Loc, IVSize, IVSigned); - } - }); + EmitOMPInnerLoop(S, LoopScope.requiresCleanups(), S.getCond(), S.getInc(), + [&S, LoopExit](CodeGenFunction &CGF) { + CGF.EmitOMPLoopBody(S, LoopExit); + CGF.EmitStopPoint(&S); + }, + [Ordered, IVSize, IVSigned, Loc](CodeGenFunction &CGF) { + if (Ordered) { + CGF.CGM.getOpenMPRuntime().emitForOrderedIterationEnd( + CGF, Loc, IVSize, IVSigned); + } + }); EmitBlock(Continue.getBlock()); BreakContinueStack.pop_back(); @@ -1138,6 +1140,7 @@ bool CodeGenFunction::EmitOMPWorksharingLoop(const OMPLoopDirective &S) { RT.emitForInit(*this, S.getLocStart(), ScheduleKind, IVSize, IVSigned, Ordered, IL.getAddress(), LB.getAddress(), UB.getAddress(), ST.getAddress()); + auto LoopExit = getJumpDestInCurrentScope(createBasicBlock("omp.loop.exit")); // UB = min(UB, GlobalUB); EmitIgnoredExpr(S.getEnsureUpperBound()); // IV = LB; @@ -1145,11 +1148,12 @@ bool CodeGenFunction::EmitOMPWorksharingLoop(const OMPLoopDirective &S) { // while (idx <= UB) { BODY; ++idx; } EmitOMPInnerLoop(S, LoopScope.requiresCleanups(), S.getCond(), S.getInc(), - [&S](CodeGenFunction &CGF) { - CGF.EmitOMPLoopBody(S); + [&S, LoopExit](CodeGenFunction &CGF) { + CGF.EmitOMPLoopBody(S, LoopExit); CGF.EmitStopPoint(&S); }, [](CodeGenFunction &) {}); + EmitBlock(LoopExit.getBlock()); // Tell the runtime we are done. RT.emitForStaticFinish(*this, S.getLocStart()); } else { @@ -1183,7 +1187,7 @@ void CodeGenFunction::EmitOMPForDirective(const OMPForDirective &S) { auto &&CodeGen = [&S, &HasLastprivates](CodeGenFunction &CGF) { HasLastprivates = CGF.EmitOMPWorksharingLoop(S); }; - CGM.getOpenMPRuntime().emitInlinedDirective(*this, CodeGen); + CGM.getOpenMPRuntime().emitInlinedDirective(*this, OMPD_for, CodeGen); // Emit an implicit barrier at the end. if (!S.getSingleClause(OMPC_nowait) || HasLastprivates) { @@ -1197,7 +1201,7 @@ void CodeGenFunction::EmitOMPForSimdDirective(const OMPForSimdDirective &S) { auto &&CodeGen = [&S, &HasLastprivates](CodeGenFunction &CGF) { HasLastprivates = CGF.EmitOMPWorksharingLoop(S); }; - CGM.getOpenMPRuntime().emitInlinedDirective(*this, CodeGen); + CGM.getOpenMPRuntime().emitInlinedDirective(*this, OMPD_simd, CodeGen); // Emit an implicit barrier at the end. if (!S.getSingleClause(OMPC_nowait) || HasLastprivates) { @@ -1214,8 +1218,8 @@ static LValue createSectionLVal(CodeGenFunction &CGF, QualType Ty, return LVal; } -static OpenMPDirectiveKind emitSections(CodeGenFunction &CGF, - const OMPExecutableDirective &S) { +OpenMPDirectiveKind +CodeGenFunction::EmitSections(const OMPExecutableDirective &S) { auto *Stmt = cast<CapturedStmt>(S.getAssociatedStmt())->getCapturedStmt(); auto *CS = dyn_cast<CompoundStmt>(Stmt); if (CS && CS->size() > 1) { @@ -1263,12 +1267,13 @@ static OpenMPDirectiveKind emitSections(CodeGenFunction &CGF, CGF.EmitLoadOfLValue(IV, S.getLocStart()).getScalarVal(), ExitBB, CS->size()); unsigned CaseNumber = 0; - for (auto C = CS->children(); C; ++C, ++CaseNumber) { + for (auto *SubStmt : CS->children()) { auto CaseBB = CGF.createBasicBlock(".omp.sections.case"); CGF.EmitBlock(CaseBB); SwitchStmt->addCase(CGF.Builder.getInt32(CaseNumber), CaseBB); - CGF.EmitStmt(*C); + CGF.EmitStmt(SubStmt); CGF.EmitBranch(ExitBB); + ++CaseNumber; } CGF.EmitBlock(ExitBB, /*IsFinished=*/true); }; @@ -1311,15 +1316,15 @@ static OpenMPDirectiveKind emitSections(CodeGenFunction &CGF, CGF.EmitLoadOfScalar(IL, S.getLocStart()))); }; - CGF.CGM.getOpenMPRuntime().emitInlinedDirective(CGF, CodeGen); + CGM.getOpenMPRuntime().emitInlinedDirective(*this, OMPD_sections, CodeGen); // Emit barrier for lastprivates only if 'sections' directive has 'nowait' // clause. Otherwise the barrier will be generated by the codegen for the // directive. if (HasLastprivates && S.getSingleClause(OMPC_nowait)) { // Emit implicit barrier to synchronize threads and avoid data races on // initialization of firstprivate variables. - CGF.CGM.getOpenMPRuntime().emitBarrierCall(CGF, S.getLocStart(), - OMPD_unknown); + CGM.getOpenMPRuntime().emitBarrierCall(*this, S.getLocStart(), + OMPD_unknown); } return OMPD_sections; } @@ -1340,11 +1345,10 @@ static OpenMPDirectiveKind emitSections(CodeGenFunction &CGF, (void)SingleScope.Privatize(); CGF.EmitStmt(Stmt); - CGF.EnsureInsertPoint(); }; - CGF.CGM.getOpenMPRuntime().emitSingleRegion(CGF, CodeGen, S.getLocStart(), - llvm::None, llvm::None, - llvm::None, llvm::None); + CGM.getOpenMPRuntime().emitSingleRegion(*this, CodeGen, S.getLocStart(), + llvm::None, llvm::None, llvm::None, + llvm::None); // Emit barrier for firstprivates, lastprivates or reductions only if // 'sections' directive has 'nowait' clause. Otherwise the barrier will be // generated by the codegen for the directive. @@ -1352,15 +1356,14 @@ static OpenMPDirectiveKind emitSections(CodeGenFunction &CGF, S.getSingleClause(OMPC_nowait)) { // Emit implicit barrier to synchronize threads and avoid data races on // initialization of firstprivate variables. - CGF.CGM.getOpenMPRuntime().emitBarrierCall(CGF, S.getLocStart(), - OMPD_unknown); + CGM.getOpenMPRuntime().emitBarrierCall(*this, S.getLocStart(), OMPD_unknown); } return OMPD_single; } void CodeGenFunction::EmitOMPSectionsDirective(const OMPSectionsDirective &S) { LexicalScope Scope(*this, S.getSourceRange()); - OpenMPDirectiveKind EmittedAs = emitSections(*this, S); + OpenMPDirectiveKind EmittedAs = EmitSections(S); // Emit an implicit barrier at the end. if (!S.getSingleClause(OMPC_nowait)) { CGM.getOpenMPRuntime().emitBarrierCall(*this, S.getLocStart(), EmittedAs); @@ -1373,7 +1376,7 @@ void CodeGenFunction::EmitOMPSectionDirective(const OMPSectionDirective &S) { CGF.EmitStmt(cast<CapturedStmt>(S.getAssociatedStmt())->getCapturedStmt()); CGF.EnsureInsertPoint(); }; - CGM.getOpenMPRuntime().emitInlinedDirective(*this, CodeGen); + CGM.getOpenMPRuntime().emitInlinedDirective(*this, OMPD_section, CodeGen); } void CodeGenFunction::EmitOMPSingleDirective(const OMPSingleDirective &S) { @@ -1453,7 +1456,7 @@ void CodeGenFunction::EmitOMPParallelForDirective( CGF.CGM.getOpenMPRuntime().emitBarrierCall(CGF, S.getLocStart(), OMPD_parallel); }; - emitCommonOMPParallelDirective(*this, S, CodeGen); + emitCommonOMPParallelDirective(*this, S, OMPD_for, CodeGen); } void CodeGenFunction::EmitOMPParallelForSimdDirective( @@ -1470,7 +1473,7 @@ void CodeGenFunction::EmitOMPParallelForSimdDirective( CGF.CGM.getOpenMPRuntime().emitBarrierCall(CGF, S.getLocStart(), OMPD_parallel); }; - emitCommonOMPParallelDirective(*this, S, CodeGen); + emitCommonOMPParallelDirective(*this, S, OMPD_simd, CodeGen); } void CodeGenFunction::EmitOMPParallelSectionsDirective( @@ -1479,12 +1482,12 @@ void CodeGenFunction::EmitOMPParallelSectionsDirective( // directives: 'parallel' with 'sections' directive. LexicalScope Scope(*this, S.getSourceRange()); auto &&CodeGen = [&S](CodeGenFunction &CGF) { - (void)emitSections(CGF, S); + (void)CGF.EmitSections(S); // Emit implicit barrier at the end of parallel region. CGF.CGM.getOpenMPRuntime().emitBarrierCall(CGF, S.getLocStart(), OMPD_parallel); }; - emitCommonOMPParallelDirective(*this, S, CodeGen); + emitCommonOMPParallelDirective(*this, S, OMPD_sections, CodeGen); } void CodeGenFunction::EmitOMPTaskDirective(const OMPTaskDirective &S) { @@ -1531,6 +1534,15 @@ void CodeGenFunction::EmitOMPTaskDirective(const OMPTaskDirective &S) { ++IRef, ++IElemInitRef; } } + // Build list of dependences. + llvm::SmallVector<std::pair<OpenMPDependClauseKind, const Expr *>, 8> + Dependences; + for (auto &&I = S.getClausesOfKind(OMPC_depend); I; ++I) { + auto *C = cast<OMPDependClause>(*I); + for (auto *IRef : C->varlists()) { + Dependences.push_back(std::make_pair(C->getDependencyKind(), IRef)); + } + } auto &&CodeGen = [PartId, &S, &PrivateVars, &FirstprivateVars]( CodeGenFunction &CGF) { // Set proper addresses for generated private copies. @@ -1575,8 +1587,8 @@ void CodeGenFunction::EmitOMPTaskDirective(const OMPTaskDirective &S) { } CGF.EmitStmt(CS->getCapturedStmt()); }; - auto OutlinedFn = - CGM.getOpenMPRuntime().emitTaskOutlinedFunction(S, *I, CodeGen); + auto OutlinedFn = CGM.getOpenMPRuntime().emitTaskOutlinedFunction( + S, *I, OMPD_task, CodeGen); // Check if we should emit tied or untied task. bool Tied = !S.getSingleClause(OMPC_untied); // Check if the task is final @@ -1602,7 +1614,7 @@ void CodeGenFunction::EmitOMPTaskDirective(const OMPTaskDirective &S) { CGM.getOpenMPRuntime().emitTaskCall( *this, S.getLocStart(), S, Tied, Final, OutlinedFn, SharedsTy, CapturedStruct, IfCond, PrivateVars, PrivateCopies, FirstprivateVars, - FirstprivateCopies, FirstprivateInits); + FirstprivateCopies, FirstprivateInits, Dependences); } void CodeGenFunction::EmitOMPTaskyieldDirective( @@ -2041,6 +2053,7 @@ static void EmitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind, case OMPC_nowait: case OMPC_untied: case OMPC_threadprivate: + case OMPC_depend: case OMPC_mergeable: llvm_unreachable("Clause is not allowed in 'omp atomic'."); } @@ -2077,7 +2090,7 @@ void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) { S.getV(), S.getExpr(), S.getUpdateExpr(), S.isXLHSInRHSPart(), S.getLocStart()); }; - CGM.getOpenMPRuntime().emitInlinedDirective(*this, CodeGen); + CGM.getOpenMPRuntime().emitInlinedDirective(*this, OMPD_atomic, CodeGen); } void CodeGenFunction::EmitOMPTargetDirective(const OMPTargetDirective &) { @@ -2087,3 +2100,23 @@ void CodeGenFunction::EmitOMPTargetDirective(const OMPTargetDirective &) { void CodeGenFunction::EmitOMPTeamsDirective(const OMPTeamsDirective &) { llvm_unreachable("CodeGen for 'omp teams' is not supported yet."); } + +void CodeGenFunction::EmitOMPCancellationPointDirective( + const OMPCancellationPointDirective &S) { + CGM.getOpenMPRuntime().emitCancellationPointCall(*this, S.getLocStart(), + S.getCancelRegion()); +} + +void CodeGenFunction::EmitOMPCancelDirective(const OMPCancelDirective &S) { + llvm_unreachable("CodeGen for 'omp cancel' is not supported yet."); +} + +CodeGenFunction::JumpDest +CodeGenFunction::getOMPCancelDestination(OpenMPDirectiveKind Kind) { + if (Kind == OMPD_parallel || Kind == OMPD_task) + return ReturnBlock; + else if (Kind == OMPD_for || Kind == OMPD_section || Kind == OMPD_sections) + return BreakContinueStack.empty() ? JumpDest() + : BreakContinueStack.back().BreakBlock; + return JumpDest(); +} diff --git a/lib/CodeGen/CGVTables.cpp b/lib/CodeGen/CGVTables.cpp index 17db40138296..969629fb5845 100644 --- a/lib/CodeGen/CGVTables.cpp +++ b/lib/CodeGen/CGVTables.cpp @@ -123,8 +123,8 @@ static RValue PerformReturnAdjustment(CodeGenFunction &CGF, // no-op thunk for the regular definition) call va_start/va_end. // There's a bit of per-call overhead for this solution, but it's // better for codesize if the definition is long. -void CodeGenFunction::GenerateVarArgsThunk( - llvm::Function *Fn, +llvm::Function * +CodeGenFunction::GenerateVarArgsThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk) { const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); @@ -184,6 +184,8 @@ void CodeGenFunction::GenerateVarArgsThunk( } } } + + return Fn; } void CodeGenFunction::StartThunk(llvm::Function *Fn, GlobalDecl GD, @@ -378,9 +380,6 @@ void CodeGenFunction::GenerateThunk(llvm::Function *Fn, // Set the right linkage. CGM.setFunctionLinkage(GD, Fn); - if (CGM.supportsCOMDAT() && Fn->isWeakForLinker()) - Fn->setComdat(CGM.getModule().getOrInsertComdat(Fn->getName())); - // Set the right visibility. const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); setThunkVisibility(CGM, MD, Thunk, Fn); @@ -450,17 +449,19 @@ void CodeGenVTables::emitThunk(GlobalDecl GD, const ThunkInfo &Thunk, // expensive/sucky at the moment, so don't generate the thunk unless // we have to. // FIXME: Do something better here; GenerateVarArgsThunk is extremely ugly. - if (!UseAvailableExternallyLinkage) { - CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk); - CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable, GD, - !Thunk.Return.isEmpty()); - } + if (UseAvailableExternallyLinkage) + return; + ThunkFn = + CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk); } else { // Normal thunk body generation. CodeGenFunction(CGM).GenerateThunk(ThunkFn, FnInfo, GD, Thunk); - CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable, GD, - !Thunk.Return.isEmpty()); } + + CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable, GD, + !Thunk.Return.isEmpty()); + if (CGM.supportsCOMDAT() && ThunkFn->isWeakForLinker()) + ThunkFn->setComdat(CGM.getModule().getOrInsertComdat(ThunkFn->getName())); } void CodeGenVTables::maybeEmitThunkForVTable(GlobalDecl GD, @@ -702,7 +703,7 @@ CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) { llvm::Function::InternalLinkage; return llvm::GlobalVariable::ExternalLinkage; - + case TSK_ImplicitInstantiation: return !Context.getLangOpts().AppleKext ? llvm::GlobalVariable::LinkOnceODRLinkage : diff --git a/lib/CodeGen/CodeGenABITypes.cpp b/lib/CodeGen/CodeGenABITypes.cpp index 12189ae1aea9..755e8aa628ce 100644 --- a/lib/CodeGen/CodeGenABITypes.cpp +++ b/lib/CodeGen/CodeGenABITypes.cpp @@ -20,6 +20,8 @@ #include "CodeGenModule.h" #include "clang/CodeGen/CGFunctionInfo.h" #include "clang/Frontend/CodeGenOptions.h" +#include "clang/Lex/HeaderSearchOptions.h" +#include "clang/Lex/PreprocessorOptions.h" using namespace clang; using namespace CodeGen; @@ -29,7 +31,10 @@ CodeGenABITypes::CodeGenABITypes(ASTContext &C, const llvm::DataLayout &TD, CoverageSourceInfo *CoverageInfo) : CGO(new CodeGenOptions), - CGM(new CodeGen::CodeGenModule(C, *CGO, M, TD, C.getDiagnostics(), + HSO(new HeaderSearchOptions), + PPO(new PreprocessorOptions), + CGM(new CodeGen::CodeGenModule(C, *HSO, *PPO, *CGO, + M, TD, C.getDiagnostics(), CoverageInfo)) { } diff --git a/lib/CodeGen/CodeGenAction.cpp b/lib/CodeGen/CodeGenAction.cpp index 54e6b73b3020..0e7b6d8a71d4 100644 --- a/lib/CodeGen/CodeGenAction.cpp +++ b/lib/CodeGen/CodeGenAction.cpp @@ -57,6 +57,8 @@ namespace clang { public: BackendConsumer(BackendAction Action, DiagnosticsEngine &Diags, + const HeaderSearchOptions &HeaderSearchOpts, + const PreprocessorOptions &PPOpts, const CodeGenOptions &CodeGenOpts, const TargetOptions &TargetOpts, const LangOptions &LangOpts, bool TimePasses, @@ -66,7 +68,8 @@ namespace clang { : Diags(Diags), Action(Action), CodeGenOpts(CodeGenOpts), TargetOpts(TargetOpts), LangOpts(LangOpts), AsmOutStream(OS), Context(nullptr), LLVMIRGeneration("LLVM IR Generation Time"), - Gen(CreateLLVMCodeGen(Diags, InFile, CodeGenOpts, C, CoverageInfo)), + Gen(CreateLLVMCodeGen(Diags, InFile, HeaderSearchOpts, PPOpts, + CodeGenOpts, C, CoverageInfo)), LinkModule(LinkModule) { llvm::TimePassesIsEnabled = TimePasses; } @@ -667,7 +670,8 @@ CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { std::unique_ptr<PPCallbacks>(CoverageInfo)); } std::unique_ptr<BackendConsumer> Result(new BackendConsumer( - BA, CI.getDiagnostics(), CI.getCodeGenOpts(), CI.getTargetOpts(), + BA, CI.getDiagnostics(), CI.getHeaderSearchOpts(), + CI.getPreprocessorOpts(), CI.getCodeGenOpts(), CI.getTargetOpts(), CI.getLangOpts(), CI.getFrontendOpts().ShowTimers, InFile, LinkModuleToUse, OS, *VMContext, CoverageInfo)); BEConsumer = Result.get(); diff --git a/lib/CodeGen/CodeGenFunction.cpp b/lib/CodeGen/CodeGenFunction.cpp index bece41e9ecb2..1fca466e9244 100644 --- a/lib/CodeGen/CodeGenFunction.cpp +++ b/lib/CodeGen/CodeGenFunction.cpp @@ -930,8 +930,9 @@ void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn, EmitCheck(std::make_pair(IsFalse, SanitizerKind::Return), "missing_return", EmitCheckSourceLocation(FD->getLocation()), None); - } else if (CGM.getCodeGenOpts().OptimizationLevel == 0) - Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::trap), {}); + } else if (CGM.getCodeGenOpts().OptimizationLevel == 0) { + EmitTrapCall(llvm::Intrinsic::trap); + } Builder.CreateUnreachable(); Builder.ClearInsertionPoint(); } @@ -970,8 +971,8 @@ bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) { IgnoreCaseStmts = true; // Scan subexpressions for verboten labels. - for (Stmt::const_child_range I = S->children(); I; ++I) - if (ContainsLabel(*I, IgnoreCaseStmts)) + for (const Stmt *SubStmt : S->children()) + if (ContainsLabel(SubStmt, IgnoreCaseStmts)) return true; return false; @@ -994,8 +995,8 @@ bool CodeGenFunction::containsBreak(const Stmt *S) { return true; // Scan subexpressions for verboten breaks. - for (Stmt::const_child_range I = S->children(); I; ++I) - if (containsBreak(*I)) + for (const Stmt *SubStmt : S->children()) + if (containsBreak(SubStmt)) return true; return false; diff --git a/lib/CodeGen/CodeGenFunction.h b/lib/CodeGen/CodeGenFunction.h index 45475d1af1c4..a74c474232c8 100644 --- a/lib/CodeGen/CodeGenFunction.h +++ b/lib/CodeGen/CodeGenFunction.h @@ -233,6 +233,20 @@ public: }; CGCapturedStmtInfo *CapturedStmtInfo; + /// \brief RAII for correct setting/restoring of CapturedStmtInfo. + class CGCapturedStmtRAII { + private: + CodeGenFunction &CGF; + CGCapturedStmtInfo *PrevCapturedStmtInfo; + public: + CGCapturedStmtRAII(CodeGenFunction &CGF, + CGCapturedStmtInfo *NewCapturedStmtInfo) + : CGF(CGF), PrevCapturedStmtInfo(CGF.CapturedStmtInfo) { + CGF.CapturedStmtInfo = NewCapturedStmtInfo; + } + ~CGCapturedStmtRAII() { CGF.CapturedStmtInfo = PrevCapturedStmtInfo; } + }; + /// BoundsChecking - Emit run-time bounds checks. Higher values mean /// potentially higher performance penalties. unsigned char BoundsChecking; @@ -283,12 +297,12 @@ public: /// Header for data within LifetimeExtendedCleanupStack. struct LifetimeExtendedCleanupHeader { /// The size of the following cleanup object. - unsigned Size : 29; + unsigned Size; /// The kind of cleanup to push: a value from the CleanupKind enumeration. - unsigned Kind : 3; + CleanupKind Kind; - size_t getSize() const { return size_t(Size); } - CleanupKind getKind() const { return static_cast<CleanupKind>(Kind); } + size_t getSize() const { return Size; } + CleanupKind getKind() const { return Kind; } }; /// i32s containing the indexes of the cleanup destinations. @@ -388,6 +402,8 @@ public: LifetimeExtendedCleanupStack.resize( LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size); + static_assert(sizeof(Header) % llvm::AlignOf<T>::Alignment == 0, + "Cleanup will be allocated on misaligned address"); char *Buffer = &LifetimeExtendedCleanupStack[OldSize]; new (Buffer) LifetimeExtendedCleanupHeader(Header); new (Buffer + sizeof(Header)) T(A...); @@ -1280,8 +1296,9 @@ public: void GenerateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk); - void GenerateVarArgsThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, - GlobalDecl GD, const ThunkInfo &Thunk); + llvm::Function *GenerateVarArgsThunk(llvm::Function *Fn, + const CGFunctionInfo &FnInfo, + GlobalDecl GD, const ThunkInfo &Thunk); void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type, FunctionArgList &Args); @@ -2185,6 +2202,9 @@ public: void EmitOMPAtomicDirective(const OMPAtomicDirective &S); void EmitOMPTargetDirective(const OMPTargetDirective &S); void EmitOMPTeamsDirective(const OMPTeamsDirective &S); + void + EmitOMPCancellationPointDirective(const OMPCancellationPointDirective &S); + void EmitOMPCancelDirective(const OMPCancelDirective &S); /// \brief Emit inner loop of the worksharing/simd construct. /// @@ -2202,10 +2222,12 @@ public: const llvm::function_ref<void(CodeGenFunction &)> &BodyGen, const llvm::function_ref<void(CodeGenFunction &)> &PostIncGen); + JumpDest getOMPCancelDestination(OpenMPDirectiveKind Kind); + private: /// Helpers for the OpenMP loop directives. - void EmitOMPLoopBody(const OMPLoopDirective &D); + void EmitOMPLoopBody(const OMPLoopDirective &D, JumpDest LoopExit); void EmitOMPSimdInit(const OMPLoopDirective &D); void EmitOMPSimdFinal(const OMPLoopDirective &D); /// \brief Emit code for the worksharing loop-based directive. @@ -2217,6 +2239,8 @@ private: OMPPrivateScope &LoopScope, bool Ordered, llvm::Value *LB, llvm::Value *UB, llvm::Value *ST, llvm::Value *IL, llvm::Value *Chunk); + /// \brief Emit code for sections directive. + OpenMPDirectiveKind EmitSections(const OMPExecutableDirective &S); public: @@ -2586,6 +2610,7 @@ public: llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E); llvm::Value *EmitAMDGPUBuiltinExpr(unsigned BuiltinID, const CallExpr *E); llvm::Value *EmitSystemZBuiltinExpr(unsigned BuiltinID, const CallExpr *E); + llvm::Value *EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E); llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E); llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E); @@ -2852,6 +2877,10 @@ public: /// conditional branch to it, for the -ftrapv checks. void EmitTrapCheck(llvm::Value *Checked); + /// \brief Emit a call to trap or debugtrap and attach function attribute + /// "trap-func-name" if specified. + llvm::CallInst *EmitTrapCall(llvm::Intrinsic::ID IntrID); + /// \brief Create a check for a function parameter that may potentially be /// declared as non-null. void EmitNonNullArgCheck(RValue RV, QualType ArgType, SourceLocation ArgLoc, diff --git a/lib/CodeGen/CodeGenModule.cpp b/lib/CodeGen/CodeGenModule.cpp index 2dd5414795e7..b905bd2b36bf 100644 --- a/lib/CodeGen/CodeGenModule.cpp +++ b/lib/CodeGen/CodeGenModule.cpp @@ -74,16 +74,19 @@ static CGCXXABI *createCXXABI(CodeGenModule &CGM) { llvm_unreachable("invalid C++ ABI kind"); } -CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO, - llvm::Module &M, const llvm::DataLayout &TD, +CodeGenModule::CodeGenModule(ASTContext &C, const HeaderSearchOptions &HSO, + const PreprocessorOptions &PPO, + const CodeGenOptions &CGO, llvm::Module &M, + const llvm::DataLayout &TD, DiagnosticsEngine &diags, CoverageSourceInfo *CoverageInfo) - : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TheModule(M), - Diags(diags), TheDataLayout(TD), Target(C.getTargetInfo()), - ABI(createCXXABI(*this)), VMContext(M.getContext()), TBAA(nullptr), - TheTargetCodeGenInfo(nullptr), Types(*this), VTables(*this), - ObjCRuntime(nullptr), OpenCLRuntime(nullptr), OpenMPRuntime(nullptr), - CUDARuntime(nullptr), DebugInfo(nullptr), ARCData(nullptr), + : Context(C), LangOpts(C.getLangOpts()), HeaderSearchOpts(HSO), + PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags), + TheDataLayout(TD), Target(C.getTargetInfo()), ABI(createCXXABI(*this)), + VMContext(M.getContext()), TBAA(nullptr), TheTargetCodeGenInfo(nullptr), + Types(*this), VTables(*this), ObjCRuntime(nullptr), + OpenCLRuntime(nullptr), OpenMPRuntime(nullptr), CUDARuntime(nullptr), + DebugInfo(nullptr), ARCData(nullptr), NoObjCARCExceptionsMetadata(nullptr), RRData(nullptr), PGOReader(nullptr), CFConstantStringClassRef(nullptr), ConstantStringClassRef(nullptr), NSConstantStringType(nullptr), NSConcreteGlobalBlock(nullptr), @@ -145,8 +148,9 @@ CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO, llvm::IndexedInstrProfReader::create(CodeGenOpts.InstrProfileInput); if (std::error_code EC = ReaderOrErr.getError()) { unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, - "Could not read profile: %0"); - getDiags().Report(DiagID) << EC.message(); + "Could not read profile %0: %1"); + getDiags().Report(DiagID) << CodeGenOpts.InstrProfileInput + << EC.message(); } else PGOReader = std::move(ReaderOrErr.get()); } @@ -1424,7 +1428,7 @@ namespace { return false; } unsigned BuiltinID = FD->getBuiltinID(); - if (!BuiltinID) + if (!BuiltinID || !BI.isLibFunction(BuiltinID)) return true; StringRef BuiltinName = BI.GetName(BuiltinID); if (BuiltinName.startswith("__builtin_") && @@ -3358,6 +3362,8 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { Owner->getTopLevelModule()->Name == getLangOpts().CurrentModule) break; } + if (CGDebugInfo *DI = getModuleDebugInfo()) + DI->EmitImportDecl(*Import); ImportedModules.insert(Import->getImportedModule()); break; diff --git a/lib/CodeGen/CodeGenModule.h b/lib/CodeGen/CodeGenModule.h index 8e671fa7878c..9a295feaffa4 100644 --- a/lib/CodeGen/CodeGenModule.h +++ b/lib/CodeGen/CodeGenModule.h @@ -69,6 +69,8 @@ class ValueDecl; class VarDecl; class LangOptions; class CodeGenOptions; +class HeaderSearchOptions; +class PreprocessorOptions; class DiagnosticsEngine; class AnnotateAttr; class CXXDestructorDecl; @@ -278,6 +280,8 @@ public: private: ASTContext &Context; const LangOptions &LangOpts; + const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info. + const PreprocessorOptions &PreprocessorOpts; // Only used for debug info. const CodeGenOptions &CodeGenOpts; llvm::Module &TheModule; DiagnosticsEngine &Diags; @@ -488,7 +492,10 @@ private: std::unique_ptr<CoverageMappingModuleGen> CoverageMapping; public: - CodeGenModule(ASTContext &C, const CodeGenOptions &CodeGenOpts, + CodeGenModule(ASTContext &C, + const HeaderSearchOptions &headersearchopts, + const PreprocessorOptions &ppopts, + const CodeGenOptions &CodeGenOpts, llvm::Module &M, const llvm::DataLayout &TD, DiagnosticsEngine &Diags, CoverageSourceInfo *CoverageInfo = nullptr); @@ -600,6 +607,10 @@ public: ASTContext &getContext() const { return Context; } const LangOptions &getLangOpts() const { return LangOpts; } + const HeaderSearchOptions &getHeaderSearchOpts() + const { return HeaderSearchOpts; } + const PreprocessorOptions &getPreprocessorOpts() + const { return PreprocessorOpts; } const CodeGenOptions &getCodeGenOpts() const { return CodeGenOpts; } llvm::Module &getModule() const { return TheModule; } DiagnosticsEngine &getDiags() const { return Diags; } @@ -732,6 +743,11 @@ public: /// Get a reference to the target of VD. llvm::Constant *GetWeakRefReference(const ValueDecl *VD); + CharUnits + computeNonVirtualBaseClassOffset(const CXXRecordDecl *DerivedClass, + CastExpr::path_const_iterator Start, + CastExpr::path_const_iterator End); + /// Returns the offset from a derived class to a class. Returns null if the /// offset is 0. llvm::Constant * diff --git a/lib/CodeGen/CodeGenPGO.cpp b/lib/CodeGen/CodeGenPGO.cpp index f182a469b3a4..8dffefc871f2 100644 --- a/lib/CodeGen/CodeGenPGO.cpp +++ b/lib/CodeGen/CodeGenPGO.cpp @@ -275,10 +275,9 @@ struct ComputeRegionCounts : public ConstStmtVisitor<ComputeRegionCounts> { void VisitStmt(const Stmt *S) { RecordStmtCount(S); - for (Stmt::const_child_range I = S->children(); I; ++I) { - if (*I) - this->Visit(*I); - } + for (const Stmt *Child : S->children()) + if (Child) + this->Visit(Child); } void VisitFunctionDecl(const FunctionDecl *D) { diff --git a/lib/CodeGen/CodeGenTypes.cpp b/lib/CodeGen/CodeGenTypes.cpp index e0f926cabd71..a4a8654eb36b 100644 --- a/lib/CodeGen/CodeGenTypes.cpp +++ b/lib/CodeGen/CodeGenTypes.cpp @@ -154,14 +154,16 @@ isSafeToConvert(const RecordDecl *RD, CodeGenTypes &CGT, static bool isSafeToConvert(QualType T, CodeGenTypes &CGT, llvm::SmallPtrSet<const RecordDecl*, 16> &AlreadyChecked) { - T = T.getCanonicalType(); - + // Strip off atomic type sugar. + if (const auto *AT = T->getAs<AtomicType>()) + T = AT->getValueType(); + // If this is a record, check it. - if (const RecordType *RT = dyn_cast<RecordType>(T)) + if (const auto *RT = T->getAs<RecordType>()) return isSafeToConvert(RT->getDecl(), CGT, AlreadyChecked); - + // If this is an array, check the elements, which are embedded inline. - if (const ArrayType *AT = dyn_cast<ArrayType>(T)) + if (const auto *AT = CGT.getContext().getAsArrayType(T)) return isSafeToConvert(AT->getElementType(), CGT, AlreadyChecked); // Otherwise, there is no concern about transforming this. We only care about diff --git a/lib/CodeGen/CoverageMappingGen.cpp b/lib/CodeGen/CoverageMappingGen.cpp index 9ad5d14edfdc..eca91590e602 100644 --- a/lib/CodeGen/CoverageMappingGen.cpp +++ b/lib/CodeGen/CoverageMappingGen.cpp @@ -475,7 +475,8 @@ struct CounterCoverageMappingBuilder /// files, this adjusts our current region stack and creates the file regions /// for the exited file. void handleFileExit(SourceLocation NewLoc) { - if (SM.isWrittenInSameFile(MostRecentLocation, NewLoc)) + if (NewLoc.isInvalid() || + SM.isWrittenInSameFile(MostRecentLocation, NewLoc)) return; // If NewLoc is not in a file that contains MostRecentLocation, walk up to @@ -581,10 +582,9 @@ struct CounterCoverageMappingBuilder void VisitStmt(const Stmt *S) { if (!S->getLocStart().isInvalid()) extendRegion(S); - for (Stmt::const_child_range I = S->children(); I; ++I) { - if (*I) - this->Visit(*I); - } + for (const Stmt *Child : S->children()) + if (Child) + this->Visit(Child); handleFileExit(getEnd(S)); } @@ -931,7 +931,8 @@ void CoverageMappingModuleGen::addFunctionMappingRecord( if (!FunctionRecordTy) { llvm::Type *FunctionRecordTypes[] = {Int8PtrTy, Int32Ty, Int32Ty, Int64Ty}; FunctionRecordTy = - llvm::StructType::get(Ctx, makeArrayRef(FunctionRecordTypes)); + llvm::StructType::get(Ctx, makeArrayRef(FunctionRecordTypes), + /*isPacked=*/true); } llvm::Constant *FunctionRecordVals[] = { diff --git a/lib/CodeGen/ItaniumCXXABI.cpp b/lib/CodeGen/ItaniumCXXABI.cpp index 3f5ad5db01b5..fa86e52ec804 100644 --- a/lib/CodeGen/ItaniumCXXABI.cpp +++ b/lib/CodeGen/ItaniumCXXABI.cpp @@ -94,7 +94,7 @@ public: llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT) override; - llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD) override; + llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD) override; llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset) override; llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT) override; @@ -219,7 +219,7 @@ public: bool ReturnAdjustment) override { // Allow inlining of thunks by emitting them with available_externally // linkage together with vtables when needed. - if (ForVTable) + if (ForVTable && !Thunk->hasLocalLinkage()) Thunk->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage); } @@ -656,7 +656,8 @@ ItaniumCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT, return llvm::ConstantInt::get(CGM.PtrDiffTy, offset.getQuantity()); } -llvm::Constant *ItaniumCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) { +llvm::Constant * +ItaniumCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) { return BuildMemberPointer(MD, CharUnits::Zero()); } diff --git a/lib/CodeGen/MicrosoftCXXABI.cpp b/lib/CodeGen/MicrosoftCXXABI.cpp index 679516bfa89a..d149df63c9e4 100644 --- a/lib/CodeGen/MicrosoftCXXABI.cpp +++ b/lib/CodeGen/MicrosoftCXXABI.cpp @@ -247,6 +247,50 @@ public: getAddrOfVBTable(const VPtrInfo &VBT, const CXXRecordDecl *RD, llvm::GlobalVariable::LinkageTypes Linkage); + llvm::GlobalVariable * + getAddrOfVirtualDisplacementMap(const CXXRecordDecl *SrcRD, + const CXXRecordDecl *DstRD) { + SmallString<256> OutName; + llvm::raw_svector_ostream Out(OutName); + getMangleContext().mangleCXXVirtualDisplacementMap(SrcRD, DstRD, Out); + Out.flush(); + StringRef MangledName = OutName.str(); + + if (auto *VDispMap = CGM.getModule().getNamedGlobal(MangledName)) + return VDispMap; + + MicrosoftVTableContext &VTContext = CGM.getMicrosoftVTableContext(); + unsigned NumEntries = 1 + SrcRD->getNumVBases(); + SmallVector<llvm::Constant *, 4> Map(NumEntries, + llvm::UndefValue::get(CGM.IntTy)); + Map[0] = llvm::ConstantInt::get(CGM.IntTy, 0); + bool AnyDifferent = false; + for (const auto &I : SrcRD->vbases()) { + const CXXRecordDecl *VBase = I.getType()->getAsCXXRecordDecl(); + if (!DstRD->isVirtuallyDerivedFrom(VBase)) + continue; + + unsigned SrcVBIndex = VTContext.getVBTableIndex(SrcRD, VBase); + unsigned DstVBIndex = VTContext.getVBTableIndex(DstRD, VBase); + Map[SrcVBIndex] = llvm::ConstantInt::get(CGM.IntTy, DstVBIndex * 4); + AnyDifferent |= SrcVBIndex != DstVBIndex; + } + // This map would be useless, don't use it. + if (!AnyDifferent) + return nullptr; + + llvm::ArrayType *VDispMapTy = llvm::ArrayType::get(CGM.IntTy, Map.size()); + llvm::Constant *Init = llvm::ConstantArray::get(VDispMapTy, Map); + llvm::GlobalValue::LinkageTypes Linkage = + SrcRD->isExternallyVisible() && DstRD->isExternallyVisible() + ? llvm::GlobalValue::LinkOnceODRLinkage + : llvm::GlobalValue::InternalLinkage; + auto *VDispMap = new llvm::GlobalVariable( + CGM.getModule(), VDispMapTy, /*Constant=*/true, Linkage, + /*Initializer=*/Init, MangledName); + return VDispMap; + } + void emitVBTableDefinition(const VPtrInfo &VBT, const CXXRecordDecl *RD, llvm::GlobalVariable *GV) const; @@ -502,10 +546,6 @@ private: CharUnits NonVirtualBaseAdjustment, unsigned VBTableIndex); - llvm::Constant *BuildMemberPointer(const CXXRecordDecl *RD, - const CXXMethodDecl *MD, - CharUnits NonVirtualBaseAdjustment); - bool MemberPointerConstantIsNull(const MemberPointerType *MPT, llvm::Constant *MP); @@ -545,7 +585,7 @@ public: llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset) override; - llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD) override; + llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD) override; llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT) override; llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF, @@ -563,6 +603,12 @@ public: llvm::Value *Base, llvm::Value *MemPtr, const MemberPointerType *MPT) override; + llvm::Value *EmitNonNullMemberPointerConversion( + const MemberPointerType *SrcTy, const MemberPointerType *DstTy, + CastKind CK, CastExpr::path_const_iterator PathBegin, + CastExpr::path_const_iterator PathEnd, llvm::Value *Src, + CGBuilderTy &Builder); + llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF, const CastExpr *E, llvm::Value *Src) override; @@ -570,6 +616,11 @@ public: llvm::Constant *EmitMemberPointerConversion(const CastExpr *E, llvm::Constant *Src) override; + llvm::Constant *EmitMemberPointerConversion( + const MemberPointerType *SrcTy, const MemberPointerType *DstTy, + CastKind CK, CastExpr::path_const_iterator PathBegin, + CastExpr::path_const_iterator PathEnd, llvm::Constant *Src); + llvm::Value * EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, const Expr *E, llvm::Value *&This, llvm::Value *MemPtr, @@ -2457,7 +2508,7 @@ MicrosoftCXXABI::EmitFullMemberPointer(llvm::Constant *FirstField, if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance)) { CharUnits Offs = CharUnits::Zero(); - if (VBTableIndex && RD->getNumVBases()) + if (VBTableIndex) Offs = getContext().getASTRecordLayout(RD).getVBPtrOffset(); fields.push_back(llvm::ConstantInt::get(CGM.IntTy, Offs.getQuantity())); } @@ -2473,43 +2524,76 @@ llvm::Constant * MicrosoftCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset) { const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); + if (RD->getMSInheritanceModel() == + MSInheritanceAttr::Keyword_virtual_inheritance) + offset -= getContext().getOffsetOfBaseWithVBPtr(RD); llvm::Constant *FirstField = llvm::ConstantInt::get(CGM.IntTy, offset.getQuantity()); return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/false, RD, CharUnits::Zero(), /*VBTableIndex=*/0); } -llvm::Constant *MicrosoftCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) { - return BuildMemberPointer(MD->getParent(), MD, CharUnits::Zero()); -} - llvm::Constant *MicrosoftCXXABI::EmitMemberPointer(const APValue &MP, QualType MPType) { - const MemberPointerType *MPT = MPType->castAs<MemberPointerType>(); + const MemberPointerType *DstTy = MPType->castAs<MemberPointerType>(); const ValueDecl *MPD = MP.getMemberPointerDecl(); if (!MPD) - return EmitNullMemberPointer(MPT); + return EmitNullMemberPointer(DstTy); - CharUnits ThisAdjustment = getMemberPointerPathAdjustment(MP); + ASTContext &Ctx = getContext(); + ArrayRef<const CXXRecordDecl *> MemberPointerPath = MP.getMemberPointerPath(); - // FIXME PR15713: Support virtual inheritance paths. + llvm::Constant *C; + if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD)) { + C = EmitMemberFunctionPointer(MD); + } else { + CharUnits FieldOffset = Ctx.toCharUnitsFromBits(Ctx.getFieldOffset(MPD)); + C = EmitMemberDataPointer(DstTy, FieldOffset); + } - if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD)) - return BuildMemberPointer(MPT->getMostRecentCXXRecordDecl(), MD, - ThisAdjustment); + if (!MemberPointerPath.empty()) { + const CXXRecordDecl *SrcRD = cast<CXXRecordDecl>(MPD->getDeclContext()); + const Type *SrcRecTy = Ctx.getTypeDeclType(SrcRD).getTypePtr(); + const MemberPointerType *SrcTy = + Ctx.getMemberPointerType(DstTy->getPointeeType(), SrcRecTy) + ->castAs<MemberPointerType>(); + + bool DerivedMember = MP.isMemberPointerToDerivedMember(); + SmallVector<const CXXBaseSpecifier *, 4> DerivedToBasePath; + const CXXRecordDecl *PrevRD = SrcRD; + for (const CXXRecordDecl *PathElem : MemberPointerPath) { + const CXXRecordDecl *Base = nullptr; + const CXXRecordDecl *Derived = nullptr; + if (DerivedMember) { + Base = PathElem; + Derived = PrevRD; + } else { + Base = PrevRD; + Derived = PathElem; + } + for (const CXXBaseSpecifier &BS : Derived->bases()) + if (BS.getType()->getAsCXXRecordDecl()->getCanonicalDecl() == + Base->getCanonicalDecl()) + DerivedToBasePath.push_back(&BS); + PrevRD = PathElem; + } + assert(DerivedToBasePath.size() == MemberPointerPath.size()); - CharUnits FieldOffset = - getContext().toCharUnitsFromBits(getContext().getFieldOffset(MPD)); - return EmitMemberDataPointer(MPT, ThisAdjustment + FieldOffset); + CastKind CK = DerivedMember ? CK_DerivedToBaseMemberPointer + : CK_BaseToDerivedMemberPointer; + C = EmitMemberPointerConversion(SrcTy, DstTy, CK, DerivedToBasePath.begin(), + DerivedToBasePath.end(), C); + } + return C; } llvm::Constant * -MicrosoftCXXABI::BuildMemberPointer(const CXXRecordDecl *RD, - const CXXMethodDecl *MD, - CharUnits NonVirtualBaseAdjustment) { +MicrosoftCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) { assert(MD->isInstance() && "Member function must not be static!"); + MD = MD->getCanonicalDecl(); - RD = RD->getMostRecentDecl(); + CharUnits NonVirtualBaseAdjustment = CharUnits::Zero(); + const CXXRecordDecl *RD = MD->getParent()->getMostRecentDecl(); CodeGenTypes &Types = CGM.getTypes(); unsigned VBTableIndex = 0; @@ -2527,20 +2611,24 @@ MicrosoftCXXABI::BuildMemberPointer(const CXXRecordDecl *RD, Ty = CGM.PtrDiffTy; } FirstField = CGM.GetAddrOfFunction(MD, Ty); - FirstField = llvm::ConstantExpr::getBitCast(FirstField, 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); + FirstField = EmitVirtualMemPtrThunk(MD, ML); // 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; } + if (VBTableIndex == 0 && + RD->getMSInheritanceModel() == + MSInheritanceAttr::Keyword_virtual_inheritance) + NonVirtualBaseAdjustment -= getContext().getOffsetOfBaseWithVBPtr(RD); + // The rest of the fields are common with data member pointers. + FirstField = llvm::ConstantExpr::getBitCast(FirstField, CGM.VoidPtrTy); return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/true, RD, NonVirtualBaseAdjustment, VBTableIndex); } @@ -2798,11 +2886,6 @@ llvm::Value *MicrosoftCXXABI::EmitMemberDataPointerAddress( return Builder.CreateBitCast(Addr, PType); } -static MSInheritanceAttr::Spelling -getInheritanceFromMemptr(const MemberPointerType *MPT) { - return MPT->getMostRecentCXXRecordDecl()->getMSInheritanceModel(); -} - llvm::Value * MicrosoftCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF, const CastExpr *E, @@ -2854,12 +2937,37 @@ MicrosoftCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF, Builder.CreateCondBr(IsNotNull, ConvertBB, ContinueBB); CGF.EmitBlock(ConvertBB); + llvm::Value *Dst = EmitNonNullMemberPointerConversion( + SrcTy, DstTy, E->getCastKind(), E->path_begin(), E->path_end(), Src, + Builder); + + Builder.CreateBr(ContinueBB); + + // In the continuation, choose between DstNull and Dst. + CGF.EmitBlock(ContinueBB); + llvm::PHINode *Phi = Builder.CreatePHI(DstNull->getType(), 2, "memptr.converted"); + Phi->addIncoming(DstNull, OriginalBB); + Phi->addIncoming(Dst, ConvertBB); + return Phi; +} + +llvm::Value *MicrosoftCXXABI::EmitNonNullMemberPointerConversion( + const MemberPointerType *SrcTy, const MemberPointerType *DstTy, CastKind CK, + CastExpr::path_const_iterator PathBegin, + CastExpr::path_const_iterator PathEnd, llvm::Value *Src, + CGBuilderTy &Builder) { + const CXXRecordDecl *SrcRD = SrcTy->getMostRecentCXXRecordDecl(); + const CXXRecordDecl *DstRD = DstTy->getMostRecentCXXRecordDecl(); + MSInheritanceAttr::Spelling SrcInheritance = SrcRD->getMSInheritanceModel(); + MSInheritanceAttr::Spelling DstInheritance = DstRD->getMSInheritanceModel(); + bool IsFunc = SrcTy->isMemberFunctionPointer(); + bool IsConstant = isa<llvm::Constant>(Src); + // Decompose src. llvm::Value *FirstField = Src; - llvm::Value *NonVirtualBaseAdjustment = nullptr; - llvm::Value *VirtualBaseAdjustmentOffset = nullptr; - llvm::Value *VBPtrOffset = nullptr; - MSInheritanceAttr::Spelling SrcInheritance = SrcRD->getMSInheritanceModel(); + llvm::Value *NonVirtualBaseAdjustment = getZeroInt(); + llvm::Value *VirtualBaseAdjustmentOffset = getZeroInt(); + llvm::Value *VBPtrOffset = getZeroInt(); if (!MSInheritanceAttr::hasOnlyOneField(IsFunc, SrcInheritance)) { // We need to extract values. unsigned I = 0; @@ -2872,59 +2980,138 @@ MicrosoftCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF, VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(Src, I++); } + bool IsDerivedToBase = (CK == CK_DerivedToBaseMemberPointer); + const MemberPointerType *DerivedTy = IsDerivedToBase ? SrcTy : DstTy; + const CXXRecordDecl *DerivedClass = DerivedTy->getMostRecentCXXRecordDecl(); + // For data pointers, we adjust the field offset directly. For functions, we // have a separate field. - llvm::Constant *Adj = getMemberPointerAdjustment(E); - if (Adj) { - Adj = llvm::ConstantExpr::getTruncOrBitCast(Adj, CGM.IntTy); - llvm::Value *&NVAdjustField = IsFunc ? NonVirtualBaseAdjustment : FirstField; - bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer); - if (!NVAdjustField) // If this field didn't exist in src, it's zero. - NVAdjustField = getZeroInt(); - if (isDerivedToBase) - NVAdjustField = Builder.CreateNSWSub(NVAdjustField, Adj, "adj"); - else - NVAdjustField = Builder.CreateNSWAdd(NVAdjustField, Adj, "adj"); + llvm::Value *&NVAdjustField = IsFunc ? NonVirtualBaseAdjustment : FirstField; + + // The virtual inheritance model has a quirk: the virtual base table is always + // referenced when dereferencing a member pointer even if the member pointer + // is non-virtual. This is accounted for by adjusting the non-virtual offset + // to point backwards to the top of the MDC from the first VBase. Undo this + // adjustment to normalize the member pointer. + llvm::Value *SrcVBIndexEqZero = + Builder.CreateICmpEQ(VirtualBaseAdjustmentOffset, getZeroInt()); + if (SrcInheritance == MSInheritanceAttr::Keyword_virtual_inheritance) { + if (int64_t SrcOffsetToFirstVBase = + getContext().getOffsetOfBaseWithVBPtr(SrcRD).getQuantity()) { + llvm::Value *UndoSrcAdjustment = Builder.CreateSelect( + SrcVBIndexEqZero, + llvm::ConstantInt::get(CGM.IntTy, SrcOffsetToFirstVBase), + getZeroInt()); + NVAdjustField = Builder.CreateNSWAdd(NVAdjustField, UndoSrcAdjustment); + } } - // FIXME PR15713: Support conversions through virtually derived classes. + // A non-zero vbindex implies that we are dealing with a source member in a + // floating virtual base in addition to some non-virtual offset. If the + // vbindex is zero, we are dealing with a source that exists in a non-virtual, + // fixed, base. The difference between these two cases is that the vbindex + + // nvoffset *always* point to the member regardless of what context they are + // evaluated in so long as the vbindex is adjusted. A member inside a fixed + // base requires explicit nv adjustment. + llvm::Constant *BaseClassOffset = llvm::ConstantInt::get( + CGM.IntTy, + CGM.computeNonVirtualBaseClassOffset(DerivedClass, PathBegin, PathEnd) + .getQuantity()); + + llvm::Value *NVDisp; + if (IsDerivedToBase) + NVDisp = Builder.CreateNSWSub(NVAdjustField, BaseClassOffset, "adj"); + else + NVDisp = Builder.CreateNSWAdd(NVAdjustField, BaseClassOffset, "adj"); + + NVAdjustField = Builder.CreateSelect(SrcVBIndexEqZero, NVDisp, getZeroInt()); + + // Update the vbindex to an appropriate value in the destination because + // SrcRD's vbtable might not be a strict prefix of the one in DstRD. + llvm::Value *DstVBIndexEqZero = SrcVBIndexEqZero; + if (MSInheritanceAttr::hasVBTableOffsetField(DstInheritance) && + MSInheritanceAttr::hasVBTableOffsetField(SrcInheritance)) { + if (llvm::GlobalVariable *VDispMap = + getAddrOfVirtualDisplacementMap(SrcRD, DstRD)) { + llvm::Value *VBIndex = Builder.CreateExactUDiv( + VirtualBaseAdjustmentOffset, llvm::ConstantInt::get(CGM.IntTy, 4)); + if (IsConstant) { + llvm::Constant *Mapping = VDispMap->getInitializer(); + VirtualBaseAdjustmentOffset = + Mapping->getAggregateElement(cast<llvm::Constant>(VBIndex)); + } else { + llvm::Value *Idxs[] = {getZeroInt(), VBIndex}; + VirtualBaseAdjustmentOffset = + Builder.CreateLoad(Builder.CreateInBoundsGEP(VDispMap, Idxs)); + } + + DstVBIndexEqZero = + Builder.CreateICmpEQ(VirtualBaseAdjustmentOffset, getZeroInt()); + } + } + + // Set the VBPtrOffset to zero if the vbindex is zero. Otherwise, initialize + // it to the offset of the vbptr. + if (MSInheritanceAttr::hasVBPtrOffsetField(DstInheritance)) { + llvm::Value *DstVBPtrOffset = llvm::ConstantInt::get( + CGM.IntTy, + getContext().getASTRecordLayout(DstRD).getVBPtrOffset().getQuantity()); + VBPtrOffset = + Builder.CreateSelect(DstVBIndexEqZero, getZeroInt(), DstVBPtrOffset); + } + + // Likewise, apply a similar adjustment so that dereferencing the member + // pointer correctly accounts for the distance between the start of the first + // virtual base and the top of the MDC. + if (DstInheritance == MSInheritanceAttr::Keyword_virtual_inheritance) { + if (int64_t DstOffsetToFirstVBase = + getContext().getOffsetOfBaseWithVBPtr(DstRD).getQuantity()) { + llvm::Value *DoDstAdjustment = Builder.CreateSelect( + DstVBIndexEqZero, + llvm::ConstantInt::get(CGM.IntTy, DstOffsetToFirstVBase), + getZeroInt()); + NVAdjustField = Builder.CreateNSWSub(NVAdjustField, DoDstAdjustment); + } + } // Recompose dst from the null struct and the adjusted fields from src. - MSInheritanceAttr::Spelling DstInheritance = DstRD->getMSInheritanceModel(); llvm::Value *Dst; if (MSInheritanceAttr::hasOnlyOneField(IsFunc, DstInheritance)) { Dst = FirstField; } else { - Dst = llvm::UndefValue::get(DstNull->getType()); + Dst = llvm::UndefValue::get(ConvertMemberPointerType(DstTy)); unsigned Idx = 0; Dst = Builder.CreateInsertValue(Dst, FirstField, Idx++); if (MSInheritanceAttr::hasNVOffsetField(IsFunc, DstInheritance)) - Dst = Builder.CreateInsertValue( - Dst, getValueOrZeroInt(NonVirtualBaseAdjustment), Idx++); + Dst = Builder.CreateInsertValue(Dst, NonVirtualBaseAdjustment, Idx++); if (MSInheritanceAttr::hasVBPtrOffsetField(DstInheritance)) - Dst = Builder.CreateInsertValue( - Dst, getValueOrZeroInt(VBPtrOffset), Idx++); + Dst = Builder.CreateInsertValue(Dst, VBPtrOffset, Idx++); if (MSInheritanceAttr::hasVBTableOffsetField(DstInheritance)) - Dst = Builder.CreateInsertValue( - Dst, getValueOrZeroInt(VirtualBaseAdjustmentOffset), Idx++); + Dst = Builder.CreateInsertValue(Dst, VirtualBaseAdjustmentOffset, Idx++); } - Builder.CreateBr(ContinueBB); - - // In the continuation, choose between DstNull and Dst. - CGF.EmitBlock(ContinueBB); - llvm::PHINode *Phi = Builder.CreatePHI(DstNull->getType(), 2, "memptr.converted"); - Phi->addIncoming(DstNull, OriginalBB); - Phi->addIncoming(Dst, ConvertBB); - return Phi; + return Dst; } llvm::Constant * MicrosoftCXXABI::EmitMemberPointerConversion(const CastExpr *E, llvm::Constant *Src) { const MemberPointerType *SrcTy = - E->getSubExpr()->getType()->castAs<MemberPointerType>(); + E->getSubExpr()->getType()->castAs<MemberPointerType>(); const MemberPointerType *DstTy = E->getType()->castAs<MemberPointerType>(); + CastKind CK = E->getCastKind(); + + return EmitMemberPointerConversion(SrcTy, DstTy, CK, E->path_begin(), + E->path_end(), Src); +} + +llvm::Constant *MicrosoftCXXABI::EmitMemberPointerConversion( + const MemberPointerType *SrcTy, const MemberPointerType *DstTy, CastKind CK, + CastExpr::path_const_iterator PathBegin, + CastExpr::path_const_iterator PathEnd, llvm::Constant *Src) { + assert(CK == CK_DerivedToBaseMemberPointer || + CK == CK_BaseToDerivedMemberPointer || + CK == CK_ReinterpretMemberPointer); // If src is null, emit a new null for dst. We can't return src because dst // might have a new representation. if (MemberPointerConstantIsNull(SrcTy, Src)) @@ -2933,61 +3120,14 @@ MicrosoftCXXABI::EmitMemberPointerConversion(const CastExpr *E, // We don't need to do anything for reinterpret_casts of non-null member // pointers. We should only get here when the two type representations have // the same size. - if (E->getCastKind() == CK_ReinterpretMemberPointer) + if (CK == CK_ReinterpretMemberPointer) return Src; - MSInheritanceAttr::Spelling SrcInheritance = getInheritanceFromMemptr(SrcTy); - MSInheritanceAttr::Spelling DstInheritance = getInheritanceFromMemptr(DstTy); - - // Decompose src. - llvm::Constant *FirstField = Src; - llvm::Constant *NonVirtualBaseAdjustment = nullptr; - llvm::Constant *VirtualBaseAdjustmentOffset = nullptr; - llvm::Constant *VBPtrOffset = nullptr; - bool IsFunc = SrcTy->isMemberFunctionPointer(); - if (!MSInheritanceAttr::hasOnlyOneField(IsFunc, SrcInheritance)) { - // We need to extract values. - unsigned I = 0; - FirstField = Src->getAggregateElement(I++); - if (MSInheritanceAttr::hasNVOffsetField(IsFunc, SrcInheritance)) - NonVirtualBaseAdjustment = Src->getAggregateElement(I++); - if (MSInheritanceAttr::hasVBPtrOffsetField(SrcInheritance)) - VBPtrOffset = Src->getAggregateElement(I++); - if (MSInheritanceAttr::hasVBTableOffsetField(SrcInheritance)) - VirtualBaseAdjustmentOffset = Src->getAggregateElement(I++); - } - - // For data pointers, we adjust the field offset directly. For functions, we - // have a separate field. - llvm::Constant *Adj = getMemberPointerAdjustment(E); - if (Adj) { - Adj = llvm::ConstantExpr::getTruncOrBitCast(Adj, CGM.IntTy); - llvm::Constant *&NVAdjustField = - IsFunc ? NonVirtualBaseAdjustment : FirstField; - bool IsDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer); - if (!NVAdjustField) // If this field didn't exist in src, it's zero. - NVAdjustField = getZeroInt(); - if (IsDerivedToBase) - NVAdjustField = llvm::ConstantExpr::getNSWSub(NVAdjustField, Adj); - else - NVAdjustField = llvm::ConstantExpr::getNSWAdd(NVAdjustField, Adj); - } - - // FIXME PR15713: Support conversions through virtually derived classes. + CGBuilderTy Builder(CGM.getLLVMContext()); + auto *Dst = cast<llvm::Constant>(EmitNonNullMemberPointerConversion( + SrcTy, DstTy, CK, PathBegin, PathEnd, Src, Builder)); - // Recompose dst from the null struct and the adjusted fields from src. - if (MSInheritanceAttr::hasOnlyOneField(IsFunc, DstInheritance)) - return FirstField; - - llvm::SmallVector<llvm::Constant *, 4> Fields; - Fields.push_back(FirstField); - if (MSInheritanceAttr::hasNVOffsetField(IsFunc, DstInheritance)) - Fields.push_back(getConstantOrZeroInt(NonVirtualBaseAdjustment)); - if (MSInheritanceAttr::hasVBPtrOffsetField(DstInheritance)) - Fields.push_back(getConstantOrZeroInt(VBPtrOffset)); - if (MSInheritanceAttr::hasVBTableOffsetField(DstInheritance)) - Fields.push_back(getConstantOrZeroInt(VirtualBaseAdjustmentOffset)); - return llvm::ConstantStruct::getAnon(Fields); + return Dst; } llvm::Value *MicrosoftCXXABI::EmitLoadOfMemberFunctionPointer( @@ -3592,6 +3732,8 @@ MicrosoftCXXABI::getAddrOfCXXCtorClosure(const CXXConstructorDecl *CD, ThunkTy, getLinkageForRTTI(RecordTy), ThunkName.str(), &CGM.getModule()); ThunkFn->setCallingConv(static_cast<llvm::CallingConv::ID>( FnInfo.getEffectiveCallingConvention())); + if (ThunkFn->isWeakForLinker()) + ThunkFn->setComdat(CGM.getModule().getOrInsertComdat(ThunkFn->getName())); bool IsCopy = CT == Ctor_CopyingClosure; // Start codegen. diff --git a/lib/CodeGen/ModuleBuilder.cpp b/lib/CodeGen/ModuleBuilder.cpp index 25e57401fd57..def56a963126 100644 --- a/lib/CodeGen/ModuleBuilder.cpp +++ b/lib/CodeGen/ModuleBuilder.cpp @@ -32,6 +32,8 @@ namespace { DiagnosticsEngine &Diags; std::unique_ptr<const llvm::DataLayout> TD; ASTContext *Ctx; + const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info. + const PreprocessorOptions &PreprocessorOpts; // Only used for debug info. const CodeGenOptions CodeGenOpts; // Intentionally copied in. unsigned HandlingTopLevelDecls; @@ -56,12 +58,15 @@ namespace { SmallVector<CXXMethodDecl *, 8> DeferredInlineMethodDefinitions; public: - CodeGeneratorImpl(DiagnosticsEngine &diags, const std::string& ModuleName, - const CodeGenOptions &CGO, llvm::LLVMContext& C, + CodeGeneratorImpl(DiagnosticsEngine &diags, const std::string &ModuleName, + const HeaderSearchOptions &HSO, + const PreprocessorOptions &PPO, const CodeGenOptions &CGO, + llvm::LLVMContext &C, CoverageSourceInfo *CoverageInfo = nullptr) - : Diags(diags), Ctx(nullptr), CodeGenOpts(CGO), HandlingTopLevelDecls(0), - CoverageInfo(CoverageInfo), - M(new llvm::Module(ModuleName, C)) {} + : Diags(diags), Ctx(nullptr), HeaderSearchOpts(HSO), + PreprocessorOpts(PPO), CodeGenOpts(CGO), HandlingTopLevelDecls(0), + CoverageInfo(CoverageInfo), + M(new llvm::Module(ModuleName, C)) {} ~CodeGeneratorImpl() override { // There should normally not be any leftover inline method definitions. @@ -97,7 +102,10 @@ namespace { M->setDataLayout(Ctx->getTargetInfo().getTargetDescription()); TD.reset( new llvm::DataLayout(Ctx->getTargetInfo().getTargetDescription())); - Builder.reset(new CodeGen::CodeGenModule(Context, CodeGenOpts, *M, *TD, + Builder.reset(new CodeGen::CodeGenModule(Context, + HeaderSearchOpts, + PreprocessorOpts, + CodeGenOpts, *M, *TD, Diags, CoverageInfo)); for (size_t i = 0, e = CodeGenOpts.DependentLibraries.size(); i < e; ++i) @@ -236,10 +244,11 @@ namespace { void CodeGenerator::anchor() { } -CodeGenerator *clang::CreateLLVMCodeGen(DiagnosticsEngine &Diags, - const std::string& ModuleName, - const CodeGenOptions &CGO, - llvm::LLVMContext& C, - CoverageSourceInfo *CoverageInfo) { - return new CodeGeneratorImpl(Diags, ModuleName, CGO, C, CoverageInfo); +CodeGenerator *clang::CreateLLVMCodeGen( + DiagnosticsEngine &Diags, const std::string &ModuleName, + const HeaderSearchOptions &HeaderSearchOpts, + const PreprocessorOptions &PreprocessorOpts, const CodeGenOptions &CGO, + llvm::LLVMContext &C, CoverageSourceInfo *CoverageInfo) { + return new CodeGeneratorImpl(Diags, ModuleName, HeaderSearchOpts, + PreprocessorOpts, CGO, C, CoverageInfo); } diff --git a/lib/CodeGen/TargetInfo.cpp b/lib/CodeGen/TargetInfo.cpp index e77c1242e70b..e5ba200e1c57 100644 --- a/lib/CodeGen/TargetInfo.cpp +++ b/lib/CodeGen/TargetInfo.cpp @@ -1391,6 +1391,26 @@ bool X86_32TargetCodeGenInfo::initDwarfEHRegSizeTable( namespace { +/// The AVX ABI level for X86 targets. +enum class X86AVXABILevel { + None, + AVX, + AVX512 +}; + +/// \p returns the size in bits of the largest (native) vector for \p AVXLevel. +static unsigned getNativeVectorSizeForAVXABI(X86AVXABILevel AVXLevel) { + switch (AVXLevel) { + case X86AVXABILevel::AVX512: + return 512; + case X86AVXABILevel::AVX: + return 256; + case X86AVXABILevel::None: + return 128; + } + llvm_unreachable("Unknown AVXLevel"); +} + /// X86_64ABIInfo - The X86_64 ABI information. class X86_64ABIInfo : public ABIInfo { enum Class { @@ -1496,13 +1516,14 @@ class X86_64ABIInfo : public ABIInfo { return !getTarget().getTriple().isOSDarwin(); } + X86AVXABILevel AVXLevel; // Some ABIs (e.g. X32 ABI and Native Client OS) use 32 bit pointers on // 64-bit hardware. bool Has64BitPointers; public: - X86_64ABIInfo(CodeGen::CodeGenTypes &CGT) : - ABIInfo(CGT), + X86_64ABIInfo(CodeGen::CodeGenTypes &CGT, X86AVXABILevel AVXLevel) : + ABIInfo(CGT), AVXLevel(AVXLevel), Has64BitPointers(CGT.getDataLayout().getPointerSize(0) == 8) { } @@ -1527,10 +1548,6 @@ public: bool has64BitPointers() const { return Has64BitPointers; } - - bool hasAVX() const { - return getTarget().getABI() == "avx"; - } }; /// WinX86_64ABIInfo - The Windows X86_64 ABI information. @@ -1561,8 +1578,8 @@ public: class X86_64TargetCodeGenInfo : public TargetCodeGenInfo { public: - X86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT) - : TargetCodeGenInfo(new X86_64ABIInfo(CGT)) {} + X86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, X86AVXABILevel AVXLevel) + : TargetCodeGenInfo(new X86_64ABIInfo(CGT, AVXLevel)) {} const X86_64ABIInfo &getABIInfo() const { return static_cast<const X86_64ABIInfo&>(TargetCodeGenInfo::getABIInfo()); @@ -1628,16 +1645,12 @@ public: ('T' << 24); return llvm::ConstantInt::get(CGM.Int32Ty, Sig); } - - unsigned getOpenMPSimdDefaultAlignment(QualType) const override { - return getABIInfo().hasAVX() ? 32 : 16; - } }; class PS4TargetCodeGenInfo : public X86_64TargetCodeGenInfo { public: - PS4TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT) - : X86_64TargetCodeGenInfo(CGT) {} + PS4TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, X86AVXABILevel AVXLevel) + : X86_64TargetCodeGenInfo(CGT, AVXLevel) {} void getDependentLibraryOption(llvm::StringRef Lib, llvm::SmallString<24> &Opt) const override { @@ -1703,11 +1716,10 @@ void WinX86_32TargetCodeGenInfo::setTargetAttributes(const Decl *D, } class WinX86_64TargetCodeGenInfo : public TargetCodeGenInfo { - bool hasAVX() const { return getABIInfo().getTarget().getABI() == "avx"; } - public: - WinX86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT) - : TargetCodeGenInfo(new WinX86_64ABIInfo(CGT)) {} + WinX86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, + X86AVXABILevel AVXLevel) + : TargetCodeGenInfo(new WinX86_64ABIInfo(CGT)) {} void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &CGM) const override; @@ -1737,10 +1749,6 @@ public: llvm::SmallString<32> &Opt) const override { Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\""; } - - unsigned getOpenMPSimdDefaultAlignment(QualType) const override { - return hasAVX() ? 32 : 16; - } }; void WinX86_64TargetCodeGenInfo::setTargetAttributes(const Decl *D, @@ -1928,7 +1936,8 @@ void X86_64ABIInfo::classify(QualType Ty, uint64_t OffsetBase, // split. if (OffsetBase && OffsetBase != 64) Hi = Lo; - } else if (Size == 128 || (hasAVX() && isNamedArg && Size == 256)) { + } else if (Size == 128 || + (isNamedArg && Size <= getNativeVectorSizeForAVXABI(AVXLevel))) { // Arguments of 256-bits are split into four eightbyte chunks. The // least significant one belongs to class SSE and all the others to class // SSEUP. The original Lo and Hi design considers that types can't be @@ -1940,6 +1949,9 @@ void X86_64ABIInfo::classify(QualType Ty, uint64_t OffsetBase, // Note that per 3.5.7 of AMD64-ABI, 256-bit args are only passed in // registers if they are "named", i.e. not part of the "..." of a // variadic function. + // + // Similarly, per 3.2.3. of the AVX512 draft, 512-bits ("named") args are + // split into eight eightbyte chunks, one SSE and seven SSEUP. Lo = SSE; Hi = SSEUp; } @@ -2150,7 +2162,7 @@ ABIArgInfo X86_64ABIInfo::getIndirectReturnResult(QualType Ty) const { bool X86_64ABIInfo::IsIllegalVectorType(QualType Ty) const { if (const VectorType *VecTy = Ty->getAs<VectorType>()) { uint64_t Size = getContext().getTypeSize(VecTy); - unsigned LargestVector = hasAVX() ? 256 : 128; + unsigned LargestVector = getNativeVectorSizeForAVXABI(AVXLevel); if (Size <= 64 || Size > LargestVector) return true; } @@ -2475,13 +2487,16 @@ GetX86_64ByValArgumentPair(llvm::Type *Lo, llvm::Type *Hi, // of the second element because it might make us access off the end of the // struct. if (HiStart != 8) { - // There are only two sorts of types the ABI generation code can produce for - // the low part of a pair that aren't 8 bytes in size: float or i8/i16/i32. + // There are usually two sorts of types the ABI generation code can produce + // for the low part of a pair that aren't 8 bytes in size: float or + // i8/i16/i32. This can also include pointers when they are 32-bit (X32 and + // NaCl). // Promote these to a larger type. if (Lo->isFloatTy()) Lo = llvm::Type::getDoubleTy(Lo->getContext()); else { - assert(Lo->isIntegerTy() && "Invalid/unknown lo type"); + assert((Lo->isIntegerTy() || Lo->isPointerTy()) + && "Invalid/unknown lo type"); Lo = llvm::Type::getInt64Ty(Lo->getContext()); } } @@ -3145,10 +3160,6 @@ public: bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, llvm::Value *Address) const override; - - unsigned getOpenMPSimdDefaultAlignment(QualType) const override { - return 16; // Natural alignment for Altivec vectors. - } }; } @@ -3388,13 +3399,11 @@ public: }; class PPC64_SVR4_TargetCodeGenInfo : public TargetCodeGenInfo { - bool HasQPX; public: PPC64_SVR4_TargetCodeGenInfo(CodeGenTypes &CGT, PPC64_SVR4_ABIInfo::ABIKind Kind, bool HasQPX) - : TargetCodeGenInfo(new PPC64_SVR4_ABIInfo(CGT, Kind, HasQPX)), - HasQPX(HasQPX) {} + : TargetCodeGenInfo(new PPC64_SVR4_ABIInfo(CGT, Kind, HasQPX)) {} int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override { // This is recovered from gcc output. @@ -3403,15 +3412,6 @@ public: bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, llvm::Value *Address) const override; - - unsigned getOpenMPSimdDefaultAlignment(QualType QT) const override { - if (HasQPX) - if (const PointerType *PT = QT->getAs<PointerType>()) - if (PT->getPointeeType()->isSpecificBuiltinType(BuiltinType::Double)) - return 32; // Natural alignment for QPX doubles. - - return 16; // Natural alignment for Altivec and VSX vectors. - } }; class PPC64TargetCodeGenInfo : public DefaultTargetCodeGenInfo { @@ -3425,10 +3425,6 @@ public: bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, llvm::Value *Address) const override; - - unsigned getOpenMPSimdDefaultAlignment(QualType) const override { - return 16; // Natural alignment for Altivec vectors. - } }; } @@ -7194,13 +7190,21 @@ const TargetCodeGenInfo &CodeGenModule::getTargetCodeGenInfo() { } case llvm::Triple::x86_64: { + StringRef ABI = getTarget().getABI(); + X86AVXABILevel AVXLevel = (ABI == "avx512" ? X86AVXABILevel::AVX512 : + ABI == "avx" ? X86AVXABILevel::AVX : + X86AVXABILevel::None); + switch (Triple.getOS()) { case llvm::Triple::Win32: - return *(TheTargetCodeGenInfo = new WinX86_64TargetCodeGenInfo(Types)); + return *(TheTargetCodeGenInfo = + new WinX86_64TargetCodeGenInfo(Types, AVXLevel)); case llvm::Triple::PS4: - return *(TheTargetCodeGenInfo = new PS4TargetCodeGenInfo(Types)); + return *(TheTargetCodeGenInfo = + new PS4TargetCodeGenInfo(Types, AVXLevel)); default: - return *(TheTargetCodeGenInfo = new X86_64TargetCodeGenInfo(Types)); + return *(TheTargetCodeGenInfo = + new X86_64TargetCodeGenInfo(Types, AVXLevel)); } } case llvm::Triple::hexagon: diff --git a/lib/CodeGen/TargetInfo.h b/lib/CodeGen/TargetInfo.h index bf63265f0283..95275d5d42ee 100644 --- a/lib/CodeGen/TargetInfo.h +++ b/lib/CodeGen/TargetInfo.h @@ -218,13 +218,6 @@ public: virtual void getDetectMismatchOption(llvm::StringRef Name, llvm::StringRef Value, llvm::SmallString<32> &Opt) const {} - - /// Gets the target-specific default alignment used when an 'aligned' clause - /// is used with a 'simd' OpenMP directive without specifying a specific - /// alignment. - virtual unsigned getOpenMPSimdDefaultAlignment(QualType Type) const { - return 0; - } }; } diff --git a/lib/Driver/CMakeLists.txt b/lib/Driver/CMakeLists.txt index 412840b6ea6e..fa0430e211b9 100644 --- a/lib/Driver/CMakeLists.txt +++ b/lib/Driver/CMakeLists.txt @@ -10,6 +10,7 @@ add_clang_library(clangDriver Driver.cpp DriverOptions.cpp Job.cpp + MinGWToolChain.cpp Multilib.cpp MSVCToolChain.cpp Phases.cpp diff --git a/lib/Driver/Compilation.cpp b/lib/Driver/Compilation.cpp index 2bcbd5cf943c..101d1fcc832a 100644 --- a/lib/Driver/Compilation.cpp +++ b/lib/Driver/Compilation.cpp @@ -192,18 +192,14 @@ static bool InputsOk(const Command &C, return !ActionFailed(&C.getSource(), FailingCommands); } -void Compilation::ExecuteJob(const Job &J, - FailingCommandList &FailingCommands) const { - if (const Command *C = dyn_cast<Command>(&J)) { - if (!InputsOk(*C, FailingCommands)) - return; +void Compilation::ExecuteJobs(const JobList &Jobs, + FailingCommandList &FailingCommands) const { + for (const auto &Job : Jobs) { + if (!InputsOk(Job, FailingCommands)) + continue; const Command *FailingCommand = nullptr; - if (int Res = ExecuteCommand(*C, FailingCommand)) + if (int Res = ExecuteCommand(Job, FailingCommand)) FailingCommands.push_back(std::make_pair(Res, FailingCommand)); - } else { - const JobList *Jobs = cast<JobList>(&J); - for (const auto &Job : *Jobs) - ExecuteJob(Job, FailingCommands); } } diff --git a/lib/Driver/CrossWindowsToolChain.cpp b/lib/Driver/CrossWindowsToolChain.cpp index 82456e76c75a..ffb1469df21d 100644 --- a/lib/Driver/CrossWindowsToolChain.cpp +++ b/lib/Driver/CrossWindowsToolChain.cpp @@ -108,10 +108,9 @@ AddCXXStdlibLibArgs(const llvm::opt::ArgList &DriverArgs, } Tool *CrossWindowsToolChain::buildLinker() const { - return new tools::CrossWindows::Link(*this); + return new tools::CrossWindows::Linker(*this); } Tool *CrossWindowsToolChain::buildAssembler() const { - return new tools::CrossWindows::Assemble(*this); + return new tools::CrossWindows::Assembler(*this); } - diff --git a/lib/Driver/Driver.cpp b/lib/Driver/Driver.cpp index 0f3ebef2cf2f..b9dc35d6219a 100644 --- a/lib/Driver/Driver.cpp +++ b/lib/Driver/Driver.cpp @@ -58,7 +58,7 @@ Driver::Driver(StringRef ClangExecutable, StringRef DefaultTargetTriple, CCCUsePCH(true), SuppressMissingInputWarning(false) { Name = llvm::sys::path::filename(ClangExecutable); - Dir = llvm::sys::path::parent_path(ClangExecutable); + Dir = llvm::sys::path::parent_path(ClangExecutable); // Compute the path to the resource directory. StringRef ClangResourceDir(CLANG_RESOURCE_DIR); @@ -81,23 +81,23 @@ Driver::~Driver() { void Driver::ParseDriverMode(ArrayRef<const char *> Args) { const std::string OptName = - getOpts().getOption(options::OPT_driver_mode).getPrefixedName(); + getOpts().getOption(options::OPT_driver_mode).getPrefixedName(); - for (size_t I = 0, E = Args.size(); I != E; ++I) { + for (const char *ArgPtr : Args) { // Ingore nullptrs, they are response file's EOL markers - if (Args[I] == nullptr) + if (ArgPtr == nullptr) continue; - const StringRef Arg = Args[I]; + const StringRef Arg = ArgPtr; if (!Arg.startswith(OptName)) continue; const StringRef Value = Arg.drop_front(OptName.size()); const unsigned M = llvm::StringSwitch<unsigned>(Value) - .Case("gcc", GCCMode) - .Case("g++", GXXMode) - .Case("cpp", CPPMode) - .Case("cl", CLMode) - .Default(~0U); + .Case("gcc", GCCMode) + .Case("g++", GXXMode) + .Case("cpp", CPPMode) + .Case("cl", CLMode) + .Default(~0U); if (M != ~0U) Mode = static_cast<DriverMode>(M); @@ -106,42 +106,39 @@ void Driver::ParseDriverMode(ArrayRef<const char *> Args) { } } -InputArgList *Driver::ParseArgStrings(ArrayRef<const char *> ArgStrings) { +InputArgList Driver::ParseArgStrings(ArrayRef<const char *> ArgStrings) { llvm::PrettyStackTraceString CrashInfo("Command line argument parsing"); unsigned IncludedFlagsBitmask; unsigned ExcludedFlagsBitmask; std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) = - getIncludeExcludeOptionFlagMasks(); + getIncludeExcludeOptionFlagMasks(); unsigned MissingArgIndex, MissingArgCount; - InputArgList *Args = getOpts().ParseArgs(ArgStrings.begin(), ArgStrings.end(), - MissingArgIndex, MissingArgCount, - IncludedFlagsBitmask, - ExcludedFlagsBitmask); + InputArgList Args = + getOpts().ParseArgs(ArgStrings, MissingArgIndex, MissingArgCount, + IncludedFlagsBitmask, ExcludedFlagsBitmask); // Check for missing argument error. if (MissingArgCount) Diag(clang::diag::err_drv_missing_argument) - << Args->getArgString(MissingArgIndex) << MissingArgCount; + << Args.getArgString(MissingArgIndex) << MissingArgCount; // Check for unsupported options. - for (const Arg *A : *Args) { + for (const Arg *A : Args) { if (A->getOption().hasFlag(options::Unsupported)) { - Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args); + Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(Args); continue; } // Warn about -mcpu= without an argument. - if (A->getOption().matches(options::OPT_mcpu_EQ) && - A->containsValue("")) { - Diag(clang::diag::warn_drv_empty_joined_argument) << - A->getAsString(*Args); + if (A->getOption().matches(options::OPT_mcpu_EQ) && A->containsValue("")) { + Diag(clang::diag::warn_drv_empty_joined_argument) << A->getAsString(Args); } } - for (const Arg *A : Args->filtered(options::OPT_UNKNOWN)) - Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(*Args); + for (const Arg *A : Args.filtered(options::OPT_UNKNOWN)) + Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(Args); return Args; } @@ -149,14 +146,13 @@ InputArgList *Driver::ParseArgStrings(ArrayRef<const char *> ArgStrings) { // Determine which compilation mode we are in. We look for options which // affect the phase, starting with the earliest phases, and record which // option we used to determine the final phase. -phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg) -const { +phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, + Arg **FinalPhaseArg) const { Arg *PhaseArg = nullptr; phases::ID FinalPhase; // -{E,EP,P,M,MM} only run the preprocessor. - if (CCCIsCPP() || - (PhaseArg = DAL.getLastArg(options::OPT_E)) || + if (CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) || (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) || (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) || (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P))) { @@ -192,7 +188,7 @@ const { return FinalPhase; } -static Arg* MakeInputArg(DerivedArgList &Args, OptTable *Opts, +static Arg *MakeInputArg(DerivedArgList &Args, OptTable *Opts, StringRef Value) { Arg *A = new Arg(Opts->getOption(options::OPT_INPUT), Value, Args.getBaseArgs().MakeIndex(Value), Value.data()); @@ -219,10 +215,9 @@ DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const { DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle)); // Add the remaining values as Xlinker arguments. - for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) - if (StringRef(A->getValue(i)) != "--no-demangle") - DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker), - A->getValue(i)); + for (const StringRef Val : A->getValues()) + if (Val != "--no-demangle") + DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker), Val); continue; } @@ -250,15 +245,13 @@ DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const { // Rewrite unless -nostdlib is present. if (!HasNostdlib && Value == "stdc++") { - DAL->AddFlagArg(A, Opts->getOption( - options::OPT_Z_reserved_lib_stdcxx)); + DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_stdcxx)); continue; } // Rewrite unconditionally. if (Value == "cc_kext") { - DAL->AddFlagArg(A, Opts->getOption( - options::OPT_Z_reserved_lib_cckext)); + DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_cckext)); continue; } } @@ -266,16 +259,16 @@ DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const { // Pick up inputs via the -- option. if (A->getOption().matches(options::OPT__DASH_DASH)) { A->claim(); - for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) - DAL->append(MakeInputArg(*DAL, Opts, A->getValue(i))); + for (const StringRef Val : A->getValues()) + DAL->append(MakeInputArg(*DAL, Opts, Val)); continue; } DAL->append(A); } - // Add a default value of -mlinker-version=, if one was given and the user - // didn't specify one. +// 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) && strlen(HOST_LINK_VERSION) > 0) { @@ -297,8 +290,8 @@ Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) { if (char *env = ::getenv("COMPILER_PATH")) { StringRef CompilerPath = env; while (!CompilerPath.empty()) { - std::pair<StringRef, StringRef> Split - = CompilerPath.split(llvm::sys::EnvPathSeparator); + std::pair<StringRef, StringRef> Split = + CompilerPath.split(llvm::sys::EnvPathSeparator); PrefixDirs.push_back(Split.first); CompilerPath = Split.second; } @@ -311,15 +304,15 @@ Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) { // FIXME: What are we going to do with -V and -b? // FIXME: This stuff needs to go into the Compilation, not the driver. - bool CCCPrintActions; + bool CCCPrintPhases; - InputArgList *Args = ParseArgStrings(ArgList.slice(1)); + InputArgList Args = ParseArgStrings(ArgList.slice(1)); // -no-canonical-prefixes is used very early in main. - Args->ClaimAllArgs(options::OPT_no_canonical_prefixes); + Args.ClaimAllArgs(options::OPT_no_canonical_prefixes); // Ignore -pipe. - Args->ClaimAllArgs(options::OPT_pipe); + Args.ClaimAllArgs(options::OPT_pipe); // Extract -ccc args. // @@ -327,12 +320,12 @@ Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) { // should be outside in the client; the parts that aren't should have proper // options, either by introducing new ones or by overloading gcc ones like -V // or -b. - CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases); - CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings); - if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name)) + CCCPrintPhases = Args.hasArg(options::OPT_ccc_print_phases); + CCCPrintBindings = Args.hasArg(options::OPT_ccc_print_bindings); + if (const Arg *A = Args.getLastArg(options::OPT_ccc_gcc_name)) CCCGenericGCCName = A->getValue(); - CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch, - options::OPT_ccc_pch_is_pth); + CCCUsePCH = + Args.hasFlag(options::OPT_ccc_pch_is_pch, options::OPT_ccc_pch_is_pth); // FIXME: DefaultTargetTriple is used by the target-prefixed calls to as/ld // and getToolChain is const. if (IsCLMode()) { @@ -342,39 +335,42 @@ Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) { T.setEnvironment(llvm::Triple::MSVC); DefaultTargetTriple = T.str(); } - if (const Arg *A = Args->getLastArg(options::OPT_target)) + if (const Arg *A = Args.getLastArg(options::OPT_target)) DefaultTargetTriple = A->getValue(); - if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir)) + if (const Arg *A = Args.getLastArg(options::OPT_ccc_install_dir)) Dir = InstalledDir = A->getValue(); - for (const Arg *A : Args->filtered(options::OPT_B)) { + for (const Arg *A : Args.filtered(options::OPT_B)) { A->claim(); PrefixDirs.push_back(A->getValue(0)); } - if (const Arg *A = Args->getLastArg(options::OPT__sysroot_EQ)) + if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) SysRoot = A->getValue(); - if (const Arg *A = Args->getLastArg(options::OPT__dyld_prefix_EQ)) + if (const Arg *A = Args.getLastArg(options::OPT__dyld_prefix_EQ)) DyldPrefix = A->getValue(); - if (Args->hasArg(options::OPT_nostdlib)) + if (Args.hasArg(options::OPT_nostdlib)) UseStdLib = false; - if (const Arg *A = Args->getLastArg(options::OPT_resource_dir)) + if (const Arg *A = Args.getLastArg(options::OPT_resource_dir)) ResourceDir = A->getValue(); - if (const Arg *A = Args->getLastArg(options::OPT_save_temps_EQ)) { + if (const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) { SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue()) .Case("cwd", SaveTempsCwd) .Case("obj", SaveTempsObj) .Default(SaveTempsCwd); } + std::unique_ptr<llvm::opt::InputArgList> UArgs = + llvm::make_unique<InputArgList>(std::move(Args)); + // Perform the default argument translations. - DerivedArgList *TranslatedArgs = TranslateInputArgs(*Args); + DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs); // Owned by the host. - const ToolChain &TC = getToolChain(*Args); + const ToolChain &TC = getToolChain(*UArgs); // The compilation takes ownership of Args. - Compilation *C = new Compilation(*this, TC, Args, TranslatedArgs); + Compilation *C = new Compilation(*this, TC, UArgs.release(), TranslatedArgs); if (!HandleImmediateArgs(*C)) return C; @@ -386,13 +382,13 @@ Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) { // Construct the list of abstract actions to perform for this compilation. On // MachO targets this uses the driver-driver and universal actions. if (TC.getTriple().isOSBinFormatMachO()) - BuildUniversalActions(C->getDefaultToolChain(), C->getArgs(), - Inputs, C->getActions()); + BuildUniversalActions(C->getDefaultToolChain(), C->getArgs(), Inputs, + C->getActions()); else BuildActions(C->getDefaultToolChain(), C->getArgs(), Inputs, C->getActions()); - if (CCCPrintActions) { + if (CCCPrintPhases) { PrintActions(*C); return C; } @@ -419,8 +415,8 @@ void Driver::generateCompilationDiagnostics(Compilation &C, PrintVersion(C, llvm::errs()); Diag(clang::diag::note_drv_command_failed_diag_msg) - << "PLEASE submit a bug report to " BUG_REPORT_URL " and include the " - "crash backtrace, preprocessed source, and associated run script."; + << "PLEASE submit a bug report to " BUG_REPORT_URL " and include the " + "crash backtrace, preprocessed source, and associated run script."; // Suppress driver output and emit preprocessor output to temp file. Mode = CPPMode; @@ -445,12 +441,12 @@ void Driver::generateCompilationDiagnostics(Compilation &C, // Ignore input from stdin or any inputs that cannot be preprocessed. // Check type first as not all linker inputs have a value. - if (types::getPreprocessedType(it->first) == types::TY_INVALID) { + if (types::getPreprocessedType(it->first) == types::TY_INVALID) { IgnoreInput = true; } else if (!strcmp(it->second->getValue(), "-")) { Diag(clang::diag::note_drv_command_failed_diag_msg) - << "Error generating preprocessed source(s) - ignoring input from stdin" - "."; + << "Error generating preprocessed source(s) - " + "ignoring input from stdin."; IgnoreInput = true; } @@ -464,7 +460,8 @@ void Driver::generateCompilationDiagnostics(Compilation &C, if (Inputs.empty()) { Diag(clang::diag::note_drv_command_failed_diag_msg) - << "Error generating preprocessed source(s) - no preprocessable inputs."; + << "Error generating preprocessed source(s) - " + "no preprocessable inputs."; return; } @@ -479,8 +476,8 @@ void Driver::generateCompilationDiagnostics(Compilation &C, } if (ArchNames.size() > 1) { Diag(clang::diag::note_drv_command_failed_diag_msg) - << "Error generating preprocessed source(s) - cannot generate " - "preprocessed source with multiple -arch options."; + << "Error generating preprocessed source(s) - cannot generate " + "preprocessed source with multiple -arch options."; return; } @@ -497,13 +494,13 @@ void Driver::generateCompilationDiagnostics(Compilation &C, // If there were errors building the compilation, quit now. if (Trap.hasErrorOccurred()) { Diag(clang::diag::note_drv_command_failed_diag_msg) - << "Error generating preprocessed source(s)."; + << "Error generating preprocessed source(s)."; return; } // Generate preprocessed output. SmallVector<std::pair<int, const Command *>, 4> FailingCommands; - C.ExecuteJob(C.getJobs(), FailingCommands); + C.ExecuteJobs(C.getJobs(), FailingCommands); // If any of the preprocessing commands failed, clean up and exit. if (!FailingCommands.empty()) { @@ -511,14 +508,14 @@ void Driver::generateCompilationDiagnostics(Compilation &C, C.CleanupFileList(C.getTempFiles(), true); Diag(clang::diag::note_drv_command_failed_diag_msg) - << "Error generating preprocessed source(s)."; + << "Error generating preprocessed source(s)."; return; } const ArgStringList &TempFiles = C.getTempFiles(); if (TempFiles.empty()) { Diag(clang::diag::note_drv_command_failed_diag_msg) - << "Error generating preprocessed source(s)."; + << "Error generating preprocessed source(s)."; return; } @@ -563,31 +560,22 @@ void Driver::generateCompilationDiagnostics(Compilation &C, << "\n\n********************"; } -void Driver::setUpResponseFiles(Compilation &C, Job &J) { - if (JobList *Jobs = dyn_cast<JobList>(&J)) { - for (auto &Job : *Jobs) - setUpResponseFiles(C, Job); - return; - } - - Command *CurCommand = dyn_cast<Command>(&J); - if (!CurCommand) - return; - +void Driver::setUpResponseFiles(Compilation &C, Command &Cmd) { // Since argumentsFitWithinSystemLimits() may underestimate system's capacity // if the tool does not support response files, there is a chance/ that things // will just work without a response file, so we silently just skip it. - if (CurCommand->getCreator().getResponseFilesSupport() == Tool::RF_None || - llvm::sys::argumentsFitWithinSystemLimits(CurCommand->getArguments())) + if (Cmd.getCreator().getResponseFilesSupport() == Tool::RF_None || + llvm::sys::argumentsFitWithinSystemLimits(Cmd.getArguments())) return; std::string TmpName = GetTemporaryPath("response", "txt"); - CurCommand->setResponseFile(C.addTempFile(C.getArgs().MakeArgString( - TmpName.c_str()))); + Cmd.setResponseFile( + C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()))); } -int Driver::ExecuteCompilation(Compilation &C, - SmallVectorImpl< std::pair<int, const Command *> > &FailingCommands) { +int Driver::ExecuteCompilation( + Compilation &C, + SmallVectorImpl<std::pair<int, const Command *>> &FailingCommands) { // Just print if -### was present. if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) { C.getJobs().Print(llvm::errs(), "\n", true); @@ -599,9 +587,10 @@ int Driver::ExecuteCompilation(Compilation &C, return 1; // Set up response file names for each command, if necessary - setUpResponseFiles(C, C.getJobs()); + for (auto &Job : C.getJobs()) + setUpResponseFiles(C, Job); - C.ExecuteJob(C.getJobs(), FailingCommands); + C.ExecuteJobs(C.getJobs(), FailingCommands); // Remove temp files. C.CleanupFileList(C.getTempFiles()); @@ -612,10 +601,9 @@ int Driver::ExecuteCompilation(Compilation &C, // Otherwise, remove result files and print extra information about abnormal // failures. - for (SmallVectorImpl< std::pair<int, const Command *> >::iterator it = - FailingCommands.begin(), ie = FailingCommands.end(); it != ie; ++it) { - int Res = it->first; - const Command *FailingCommand = it->second; + for (const auto &CmdPair : FailingCommands) { + int Res = CmdPair.first; + const Command *FailingCommand = CmdPair.second; // Remove result files if we're not saving temps. if (!isSaveTempsEnabled()) { @@ -640,10 +628,10 @@ int Driver::ExecuteCompilation(Compilation &C, // FIXME: See FIXME above regarding result code interpretation. if (Res < 0) Diag(clang::diag::err_drv_command_signalled) - << FailingTool.getShortName(); + << FailingTool.getShortName(); else - Diag(clang::diag::err_drv_command_failed) - << FailingTool.getShortName() << Res; + Diag(clang::diag::err_drv_command_failed) << FailingTool.getShortName() + << Res; } } return 0; @@ -653,7 +641,7 @@ void Driver::PrintHelp(bool ShowHidden) const { unsigned IncludedFlagsBitmask; unsigned ExcludedFlagsBitmask; std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) = - getIncludeExcludeOptionFlagMasks(); + getIncludeExcludeOptionFlagMasks(); ExcludedFlagsBitmask |= options::NoDriverOption; if (!ShowHidden) @@ -684,8 +672,8 @@ void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const { /// option. static void PrintDiagnosticCategories(raw_ostream &OS) { // Skip the empty category. - for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories(); - i != max; ++i) + for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories(); i != max; + ++i) OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n'; } @@ -739,25 +727,26 @@ bool Driver::HandleImmediateArgs(const Compilation &C) { if (C.getArgs().hasArg(options::OPT_print_search_dirs)) { llvm::outs() << "programs: ="; - for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(), - ie = TC.getProgramPaths().end(); it != ie; ++it) { - if (it != TC.getProgramPaths().begin()) + bool separator = false; + for (const std::string &Path : TC.getProgramPaths()) { + if (separator) llvm::outs() << ':'; - llvm::outs() << *it; + llvm::outs() << Path; + separator = true; } llvm::outs() << "\n"; llvm::outs() << "libraries: =" << ResourceDir; StringRef sysroot = C.getSysRoot(); - for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(), - ie = TC.getFilePaths().end(); it != ie; ++it) { + for (const std::string &Path : TC.getFilePaths()) { + // Always print a separator. ResourceDir was the first item shown. llvm::outs() << ':'; - const char *path = it->c_str(); - if (path[0] == '=') - llvm::outs() << sysroot << path + 1; + // Interpretation of leading '=' is needed only for NetBSD. + if (Path[0] == '=') + llvm::outs() << sysroot << Path.substr(1); else - llvm::outs() << path; + llvm::outs() << Path; } llvm::outs() << "\n"; return false; @@ -781,23 +770,17 @@ bool Driver::HandleImmediateArgs(const Compilation &C) { } if (C.getArgs().hasArg(options::OPT_print_multi_lib)) { - const MultilibSet &Multilibs = TC.getMultilibs(); - - for (MultilibSet::const_iterator I = Multilibs.begin(), E = Multilibs.end(); - I != E; ++I) { - llvm::outs() << *I << "\n"; - } + for (const Multilib &Multilib : TC.getMultilibs()) + llvm::outs() << Multilib << "\n"; return false; } if (C.getArgs().hasArg(options::OPT_print_multi_directory)) { - const MultilibSet &Multilibs = TC.getMultilibs(); - for (MultilibSet::const_iterator I = Multilibs.begin(), E = Multilibs.end(); - I != E; ++I) { - if (I->gccSuffix().empty()) + for (const Multilib &Multilib : TC.getMultilibs()) { + if (Multilib.gccSuffix().empty()) llvm::outs() << ".\n"; else { - StringRef Suffix(I->gccSuffix()); + StringRef Suffix(Multilib.gccSuffix()); assert(Suffix.front() == '/'); llvm::outs() << Suffix.substr(1) << "\n"; } @@ -819,7 +802,7 @@ bool Driver::HandleImmediateArgs(const Compilation &C) { // 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) { + std::map<Action *, unsigned> &Ids) { if (Ids.count(A)) // A was already visited. return Ids[A]; @@ -830,15 +813,13 @@ static unsigned PrintActions1(const Compilation &C, Action *A, if (InputAction *IA = dyn_cast<InputAction>(A)) { os << "\"" << IA->getInputArg().getValue() << "\""; } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) { - os << '"' << BIA->getArchName() << '"' - << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}"; + os << '"' << BIA->getArchName() << '"' << ", {" + << PrintActions1(C, *BIA->begin(), Ids) << "}"; } else { - os << "{"; - for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) { - os << PrintActions1(C, *it, Ids); - ++it; - if (it != ie) - os << ", "; + const char *Prefix = "{"; + for (Action *PreRequisite : *A) { + os << Prefix << PrintActions1(C, PreRequisite, Ids); + Prefix = ", "; } os << "}"; } @@ -854,17 +835,15 @@ static unsigned PrintActions1(const Compilation &C, Action *A, // 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(), - ie = C.getActions().end(); it != ie; ++it) - PrintActions1(C, *it, Ids); + std::map<Action *, unsigned> Ids; + for (Action *A : C.getActions()) + PrintActions1(C, A, Ids); } /// \brief Check whether the given input tree contains any compilation or /// assembly actions. static bool ContainsCompileOrAssembleAction(const Action *A) { - if (isa<CompileJobAction>(A) || - isa<BackendJobAction>(A) || + if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A) || isa<AssembleJobAction>(A)) return true; @@ -875,8 +854,7 @@ static bool ContainsCompileOrAssembleAction(const Action *A) { return false; } -void Driver::BuildUniversalActions(const ToolChain &TC, - DerivedArgList &Args, +void Driver::BuildUniversalActions(const ToolChain &TC, DerivedArgList &Args, const InputList &BAInputs, ActionList &Actions) const { llvm::PrettyStackTraceString CrashInfo("Building universal build actions"); @@ -889,10 +867,9 @@ void Driver::BuildUniversalActions(const ToolChain &TC, // Validate the option here; we don't save the type here because its // particular spelling may participate in other driver choices. llvm::Triple::ArchType Arch = - tools::darwin::getArchTypeForMachOArchName(A->getValue()); + tools::darwin::getArchTypeForMachOArchName(A->getValue()); if (Arch == llvm::Triple::UnknownArch) { - Diag(clang::diag::err_drv_invalid_arch_name) - << A->getAsString(Args); + Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args); continue; } @@ -923,7 +900,7 @@ void Driver::BuildUniversalActions(const ToolChain &TC, if (Archs.size() > 1 && !types::canLipoType(Act->getType())) Diag(clang::diag::err_drv_invalid_output_with_multiple_archs) - << types::getTypeName(Act->getType()); + << types::getTypeName(Act->getType()); ActionList Inputs; for (unsigned i = 0, e = Archs.size(); i != e; ++i) { @@ -1013,10 +990,11 @@ void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args, options::OPT__SLASH_TP)) { InputTypeArg = TCTP; InputType = TCTP->getOption().matches(options::OPT__SLASH_TC) - ? types::TY_C : types::TY_CXX; + ? types::TY_C + : types::TY_CXX; - arg_iterator it = Args.filtered_begin(options::OPT__SLASH_TC, - options::OPT__SLASH_TP); + arg_iterator it = + Args.filtered_begin(options::OPT__SLASH_TC, options::OPT__SLASH_TP); const arg_iterator ie = Args.filtered_end(); Arg *Previous = *it++; bool ShowNote = false; @@ -1078,7 +1056,7 @@ void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args, if (Ty != OldTy) Diag(clang::diag::warn_drv_treating_input_as_cxx) - << getTypeName(OldTy) << getTypeName(Ty); + << getTypeName(OldTy) << getTypeName(Ty); } } @@ -1180,7 +1158,7 @@ void Driver::BuildActions(const ToolChain &TC, DerivedArgList &Args, !llvm::sys::path::is_separator(V.back())) { // Check whether /Fo tries to name an output file for multiple inputs. Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources) - << A->getSpelling() << V; + << A->getSpelling() << V; Args.eraseArg(options::OPT__SLASH_Fo); } } @@ -1192,7 +1170,7 @@ void Driver::BuildActions(const ToolChain &TC, DerivedArgList &Args, !llvm::sys::path::is_separator(V.back())) { // Check whether /Fa tries to name an asm file for multiple inputs. Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources) - << A->getSpelling() << V; + << A->getSpelling() << V; Args.eraseArg(options::OPT__SLASH_Fa); } } @@ -1232,30 +1210,27 @@ void Driver::BuildActions(const ToolChain &TC, DerivedArgList &Args, // by a command-line argument with a corresponding Arg. if (CCCIsCPP()) Diag(clang::diag::warn_drv_input_file_unused_by_cpp) - << InputArg->getAsString(Args) - << getPhaseName(InitialPhase); + << InputArg->getAsString(Args) << getPhaseName(InitialPhase); // Special case '-E' warning on a previously preprocessed file to make // more sense. else if (InitialPhase == phases::Compile && FinalPhase == phases::Preprocess && getPreprocessedType(InputType) == types::TY_INVALID) Diag(clang::diag::warn_drv_preprocessed_input_file_unused) - << InputArg->getAsString(Args) - << !!FinalPhaseArg - << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : ""); + << InputArg->getAsString(Args) << !!FinalPhaseArg + << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : ""); else Diag(clang::diag::warn_drv_input_file_unused) - << InputArg->getAsString(Args) - << getPhaseName(InitialPhase) - << !!FinalPhaseArg - << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : ""); + << InputArg->getAsString(Args) << getPhaseName(InitialPhase) + << !!FinalPhaseArg + << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : ""); continue; } // Build the pipeline for this file. std::unique_ptr<Action> Current(new InputAction(*InputArg, InputType)); - for (SmallVectorImpl<phases::ID>::iterator - i = PL.begin(), e = PL.end(); i != e; ++i) { + for (SmallVectorImpl<phases::ID>::iterator i = PL.begin(), e = PL.end(); + i != e; ++i) { phases::ID Phase = *i; // We are done if this step is past what the user requested. @@ -1308,7 +1283,8 @@ Driver::ConstructPhaseAction(const ToolChain &TC, const ArgList &Args, llvm::PrettyStackTraceString CrashInfo("Constructing phase actions"); // Build the appropriate action. switch (Phase) { - case phases::Link: llvm_unreachable("link action invalid here."); + case phases::Link: + llvm_unreachable("link action invalid here."); case phases::Preprocess: { types::ID OutputTy; // -{M, MM} alter the output type. @@ -1364,12 +1340,12 @@ Driver::ConstructPhaseAction(const ToolChain &TC, const ArgList &Args, case phases::Backend: { if (IsUsingLTO(Args)) { types::ID Output = - Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC; + Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC; return llvm::make_unique<BackendJobAction>(std::move(Input), Output); } if (Args.hasArg(options::OPT_emit_llvm)) { types::ID Output = - Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC; + Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC; return llvm::make_unique<BackendJobAction>(std::move(Input), Output); } return llvm::make_unique<BackendJobAction>(std::move(Input), @@ -1430,11 +1406,10 @@ void Driver::BuildJobs(Compilation &C) const { InputInfo II; BuildJobsForAction(C, A, &C.getDefaultToolChain(), - /*BoundArch*/nullptr, + /*BoundArch*/ nullptr, /*AtTopLevel*/ true, /*MultipleArchs*/ ArchNames.size() > 1, - /*LinkingOutput*/ LinkingOutput, - II); + /*LinkingOutput*/ LinkingOutput, II); } // If the user passed -Qunused-arguments or there were errors, don't warn @@ -1444,10 +1419,10 @@ void Driver::BuildJobs(Compilation &C) const { return; // Claim -### here. - (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH); + (void)C.getArgs().hasArg(options::OPT__HASH_HASH_HASH); // Claim --driver-mode, it was handled earlier. - (void) C.getArgs().hasArg(options::OPT_driver_mode); + (void)C.getArgs().hasArg(options::OPT_driver_mode); for (Arg *A : C.getArgs()) { // FIXME: It would be nice to be able to send the argument to the @@ -1475,7 +1450,7 @@ void Driver::BuildJobs(Compilation &C) const { } Diag(clang::diag::warn_drv_unused_argument) - << A->getAsString(C.getArgs()); + << A->getAsString(C.getArgs()); } } } @@ -1489,13 +1464,12 @@ static const Tool *SelectToolForJob(Compilation &C, bool SaveTemps, // bottom up, so what we are actually looking for is an assembler job with a // compiler input. - if (TC->useIntegratedAs() && - !SaveTemps && + if (TC->useIntegratedAs() && !SaveTemps && !C.getArgs().hasArg(options::OPT_via_file_asm) && !C.getArgs().hasArg(options::OPT__SLASH_FA) && !C.getArgs().hasArg(options::OPT__SLASH_Fa) && - isa<AssembleJobAction>(JA) && - Inputs->size() == 1 && isa<BackendJobAction>(*Inputs->begin())) { + isa<AssembleJobAction>(JA) && Inputs->size() == 1 && + isa<BackendJobAction>(*Inputs->begin())) { // A BackendJob is always preceded by a CompileJob, and without // -save-temps they will always get combined together, so instead of // checking the backend tool, check if the tool for the CompileJob @@ -1536,8 +1510,7 @@ static const Tool *SelectToolForJob(Compilation &C, bool SaveTemps, // (irrelevant since we don't support combine yet). if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) && !C.getArgs().hasArg(options::OPT_no_integrated_cpp) && - !C.getArgs().hasArg(options::OPT_traditional_cpp) && - !SaveTemps && + !C.getArgs().hasArg(options::OPT_traditional_cpp) && !SaveTemps && !C.getArgs().hasArg(options::OPT_rewrite_objc) && ToolForJob->hasIntegratedCPP()) Inputs = &(*Inputs)[0]->getInputs(); @@ -1545,12 +1518,9 @@ static const Tool *SelectToolForJob(Compilation &C, bool SaveTemps, return ToolForJob; } -void Driver::BuildJobsForAction(Compilation &C, - const Action *A, - const ToolChain *TC, - const char *BoundArch, - bool AtTopLevel, - bool MultipleArchs, +void Driver::BuildJobsForAction(Compilation &C, const Action *A, + const ToolChain *TC, const char *BoundArch, + bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput, InputInfo &Result) const { llvm::PrettyStackTraceString CrashInfo("Building compilation jobs"); @@ -1578,8 +1548,8 @@ void Driver::BuildJobsForAction(Compilation &C, else TC = &C.getDefaultToolChain(); - BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(), - AtTopLevel, MultipleArchs, LinkingOutput, Result); + BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(), AtTopLevel, + MultipleArchs, LinkingOutput, Result); return; } @@ -1647,7 +1617,8 @@ const char *Driver::getDefaultImageName() const { /// does not provide a filename, then use BaseName, and use the extension /// suitable for FileType. static const char *MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue, - StringRef BaseName, types::ID FileType) { + StringRef BaseName, + types::ID FileType) { SmallString<128> Filename = ArgValue; if (ArgValue.empty()) { @@ -1674,16 +1645,13 @@ static const char *MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue, return Args.MakeArgString(Filename.c_str()); } -const char *Driver::GetNamedOutputPath(Compilation &C, - const JobAction &JA, +const char *Driver::GetNamedOutputPath(Compilation &C, const JobAction &JA, const char *BaseInput, - const char *BoundArch, - bool AtTopLevel, + const char *BoundArch, bool AtTopLevel, bool MultipleArchs) const { llvm::PrettyStackTraceString CrashInfo("Computing output path"); // Output to a user requested destination? - if (AtTopLevel && !isa<DsymutilJobAction>(JA) && - !isa<VerifyJobAction>(JA)) { + if (AtTopLevel && !isa<DsymutilJobAction>(JA) && !isa<VerifyJobAction>(JA)) { if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) return C.addResultFile(FinalOutput->getValue(), &JA); } @@ -1695,8 +1663,9 @@ const char *Driver::GetNamedOutputPath(Compilation &C, StringRef NameArg; if (Arg *A = C.getArgs().getLastArg(options::OPT__SLASH_Fi)) NameArg = A->getValue(); - return C.addResultFile(MakeCLOutputFilename(C.getArgs(), NameArg, BaseName, - types::TY_PP_C), &JA); + return C.addResultFile( + MakeCLOutputFilename(C.getArgs(), NameArg, BaseName, types::TY_PP_C), + &JA); } // Default to writing to stdout? @@ -1711,19 +1680,19 @@ const char *Driver::GetNamedOutputPath(Compilation &C, // Use /Fa and the input filename to determine the asm file name. StringRef BaseName = llvm::sys::path::filename(BaseInput); StringRef FaValue = C.getArgs().getLastArgValue(options::OPT__SLASH_Fa); - return C.addResultFile(MakeCLOutputFilename(C.getArgs(), FaValue, BaseName, - JA.getType()), &JA); + return C.addResultFile( + MakeCLOutputFilename(C.getArgs(), FaValue, BaseName, JA.getType()), + &JA); } // Output to a temporary file? if ((!AtTopLevel && !isSaveTempsEnabled() && - !C.getArgs().hasArg(options::OPT__SLASH_Fo)) || + !C.getArgs().hasArg(options::OPT__SLASH_Fo)) || CCGenDiagnostics) { StringRef Name = llvm::sys::path::filename(BaseInput); std::pair<StringRef, StringRef> Split = Name.split('.'); - std::string TmpName = - GetTemporaryPath(Split.first, - types::getTypeTempSuffix(JA.getType(), IsCLMode())); + std::string TmpName = GetTemporaryPath( + Split.first, types::getTypeTempSuffix(JA.getType(), IsCLMode())); return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())); } @@ -1742,22 +1711,27 @@ const char *Driver::GetNamedOutputPath(Compilation &C, 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, - options::OPT__SLASH_o)->getValue(); - NamedOutput = MakeCLOutputFilename(C.getArgs(), Val, BaseName, - types::TY_Object); + StringRef Val = + C.getArgs() + .getLastArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o) + ->getValue(); + NamedOutput = + MakeCLOutputFilename(C.getArgs(), Val, BaseName, types::TY_Object); } else if (JA.getType() == types::TY_Image && - C.getArgs().hasArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o)) { + C.getArgs().hasArg(options::OPT__SLASH_Fe, + options::OPT__SLASH_o)) { // The /Fe or /o flag names the linked file. - StringRef Val = C.getArgs().getLastArg(options::OPT__SLASH_Fe, - options::OPT__SLASH_o)->getValue(); - NamedOutput = MakeCLOutputFilename(C.getArgs(), Val, BaseName, - types::TY_Image); + StringRef Val = + C.getArgs() + .getLastArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o) + ->getValue(); + NamedOutput = + MakeCLOutputFilename(C.getArgs(), Val, BaseName, types::TY_Image); } else if (JA.getType() == types::TY_Image) { if (IsCLMode()) { // clang-cl uses BaseName for the executable name. - NamedOutput = MakeCLOutputFilename(C.getArgs(), "", BaseName, - types::TY_Image); + NamedOutput = + MakeCLOutputFilename(C.getArgs(), "", BaseName, types::TY_Image); } else if (MultipleArchs && BoundArch) { SmallString<128> Output(getDefaultImageName()); Output += "-"; @@ -1811,9 +1785,8 @@ const char *Driver::GetNamedOutputPath(Compilation &C, if (SameFile) { StringRef Name = llvm::sys::path::filename(BaseInput); std::pair<StringRef, StringRef> Split = Name.split('.'); - std::string TmpName = - GetTemporaryPath(Split.first, - types::getTypeTempSuffix(JA.getType(), IsCLMode())); + std::string TmpName = GetTemporaryPath( + Split.first, types::getTypeTempSuffix(JA.getType(), IsCLMode())); return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())); } } @@ -1834,14 +1807,10 @@ const char *Driver::GetNamedOutputPath(Compilation &C, std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const { // Respect a limited subset of the '-Bprefix' functionality in GCC by // attempting to use this prefix when looking for file paths. - for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(), - ie = PrefixDirs.end(); it != ie; ++it) { - std::string Dir(*it); + for (const std::string &Dir : PrefixDirs) { if (Dir.empty()) continue; - if (Dir[0] == '=') - Dir = SysRoot + Dir.substr(1); - SmallString<128> P(Dir); + SmallString<128> P(Dir[0] == '=' ? SysRoot + Dir.substr(1) : Dir); llvm::sys::path::append(P, Name); if (llvm::sys::fs::exists(Twine(P))) return P.str(); @@ -1852,15 +1821,10 @@ std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const { if (llvm::sys::fs::exists(Twine(P))) return P.str(); - const ToolChain::path_list &List = TC.getFilePaths(); - for (ToolChain::path_list::const_iterator - it = List.begin(), ie = List.end(); it != ie; ++it) { - std::string Dir(*it); + for (const std::string &Dir : TC.getFilePaths()) { if (Dir.empty()) continue; - if (Dir[0] == '=') - Dir = SysRoot + Dir.substr(1); - SmallString<128> P(Dir); + SmallString<128> P(Dir[0] == '=' ? SysRoot + Dir.substr(1) : Dir); llvm::sys::path::append(P, Name); if (llvm::sys::fs::exists(Twine(P))) return P.str(); @@ -1869,9 +1833,9 @@ std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const { return Name; } -void -Driver::generatePrefixedToolNames(const char *Tool, const ToolChain &TC, - SmallVectorImpl<std::string> &Names) const { +void Driver::generatePrefixedToolNames( + const char *Tool, const ToolChain &TC, + SmallVectorImpl<std::string> &Names) const { // FIXME: Needs a better variable than DefaultTargetTriple Names.emplace_back(DefaultTargetTriple + "-" + Tool); Names.emplace_back(Tool); @@ -1923,8 +1887,8 @@ std::string Driver::GetProgramPath(const char *Name, return Name; } -std::string Driver::GetTemporaryPath(StringRef Prefix, const char *Suffix) - const { +std::string Driver::GetTemporaryPath(StringRef Prefix, + const char *Suffix) const { SmallString<128> Path; std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path); if (EC) { @@ -1998,7 +1962,7 @@ static llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple, if (Target.getEnvironment() == llvm::Triple::GNUX32) Target.setEnvironment(llvm::Triple::GNU); } else if (A->getOption().matches(options::OPT_mx32) && - Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) { + Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) { AT = llvm::Triple::x86_64; Target.setEnvironment(llvm::Triple::GNUX32); } else if (A->getOption().matches(options::OPT_m32)) { @@ -2006,7 +1970,7 @@ static llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple, if (Target.getEnvironment() == llvm::Triple::GNUX32) Target.setEnvironment(llvm::Triple::GNU); } else if (A->getOption().matches(options::OPT_m16) && - Target.get32BitArchVariant().getArch() == llvm::Triple::x86) { + Target.get32BitArchVariant().getArch() == llvm::Triple::x86) { AT = llvm::Triple::x86; Target.setEnvironment(llvm::Triple::CODE16); } @@ -2075,12 +2039,7 @@ const ToolChain &Driver::getToolChain(const ArgList &Args, TC = new toolchains::Generic_GCC(*this, Target, Args); break; case llvm::Triple::GNU: - // FIXME: We need a MinGW toolchain. Use the default Generic_GCC - // toolchain for now as the default case would below otherwise. - if (Target.isOSBinFormatELF()) - TC = new toolchains::Generic_ELF(*this, Target, Args); - else - TC = new toolchains::Generic_GCC(*this, Target, Args); + TC = new toolchains::MinGW(*this, Target, Args); break; case llvm::Triple::Itanium: TC = new toolchains::CrossWindowsToolChain(*this, Target, Args); @@ -2116,8 +2075,7 @@ const ToolChain &Driver::getToolChain(const ArgList &Args, bool Driver::ShouldUseClangCompiler(const JobAction &JA) const { // Say "no" if there is not exactly one input of a type clang understands. - if (JA.size() != 1 || - !types::isAcceptedByClang((*JA.begin())->getType())) + if (JA.size() != 1 || !types::isAcceptedByClang((*JA.begin())->getType())) return false; // And say "no" if this is not a kind of action clang understands. @@ -2143,21 +2101,21 @@ bool Driver::GetReleaseVersion(const char *Str, unsigned &Major, return false; char *End; - Major = (unsigned) strtol(Str, &End, 10); + Major = (unsigned)strtol(Str, &End, 10); if (*Str != '\0' && *End == '\0') return true; if (*End != '.') return false; - Str = End+1; - Minor = (unsigned) strtol(Str, &End, 10); + Str = End + 1; + Minor = (unsigned)strtol(Str, &End, 10); if (*Str != '\0' && *End == '\0') return true; if (*End != '.') return false; - Str = End+1; - Micro = (unsigned) strtol(Str, &End, 10); + Str = End + 1; + Micro = (unsigned)strtol(Str, &End, 10); if (*Str != '\0' && *End == '\0') return true; if (Str == End) diff --git a/lib/Driver/Job.cpp b/lib/Driver/Job.cpp index 6d18a41cad08..ac18e1eb56a1 100644 --- a/lib/Driver/Job.cpp +++ b/lib/Driver/Job.cpp @@ -25,14 +25,10 @@ using llvm::raw_ostream; using llvm::StringRef; using llvm::ArrayRef; -Job::~Job() {} - -Command::Command(const Action &_Source, const Tool &_Creator, - const char *_Executable, - const ArgStringList &_Arguments) - : Job(CommandClass), Source(_Source), Creator(_Creator), - Executable(_Executable), Arguments(_Arguments), - ResponseFile(nullptr) {} +Command::Command(const Action &Source, const Tool &Creator, + const char *Executable, const ArgStringList &Arguments) + : Source(Source), Creator(Creator), Executable(Executable), + Arguments(Arguments), ResponseFile(nullptr) {} static int skipArgs(const char *Flag, bool HaveCrashVFS) { // These flags are all of the form -Flag <Arg> and are treated as two @@ -295,8 +291,6 @@ int FallbackCommand::Execute(const StringRef **Redirects, std::string *ErrMsg, return SecondaryStatus; } -JobList::JobList() : Job(JobListClass) {} - void JobList::Print(raw_ostream &OS, const char *Terminator, bool Quote, CrashReportInfo *CrashInfo) const { for (const auto &Job : *this) diff --git a/lib/Driver/MSVCToolChain.cpp b/lib/Driver/MSVCToolChain.cpp index 72161213db05..f20f58a119f4 100644 --- a/lib/Driver/MSVCToolChain.cpp +++ b/lib/Driver/MSVCToolChain.cpp @@ -53,12 +53,12 @@ MSVCToolChain::MSVCToolChain(const Driver &D, const llvm::Triple& Triple, } Tool *MSVCToolChain::buildLinker() const { - return new tools::visualstudio::Link(*this); + return new tools::visualstudio::Linker(*this); } Tool *MSVCToolChain::buildAssembler() const { if (getTriple().isOSBinFormatMachO()) - return new tools::darwin::Assemble(*this); + return new tools::darwin::Assembler(*this); getDriver().Diag(clang::diag::err_no_external_assembler); return nullptr; } diff --git a/lib/Driver/MinGWToolChain.cpp b/lib/Driver/MinGWToolChain.cpp new file mode 100644 index 000000000000..606508da6964 --- /dev/null +++ b/lib/Driver/MinGWToolChain.cpp @@ -0,0 +1,143 @@ +//===--- MinGWToolChain.cpp - MinGWToolChain Implementation +//-----------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "ToolChains.h" +#include "clang/Driver/Driver.h" +#include "clang/Driver/Options.h" +#include "llvm/Option/ArgList.h" +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/Path.h" + +using namespace clang::diag; +using namespace clang::driver; +using namespace clang::driver::toolchains; +using namespace clang; +using namespace llvm::opt; + +MinGW::MinGW(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) + : ToolChain(D, Triple, Args) { + getProgramPaths().push_back(getDriver().getInstalledDir()); + + if (getDriver().SysRoot.size()) + Base = getDriver().SysRoot; + else if (llvm::ErrorOr<std::string> GPPName = + llvm::sys::findProgramByName("gcc")) + Base = llvm::sys::path::parent_path( + llvm::sys::path::parent_path(GPPName.get())); + else + Base = llvm::sys::path::parent_path(getDriver().getInstalledDir()); + Base += llvm::sys::path::get_separator(); + llvm::SmallString<1024> LibDir(Base); + llvm::sys::path::append(LibDir, "lib", "gcc"); + LibDir += llvm::sys::path::get_separator(); + + // First look for mingw-w64. + Arch = getTriple().getArchName(); + Arch += "-w64-mingw32"; + std::error_code EC; + llvm::sys::fs::directory_iterator MingW64Entry(LibDir + Arch, EC); + if (!EC) { + GccLibDir = MingW64Entry->path(); + } else { + // If mingw-w64 not found, try looking for mingw.org. + Arch = "mingw32"; + llvm::sys::fs::directory_iterator MingwOrgEntry(LibDir + Arch, EC); + if (!EC) + GccLibDir = MingwOrgEntry->path(); + } + Arch += llvm::sys::path::get_separator(); + // GccLibDir must precede Base/lib so that the + // correct crtbegin.o ,cetend.o would be found. + getFilePaths().push_back(GccLibDir); + getFilePaths().push_back(Base + "lib"); + getFilePaths().push_back(Base + Arch + "lib"); +} + +bool MinGW::IsIntegratedAssemblerDefault() const { return true; } + +Tool *MinGW::getTool(Action::ActionClass AC) const { + switch (AC) { + case Action::PreprocessJobClass: + if (!Preprocessor) + Preprocessor.reset(new tools::gcc::Preprocessor(*this)); + return Preprocessor.get(); + case Action::CompileJobClass: + if (!Compiler) + Compiler.reset(new tools::gcc::Compiler(*this)); + return Compiler.get(); + default: + return ToolChain::getTool(AC); + } +} + +Tool *MinGW::buildAssembler() const { + return new tools::MinGW::Assembler(*this); +} + +Tool *MinGW::buildLinker() const { return new tools::MinGW::Linker(*this); } + +bool MinGW::IsUnwindTablesDefault() const { + return getArch() == llvm::Triple::x86_64; +} + +bool MinGW::isPICDefault() const { return getArch() == llvm::Triple::x86_64; } + +bool MinGW::isPIEDefault() const { return false; } + +bool MinGW::isPICDefaultForced() const { + return getArch() == llvm::Triple::x86_64; +} + +bool MinGW::UseSEHExceptions() const { + return getArch() == llvm::Triple::x86_64; +} + +void MinGW::AddClangSystemIncludeArgs(const ArgList &DriverArgs, + ArgStringList &CC1Args) const { + if (DriverArgs.hasArg(options::OPT_nostdinc)) + return; + + if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { + SmallString<1024> P(getDriver().ResourceDir); + llvm::sys::path::append(P, "include"); + addSystemInclude(DriverArgs, CC1Args, P.str()); + } + + if (DriverArgs.hasArg(options::OPT_nostdlibinc)) + return; + + llvm::SmallString<1024> IncludeDir(GccLibDir); + llvm::sys::path::append(IncludeDir, "include"); + addSystemInclude(DriverArgs, CC1Args, IncludeDir.c_str()); + IncludeDir += "-fixed"; + addSystemInclude(DriverArgs, CC1Args, IncludeDir.c_str()); + addSystemInclude(DriverArgs, CC1Args, Base + Arch + "include"); + addSystemInclude(DriverArgs, CC1Args, Base + "include"); +} + +void MinGW::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, + ArgStringList &CC1Args) const { + if (DriverArgs.hasArg(options::OPT_nostdlibinc) || + DriverArgs.hasArg(options::OPT_nostdincxx)) + return; + + llvm::SmallString<1024> IncludeDir; + for (bool MingW64 : {true, false}) { + if (MingW64) + IncludeDir = Base + Arch; + else + IncludeDir = GccLibDir; + llvm::sys::path::append(IncludeDir, "include", "c++"); + addSystemInclude(DriverArgs, CC1Args, IncludeDir.str()); + IncludeDir += llvm::sys::path::get_separator(); + addSystemInclude(DriverArgs, CC1Args, IncludeDir.str() + Arch); + addSystemInclude(DriverArgs, CC1Args, IncludeDir.str() + "backward"); + } +} diff --git a/lib/Driver/SanitizerArgs.cpp b/lib/Driver/SanitizerArgs.cpp index 14c37025eb39..3043481c7132 100644 --- a/lib/Driver/SanitizerArgs.cpp +++ b/lib/Driver/SanitizerArgs.cpp @@ -7,6 +7,7 @@ // //===----------------------------------------------------------------------===// #include "clang/Driver/SanitizerArgs.h" +#include "Tools.h" #include "clang/Basic/Sanitizers.h" #include "clang/Driver/Driver.h" #include "clang/Driver/DriverDiagnostic.h" @@ -26,6 +27,7 @@ using namespace llvm::opt; enum : SanitizerMask { NeedsUbsanRt = Undefined | Integer | CFI, + NeedsUbsanCxxRt = Vptr | CFI, NotAllowedWithTrap = Vptr, RequiresPIE = Memory | DataFlow, NeedsUnwindTables = Address | Thread | Memory | DataFlow, @@ -194,7 +196,7 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, SanitizerMask DiagnosedKinds = 0; // All Kinds we have diagnosed up to now. // Used to deduplicate diagnostics. SanitizerMask Kinds = 0; - SanitizerMask Supported = setGroupBits(TC.getSupportedSanitizers()); + const SanitizerMask Supported = setGroupBits(TC.getSupportedSanitizers()); ToolChain::RTTIMode RTTIMode = TC.getRTTIMode(); const Driver &D = TC.getDriver(); @@ -282,6 +284,21 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, << lastArgumentForMask(D, Args, Kinds & NeedsLTO) << "-flto"; } + // Report error if there are non-trapping sanitizers that require + // c++abi-specific parts of UBSan runtime, and they are not provided by the + // toolchain. We don't have a good way to check the latter, so we just + // check if the toolchan supports vptr. + if (~Supported & Vptr) { + if (SanitizerMask KindsToDiagnose = + Kinds & ~TrappingKinds & NeedsUbsanCxxRt) { + SanitizerSet S; + S.Mask = KindsToDiagnose; + D.Diag(diag::err_drv_unsupported_opt_for_target) + << ("-fno-sanitize-trap=" + toString(S)) << TC.getTriple().str(); + Kinds &= ~KindsToDiagnose; + } + } + // Warn about incompatible groups of sanitizers. std::pair<SanitizerMask, SanitizerMask> IncompatibleGroups[] = { std::make_pair(Address, Thread), std::make_pair(Address, Memory), @@ -517,8 +534,9 @@ static std::string toString(const clang::SanitizerSet &Sanitizers) { return Res; } -void SanitizerArgs::addArgs(const llvm::opt::ArgList &Args, - llvm::opt::ArgStringList &CmdArgs) const { +void SanitizerArgs::addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs, + types::ID InputType) const { if (Sanitizers.empty()) return; CmdArgs.push_back(Args.MakeArgString("-fsanitize=" + toString(Sanitizers))); @@ -565,6 +583,17 @@ void SanitizerArgs::addArgs(const llvm::opt::ArgList &Args, // affect compilation. if (Sanitizers.has(Memory) || Sanitizers.has(Address)) CmdArgs.push_back(Args.MakeArgString("-fno-assume-sane-operator-new")); + + if (TC.getTriple().isOSWindows() && needsUbsanRt()) { + // Instruct the code generator to embed linker directives in the object file + // that cause the required runtime libraries to be linked. + CmdArgs.push_back(Args.MakeArgString( + "--dependent-lib=" + tools::getCompilerRT(TC, "ubsan_standalone"))); + if (types::isCXX(InputType)) + CmdArgs.push_back( + Args.MakeArgString("--dependent-lib=" + + tools::getCompilerRT(TC, "ubsan_standalone_cxx"))); + } } SanitizerMask parseArgValues(const Driver &D, const llvm::opt::Arg *A, diff --git a/lib/Driver/ToolChains.cpp b/lib/Driver/ToolChains.cpp index 987e063039ca..df74b41b0225 100644 --- a/lib/Driver/ToolChains.cpp +++ b/lib/Driver/ToolChains.cpp @@ -39,9 +39,8 @@ using namespace clang::driver::toolchains; using namespace clang; using namespace llvm::opt; -MachO::MachO(const Driver &D, const llvm::Triple &Triple, - const ArgList &Args) - : ToolChain(D, Triple, Args) { +MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) + : ToolChain(D, Triple, Args) { // We expect 'as', 'ld', etc. to be adjacent to our install dir. getProgramPaths().push_back(getDriver().getInstalledDir()); if (getDriver().getInstalledDir() != getDriver().Dir) @@ -62,9 +61,7 @@ types::ID MachO::LookupTypeForExtension(const char *Ext) const { return Ty; } -bool MachO::HasNativeLLVMSupport() const { - return true; -} +bool MachO::HasNativeLLVMSupport() const { return true; } /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0. ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const { @@ -90,20 +87,20 @@ bool Darwin::hasBlocksRuntime() const { // other assumptions. Maybe MachO should consider standardising // their nomenclature. static const char *ArmMachOArchName(StringRef Arch) { - return llvm::StringSwitch<const char*>(Arch) - .Case("armv6k", "armv6") - .Case("armv6m", "armv6m") - .Case("armv5tej", "armv5") - .Case("xscale", "xscale") - .Case("armv4t", "armv4t") - .Case("armv7", "armv7") - .Cases("armv7a", "armv7-a", "armv7") - .Cases("armv7r", "armv7-r", "armv7") - .Cases("armv7em", "armv7e-m", "armv7em") - .Cases("armv7k", "armv7-k", "armv7k") - .Cases("armv7m", "armv7-m", "armv7m") - .Cases("armv7s", "armv7-s", "armv7s") - .Default(nullptr); + return llvm::StringSwitch<const char *>(Arch) + .Case("armv6k", "armv6") + .Case("armv6m", "armv6m") + .Case("armv5tej", "armv5") + .Case("xscale", "xscale") + .Case("armv4t", "armv4t") + .Case("armv7", "armv7") + .Cases("armv7a", "armv7-a", "armv7") + .Cases("armv7r", "armv7-r", "armv7") + .Cases("armv7em", "armv7e-m", "armv7em") + .Cases("armv7k", "armv7-k", "armv7k") + .Cases("armv7m", "armv7-m", "armv7m") + .Cases("armv7s", "armv7-s", "armv7s") + .Default(nullptr); } static const char *ArmMachOArchNameCPU(StringRef CPU) { @@ -159,15 +156,12 @@ StringRef MachO::getMachOArchName(const ArgList &Args) const { } } -Darwin::~Darwin() { -} - -MachO::~MachO() { -} +Darwin::~Darwin() {} +MachO::~MachO() {} std::string MachO::ComputeEffectiveClangTriple(const ArgList &Args, - types::ID InputType) const { + types::ID InputType) const { llvm::Triple Triple(ComputeLLVMTriple(Args, InputType)); return Triple.getTriple(); @@ -211,18 +205,15 @@ Tool *MachO::getTool(Action::ActionClass AC) const { } } -Tool *MachO::buildLinker() const { - return new tools::darwin::Link(*this); -} +Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); } Tool *MachO::buildAssembler() const { - return new tools::darwin::Assemble(*this); + return new tools::darwin::Assembler(*this); } -DarwinClang::DarwinClang(const Driver &D, const llvm::Triple& Triple, +DarwinClang::DarwinClang(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) - : Darwin(D, Triple, Args) { -} + : Darwin(D, Triple, Args) {} void DarwinClang::addClangWarningOptions(ArgStringList &CC1Args) const { // For iOS, 64-bit, promote certain warnings to errors. @@ -308,7 +299,7 @@ void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs, } void Darwin::addProfileRTLibs(const ArgList &Args, - ArgStringList &CmdArgs) const { + ArgStringList &CmdArgs) const { if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs, false) || Args.hasArg(options::OPT_fprofile_generate) || @@ -337,10 +328,11 @@ void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args, } assert(isTargetMacOS() || isTargetIOSSimulator()); StringRef OS = isTargetMacOS() ? "osx" : "iossim"; - AddLinkRuntimeLib(Args, CmdArgs, (Twine("libclang_rt.") + Sanitizer + "_" + - OS + "_dynamic.dylib").str(), - /*AlwaysLink*/ true, /*IsEmbedded*/ false, - /*AddRPath*/ true); + AddLinkRuntimeLib( + Args, CmdArgs, + (Twine("libclang_rt.") + Sanitizer + "_" + OS + "_dynamic.dylib").str(), + /*AlwaysLink*/ true, /*IsEmbedded*/ false, + /*AddRPath*/ true); if (GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) { // Add explicit dependcy on -lc++abi, as -lc++ doesn't re-export @@ -357,7 +349,7 @@ void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args, break; default: getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform) - << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "darwin"; + << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "darwin"; return; } @@ -372,12 +364,10 @@ void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args, // cares. This is useful in situations where someone wants to statically link // something like libstdc++, and needs its runtime support routines. if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) { - getDriver().Diag(diag::err_drv_unsupported_opt) - << A->getAsString(Args); + getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args); return; } - const SanitizerArgs &Sanitize = getSanitizerArgs(); if (Sanitize.needsAsanRt()) AddLinkSanitizerLibArgs(Args, CmdArgs, "asan"); @@ -443,7 +433,7 @@ void Darwin::AddDeploymentTarget(DerivedArgList &Args) const { if (llvm::sys::path::is_absolute(env) && llvm::sys::fs::exists(env) && StringRef(env) != "/") { Args.append(Args.MakeSeparateArg( - nullptr, Opts.getOption(options::OPT_isysroot), env)); + nullptr, Opts.getOption(options::OPT_isysroot), env)); } } } @@ -453,8 +443,7 @@ void Darwin::AddDeploymentTarget(DerivedArgList &Args) const { if (OSXVersion && iOSVersion) { getDriver().Diag(diag::err_drv_argument_not_allowed_with) - << OSXVersion->getAsString(Args) - << iOSVersion->getAsString(Args); + << OSXVersion->getAsString(Args) << iOSVersion->getAsString(Args); iOSVersion = nullptr; } else if (!OSXVersion && !iOSVersion) { // If no deployment target was specified on the command line, check for @@ -466,16 +455,31 @@ void Darwin::AddDeploymentTarget(DerivedArgList &Args) const { if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET")) iOSTarget = env; - // If no '-miphoneos-version-min' specified on the command line and - // IPHONEOS_DEPLOYMENT_TARGET is not defined, see if we can set the default - // based on -isysroot. - if (iOSTarget.empty()) { + // If there is no command-line argument to specify the Target version and + // no environment variable defined, see if we can set the default based + // on -isysroot. + if (iOSTarget.empty() && OSXTarget.empty() && + Args.hasArg(options::OPT_isysroot)) { if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { - StringRef first, second; StringRef isysroot = A->getValue(); - std::tie(first, second) = isysroot.split(StringRef("SDKs/iPhoneOS")); - if (second != "") - iOSTarget = second.substr(0,3); + // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk + size_t BeginSDK = isysroot.rfind("SDKs/"); + size_t EndSDK = isysroot.rfind(".sdk"); + if (BeginSDK != StringRef::npos && EndSDK != StringRef::npos) { + StringRef SDK = isysroot.slice(BeginSDK + 5, EndSDK); + // Slice the version number out. + // Version number is between the first and the last number. + size_t StartVer = SDK.find_first_of("0123456789"); + size_t EndVer = SDK.find_last_of("0123456789"); + if (StartVer != StringRef::npos && EndVer > StartVer) { + StringRef Version = SDK.slice(StartVer, EndVer + 1); + if (SDK.startswith("iPhoneOS") || + SDK.startswith("iPhoneSimulator")) + iOSTarget = Version; + else if (SDK.startswith("MacOSX")) + OSXTarget = Version; + } + } } } @@ -535,18 +539,18 @@ void Darwin::AddDeploymentTarget(DerivedArgList &Args) const { bool HadExtra; if (Platform == MacOS) { assert(!iOSVersion && "Unknown target platform!"); - if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor, - Micro, HadExtra) || HadExtra || - Major != 10 || Minor >= 100 || Micro >= 100) + if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor, Micro, + HadExtra) || + HadExtra || Major != 10 || Minor >= 100 || Micro >= 100) getDriver().Diag(diag::err_drv_invalid_version_number) - << OSXVersion->getAsString(Args); + << OSXVersion->getAsString(Args); } else if (Platform == IPhoneOS) { assert(iOSVersion && "Unknown target platform!"); - if (!Driver::GetReleaseVersion(iOSVersion->getValue(), Major, Minor, - Micro, HadExtra) || HadExtra || - Major >= 10 || Minor >= 100 || Micro >= 100) + if (!Driver::GetReleaseVersion(iOSVersion->getValue(), Major, Minor, Micro, + HadExtra) || + HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100) getDriver().Diag(diag::err_drv_invalid_version_number) - << iOSVersion->getAsString(Args); + << iOSVersion->getAsString(Args); } else llvm_unreachable("unknown kind of Darwin platform"); @@ -646,10 +650,11 @@ DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args, // Skip this argument unless the architecture matches either the toolchain // triple arch, or the arch being bound. llvm::Triple::ArchType XarchArch = - tools::darwin::getArchTypeForMachOArchName(A->getValue(0)); - if (!(XarchArch == getArch() || - (BoundArch && XarchArch == - tools::darwin::getArchTypeForMachOArchName(BoundArch)))) + tools::darwin::getArchTypeForMachOArchName(A->getValue(0)); + if (!(XarchArch == getArch() || + (BoundArch && + XarchArch == + tools::darwin::getArchTypeForMachOArchName(BoundArch)))) continue; Arg *OriginalArg = A; @@ -667,11 +672,11 @@ DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args, // like -O4 are going to slip through. if (!XarchArg || Index > Prev + 1) { getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args) - << A->getAsString(Args); + << A->getAsString(Args); continue; } else if (XarchArg->getOption().hasFlag(options::DriverOption)) { getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver) - << A->getAsString(Args); + << A->getAsString(Args); continue; } @@ -685,11 +690,9 @@ DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args, // "input arguments". if (A->getOption().hasFlag(options::LinkerInput)) { // Convert the argument into individual Zlinker_input_args. - for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) { - DAL->AddSeparateArg(OriginalArg, - Opts.getOption(options::OPT_Zlinker_input), - A->getValue(i)); - + for (const char *Value : A->getValues()) { + DAL->AddSeparateArg( + OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value); } continue; } @@ -698,7 +701,7 @@ DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args, // Sob. These is strictly gcc compatible for the time being. Apple // gcc translates options twice, which means that self-expanding // options add duplicates. - switch ((options::ID) A->getOption().getID()) { + switch ((options::ID)A->getOption().getID()) { default: DAL->append(A); break; @@ -710,20 +713,19 @@ DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args, break; case options::OPT_dependency_file: - DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), - A->getValue()); + DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue()); break; case options::OPT_gfull: DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag)); - DAL->AddFlagArg(A, - Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols)); + DAL->AddFlagArg( + A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols)); break; case options::OPT_gused: DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag)); - DAL->AddFlagArg(A, - Opts.getOption(options::OPT_feliminate_unused_debug_symbols)); + DAL->AddFlagArg( + A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols)); break; case options::OPT_shared: @@ -744,8 +746,8 @@ DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args, break; case options::OPT_Wno_nonportable_cfstrings: - DAL->AddFlagArg(A, - Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings)); + DAL->AddFlagArg( + A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings)); break; case options::OPT_fpascal_strings: @@ -861,7 +863,6 @@ void MachO::AddLinkRuntimeLibArgs(const ArgList &Args, AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, false, true); } - DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args, const char *BoundArch) const { // First get the generic Apple args, before moving onto Darwin-specific ones. @@ -882,7 +883,7 @@ DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args, // but we can't check the deployment target in the translation code until // it is set here. if (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0)) { - for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) { + for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie;) { Arg *A = *it; ++it; if (A->getOption().getID() != options::OPT_mkernel && @@ -914,8 +915,7 @@ DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args, where = "iOS 5.0"; if (where != StringRef()) { - getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) - << where; + getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where; } } @@ -938,13 +938,9 @@ bool Darwin::UseSjLjExceptions() const { getTriple().getArch() == llvm::Triple::thumb); } -bool MachO::isPICDefault() const { - return true; -} +bool MachO::isPICDefault() const { return true; } -bool MachO::isPIEDefault() const { - return false; -} +bool MachO::isPIEDefault() const { return false; } bool MachO::isPICDefaultForced() const { return (getArch() == llvm::Triple::x86_64 || @@ -1058,25 +1054,23 @@ void Darwin::addStartObjectFileArgs(const ArgList &Args, } } -bool Darwin::SupportsObjCGC() const { - return isTargetMacOS(); -} +bool Darwin::SupportsObjCGC() const { return isTargetMacOS(); } void Darwin::CheckObjCARC() const { - if (isTargetIOSBased()|| (isTargetMacOS() && !isMacosxVersionLT(10, 6))) + if (isTargetIOSBased() || (isTargetMacOS() && !isMacosxVersionLT(10, 6))) return; 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. + if (isTargetMacOS() || isTargetIOSSimulator()) Res |= SanitizerKind::Address; - Res |= SanitizerKind::Vptr; - } - if (isTargetMacOS()) + if (isTargetMacOS()) { + if (!isMacosxVersionLT(10, 9)) + Res |= SanitizerKind::Vptr; Res |= SanitizerKind::SafeStack; + } return Res; } @@ -1089,17 +1083,15 @@ SanitizerMask Darwin::getSupportedSanitizers() const { /// This is the primary means of forming GCCVersion objects. /*static*/ Generic_GCC::GCCVersion Linux::GCCVersion::Parse(StringRef VersionText) { - const GCCVersion BadVersion = { VersionText.str(), -1, -1, -1, "", "", "" }; + const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""}; std::pair<StringRef, StringRef> First = VersionText.split('.'); std::pair<StringRef, StringRef> Second = First.second.split('.'); - GCCVersion GoodVersion = { VersionText.str(), -1, -1, -1, "", "", "" }; - if (First.first.getAsInteger(10, GoodVersion.Major) || - GoodVersion.Major < 0) + GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""}; + if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0) return BadVersion; GoodVersion.MajorStr = First.first.str(); - if (Second.first.getAsInteger(10, GoodVersion.Minor) || - GoodVersion.Minor < 0) + if (Second.first.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0) return BadVersion; GoodVersion.MinorStr = Second.first.str(); @@ -1176,12 +1168,11 @@ static llvm::StringRef getGCCToolchainDir(const ArgList &Args) { /// should instead pull the target out of the driver. This is currently /// necessary because the driver doesn't store the final version of the target /// triple. -void -Generic_GCC::GCCInstallationDetector::init( +void Generic_GCC::GCCInstallationDetector::init( const Driver &D, const llvm::Triple &TargetTriple, const ArgList &Args) { - llvm::Triple BiarchVariantTriple = - TargetTriple.isArch32Bit() ? TargetTriple.get64BitArchVariant() - : TargetTriple.get32BitArchVariant(); + llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit() + ? TargetTriple.get64BitArchVariant() + : TargetTriple.get32BitArchVariant(); // The library directories which may contain GCC installations. SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs; // The compatible GCC triples for this particular architecture. @@ -1219,25 +1210,22 @@ Generic_GCC::GCCInstallationDetector::init( // Loop over the various components which exist and select the best GCC // installation available. GCC installs are ranked by version number. Version = GCCVersion::Parse("0.0.0"); - for (unsigned i = 0, ie = Prefixes.size(); i < ie; ++i) { - if (!llvm::sys::fs::exists(Prefixes[i])) + for (const std::string &Prefix : Prefixes) { + if (!llvm::sys::fs::exists(Prefix)) continue; - for (unsigned j = 0, je = CandidateLibDirs.size(); j < je; ++j) { - const std::string LibDir = Prefixes[i] + CandidateLibDirs[j].str(); + for (const StringRef Suffix : CandidateLibDirs) { + const std::string LibDir = Prefix + Suffix.str(); if (!llvm::sys::fs::exists(LibDir)) continue; - for (unsigned k = 0, ke = CandidateTripleAliases.size(); k < ke; ++k) - ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, - CandidateTripleAliases[k]); + for (const StringRef Candidate : CandidateTripleAliases) + ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate); } - for (unsigned j = 0, je = CandidateBiarchLibDirs.size(); j < je; ++j) { - const std::string LibDir = Prefixes[i] + CandidateBiarchLibDirs[j].str(); + for (const StringRef Suffix : CandidateBiarchLibDirs) { + const std::string LibDir = Prefix + Suffix.str(); if (!llvm::sys::fs::exists(LibDir)) continue; - for (unsigned k = 0, ke = CandidateBiarchTripleAliases.size(); k < ke; - ++k) - ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, - CandidateBiarchTripleAliases[k], + for (const StringRef Candidate : CandidateBiarchTripleAliases) + ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate, /*NeedsBiarchSuffix=*/ true); } } @@ -1274,91 +1262,82 @@ bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const { // Declare a bunch of static data sets that we'll select between below. These // are specifically designed to always refer to string literals to avoid any // lifetime or initialization issues. - static const char *const AArch64LibDirs[] = { "/lib64", "/lib" }; - static const char *const AArch64Triples[] = { "aarch64-none-linux-gnu", - "aarch64-linux-gnu", - "aarch64-linux-android", - "aarch64-redhat-linux" }; - static const char *const AArch64beLibDirs[] = { "/lib" }; - static const char *const AArch64beTriples[] = { "aarch64_be-none-linux-gnu", - "aarch64_be-linux-gnu" }; - - static const char *const ARMLibDirs[] = { "/lib" }; - static const char *const ARMTriples[] = { "arm-linux-gnueabi", - "arm-linux-androideabi" }; - static const char *const ARMHFTriples[] = { "arm-linux-gnueabihf", - "armv7hl-redhat-linux-gnueabi" }; - static const char *const ARMebLibDirs[] = { "/lib" }; - static const char *const ARMebTriples[] = { "armeb-linux-gnueabi", - "armeb-linux-androideabi" }; - static const char *const ARMebHFTriples[] = { "armeb-linux-gnueabihf", - "armebv7hl-redhat-linux-gnueabi" }; - - static const char *const X86_64LibDirs[] = { "/lib64", "/lib" }; + static const char *const AArch64LibDirs[] = {"/lib64", "/lib"}; + static const char *const AArch64Triples[] = { + "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-linux-android", + "aarch64-redhat-linux"}; + static const char *const AArch64beLibDirs[] = {"/lib"}; + static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu", + "aarch64_be-linux-gnu"}; + + static const char *const ARMLibDirs[] = {"/lib"}; + static const char *const ARMTriples[] = {"arm-linux-gnueabi", + "arm-linux-androideabi"}; + static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf", + "armv7hl-redhat-linux-gnueabi"}; + static const char *const ARMebLibDirs[] = {"/lib"}; + static const char *const ARMebTriples[] = {"armeb-linux-gnueabi", + "armeb-linux-androideabi"}; + static const char *const ARMebHFTriples[] = { + "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"}; + + static const char *const X86_64LibDirs[] = {"/lib64", "/lib"}; static const char *const X86_64Triples[] = { - "x86_64-linux-gnu", "x86_64-unknown-linux-gnu", "x86_64-pc-linux-gnu", - "x86_64-redhat-linux6E", "x86_64-redhat-linux", "x86_64-suse-linux", - "x86_64-manbo-linux-gnu", "x86_64-linux-gnu", "x86_64-slackware-linux", - "x86_64-linux-android", "x86_64-unknown-linux" - }; - static const char *const X32LibDirs[] = { "/libx32" }; - static const char *const X86LibDirs[] = { "/lib32", "/lib" }; + "x86_64-linux-gnu", "x86_64-unknown-linux-gnu", + "x86_64-pc-linux-gnu", "x86_64-redhat-linux6E", + "x86_64-redhat-linux", "x86_64-suse-linux", + "x86_64-manbo-linux-gnu", "x86_64-linux-gnu", + "x86_64-slackware-linux", "x86_64-linux-android", + "x86_64-unknown-linux"}; + static const char *const X32LibDirs[] = {"/libx32"}; + static const char *const X86LibDirs[] = {"/lib32", "/lib"}; static const char *const X86Triples[] = { - "i686-linux-gnu", "i686-pc-linux-gnu", "i486-linux-gnu", "i386-linux-gnu", - "i386-redhat-linux6E", "i686-redhat-linux", "i586-redhat-linux", - "i386-redhat-linux", "i586-suse-linux", "i486-slackware-linux", - "i686-montavista-linux", "i686-linux-android", "i586-linux-gnu" - }; - - static const char *const MIPSLibDirs[] = { "/lib" }; - static const char *const MIPSTriples[] = { "mips-linux-gnu", - "mips-mti-linux-gnu", - "mips-img-linux-gnu" }; - static const char *const MIPSELLibDirs[] = { "/lib" }; - static const char *const MIPSELTriples[] = { "mipsel-linux-gnu", - "mipsel-linux-android", - "mips-img-linux-gnu" }; - - static const char *const MIPS64LibDirs[] = { "/lib64", "/lib" }; - static const char *const MIPS64Triples[] = { "mips64-linux-gnu", - "mips-mti-linux-gnu", - "mips-img-linux-gnu", - "mips64-linux-gnuabi64" }; - static const char *const MIPS64ELLibDirs[] = { "/lib64", "/lib" }; - static const char *const MIPS64ELTriples[] = { "mips64el-linux-gnu", - "mips-mti-linux-gnu", - "mips-img-linux-gnu", - "mips64el-linux-android", - "mips64el-linux-gnuabi64" }; - - static const char *const PPCLibDirs[] = { "/lib32", "/lib" }; + "i686-linux-gnu", "i686-pc-linux-gnu", "i486-linux-gnu", + "i386-linux-gnu", "i386-redhat-linux6E", "i686-redhat-linux", + "i586-redhat-linux", "i386-redhat-linux", "i586-suse-linux", + "i486-slackware-linux", "i686-montavista-linux", "i686-linux-android", + "i586-linux-gnu"}; + + static const char *const MIPSLibDirs[] = {"/lib"}; + static const char *const MIPSTriples[] = { + "mips-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu"}; + static const char *const MIPSELLibDirs[] = {"/lib"}; + static const char *const MIPSELTriples[] = { + "mipsel-linux-gnu", "mipsel-linux-android", "mips-img-linux-gnu"}; + + static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"}; + static const char *const MIPS64Triples[] = { + "mips64-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu", + "mips64-linux-gnuabi64"}; + static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"}; + static const char *const MIPS64ELTriples[] = { + "mips64el-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu", + "mips64el-linux-android", "mips64el-linux-gnuabi64"}; + + static const char *const PPCLibDirs[] = {"/lib32", "/lib"}; static const char *const PPCTriples[] = { - "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe", - "powerpc-suse-linux", "powerpc-montavista-linuxspe" - }; - static const char *const PPC64LibDirs[] = { "/lib64", "/lib" }; - static const char *const PPC64Triples[] = { "powerpc64-linux-gnu", - "powerpc64-unknown-linux-gnu", - "powerpc64-suse-linux", - "ppc64-redhat-linux" }; - static const char *const PPC64LELibDirs[] = { "/lib64", "/lib" }; - static const char *const PPC64LETriples[] = { "powerpc64le-linux-gnu", - "powerpc64le-unknown-linux-gnu", - "powerpc64le-suse-linux", - "ppc64le-redhat-linux" }; - - static const char *const SPARCv8LibDirs[] = { "/lib32", "/lib" }; - static const char *const SPARCv8Triples[] = { "sparc-linux-gnu", - "sparcv8-linux-gnu" }; - static const char *const SPARCv9LibDirs[] = { "/lib64", "/lib" }; - static const char *const SPARCv9Triples[] = { "sparc64-linux-gnu", - "sparcv9-linux-gnu" }; - - static const char *const SystemZLibDirs[] = { "/lib64", "/lib" }; + "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe", + "powerpc-suse-linux", "powerpc-montavista-linuxspe"}; + static const char *const PPC64LibDirs[] = {"/lib64", "/lib"}; + static const char *const PPC64Triples[] = { + "powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu", + "powerpc64-suse-linux", "ppc64-redhat-linux"}; + static const char *const PPC64LELibDirs[] = {"/lib64", "/lib"}; + static const char *const PPC64LETriples[] = { + "powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu", + "powerpc64le-suse-linux", "ppc64le-redhat-linux"}; + + static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"}; + static const char *const SPARCv8Triples[] = {"sparc-linux-gnu", + "sparcv8-linux-gnu"}; + static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"}; + static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu", + "sparcv9-linux-gnu"}; + + static const char *const SystemZLibDirs[] = {"/lib64", "/lib"}; static const char *const SystemZTriples[] = { - "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu", - "s390x-suse-linux", "s390x-redhat-linux" - }; + "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu", + "s390x-suse-linux", "s390x-redhat-linux"}; using std::begin; using std::end; @@ -1526,14 +1505,12 @@ static bool isMipsEL(llvm::Triple::ArchType Arch) { } static bool isMips16(const ArgList &Args) { - Arg *A = Args.getLastArg(options::OPT_mips16, - options::OPT_mno_mips16); + Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16); return A && A->getOption().matches(options::OPT_mips16); } static bool isMicroMips(const ArgList &Args) { - Arg *A = Args.getLastArg(options::OPT_mmicromips, - options::OPT_mno_micromips); + Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips); return A && A->getOption().matches(options::OPT_mmicromips); } @@ -1554,8 +1531,7 @@ static Multilib makeMultilib(StringRef commonSuffix) { } static bool findMIPSMultilibs(const llvm::Triple &TargetTriple, StringRef Path, - const ArgList &Args, - DetectedMultilibs &Result) { + const ArgList &Args, DetectedMultilibs &Result) { // Some MIPS toolchains put libraries and object files compiled // using different options in to the sub-directoris which names // reflects the flags used for compilation. For example sysroot @@ -1587,181 +1563,182 @@ static bool findMIPSMultilibs(const llvm::Triple &TargetTriple, StringRef Path, MultilibSet FSFMipsMultilibs; { auto MArchMips32 = makeMultilib("/mips32") - .flag("+m32").flag("-m64").flag("-mmicromips").flag("+march=mips32"); + .flag("+m32") + .flag("-m64") + .flag("-mmicromips") + .flag("+march=mips32"); auto MArchMicroMips = makeMultilib("/micromips") - .flag("+m32").flag("-m64").flag("+mmicromips"); + .flag("+m32") + .flag("-m64") + .flag("+mmicromips"); auto MArchMips64r2 = makeMultilib("/mips64r2") - .flag("-m32").flag("+m64").flag("+march=mips64r2"); + .flag("-m32") + .flag("+m64") + .flag("+march=mips64r2"); - auto MArchMips64 = makeMultilib("/mips64") - .flag("-m32").flag("+m64").flag("-march=mips64r2"); + auto MArchMips64 = makeMultilib("/mips64").flag("-m32").flag("+m64").flag( + "-march=mips64r2"); auto MArchDefault = makeMultilib("") - .flag("+m32").flag("-m64").flag("-mmicromips").flag("+march=mips32r2"); - - auto Mips16 = makeMultilib("/mips16") - .flag("+mips16"); - - auto UCLibc = makeMultilib("/uclibc") - .flag("+muclibc"); - - auto MAbi64 = makeMultilib("/64") - .flag("+mabi=n64").flag("-mabi=n32").flag("-m32"); - - auto BigEndian = makeMultilib("") - .flag("+EB").flag("-EL"); - - auto LittleEndian = makeMultilib("/el") - .flag("+EL").flag("-EB"); - - auto SoftFloat = makeMultilib("/sof") - .flag("+msoft-float"); - - auto Nan2008 = makeMultilib("/nan2008") - .flag("+mnan=2008"); - - FSFMipsMultilibs = MultilibSet() - .Either(MArchMips32, MArchMicroMips, - MArchMips64r2, MArchMips64, MArchDefault) - .Maybe(UCLibc) - .Maybe(Mips16) - .FilterOut("/mips64/mips16") - .FilterOut("/mips64r2/mips16") - .FilterOut("/micromips/mips16") - .Maybe(MAbi64) - .FilterOut("/micromips/64") - .FilterOut("/mips32/64") - .FilterOut("^/64") - .FilterOut("/mips16/64") - .Either(BigEndian, LittleEndian) - .Maybe(SoftFloat) - .Maybe(Nan2008) - .FilterOut(".*sof/nan2008") - .FilterOut(NonExistent) - .setIncludeDirsCallback([]( - StringRef InstallDir, StringRef TripleStr, const Multilib &M) { - std::vector<std::string> Dirs; - Dirs.push_back((InstallDir + "/include").str()); - std::string SysRootInc = InstallDir.str() + "/../../../../sysroot"; - if (StringRef(M.includeSuffix()).startswith("/uclibc")) - Dirs.push_back(SysRootInc + "/uclibc/usr/include"); - else - Dirs.push_back(SysRootInc + "/usr/include"); - return Dirs; - }); + .flag("+m32") + .flag("-m64") + .flag("-mmicromips") + .flag("+march=mips32r2"); + + auto Mips16 = makeMultilib("/mips16").flag("+mips16"); + + auto UCLibc = makeMultilib("/uclibc").flag("+muclibc"); + + auto MAbi64 = + makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32"); + + auto BigEndian = makeMultilib("").flag("+EB").flag("-EL"); + + auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB"); + + auto SoftFloat = makeMultilib("/sof").flag("+msoft-float"); + + auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008"); + + FSFMipsMultilibs = + MultilibSet() + .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64, + MArchDefault) + .Maybe(UCLibc) + .Maybe(Mips16) + .FilterOut("/mips64/mips16") + .FilterOut("/mips64r2/mips16") + .FilterOut("/micromips/mips16") + .Maybe(MAbi64) + .FilterOut("/micromips/64") + .FilterOut("/mips32/64") + .FilterOut("^/64") + .FilterOut("/mips16/64") + .Either(BigEndian, LittleEndian) + .Maybe(SoftFloat) + .Maybe(Nan2008) + .FilterOut(".*sof/nan2008") + .FilterOut(NonExistent) + .setIncludeDirsCallback([](StringRef InstallDir, + StringRef TripleStr, const Multilib &M) { + std::vector<std::string> Dirs; + Dirs.push_back((InstallDir + "/include").str()); + std::string SysRootInc = + InstallDir.str() + "/../../../../sysroot"; + if (StringRef(M.includeSuffix()).startswith("/uclibc")) + Dirs.push_back(SysRootInc + "/uclibc/usr/include"); + else + Dirs.push_back(SysRootInc + "/usr/include"); + return Dirs; + }); } // Check for Code Sourcery toolchain multilibs MultilibSet CSMipsMultilibs; { - auto MArchMips16 = makeMultilib("/mips16") - .flag("+m32").flag("+mips16"); + auto MArchMips16 = makeMultilib("/mips16").flag("+m32").flag("+mips16"); - auto MArchMicroMips = makeMultilib("/micromips") - .flag("+m32").flag("+mmicromips"); + auto MArchMicroMips = + makeMultilib("/micromips").flag("+m32").flag("+mmicromips"); - auto MArchDefault = makeMultilib("") - .flag("-mips16").flag("-mmicromips"); + auto MArchDefault = makeMultilib("").flag("-mips16").flag("-mmicromips"); - auto UCLibc = makeMultilib("/uclibc") - .flag("+muclibc"); + auto UCLibc = makeMultilib("/uclibc").flag("+muclibc"); - auto SoftFloat = makeMultilib("/soft-float") - .flag("+msoft-float"); + auto SoftFloat = makeMultilib("/soft-float").flag("+msoft-float"); - auto Nan2008 = makeMultilib("/nan2008") - .flag("+mnan=2008"); + auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008"); - auto DefaultFloat = makeMultilib("") - .flag("-msoft-float").flag("-mnan=2008"); + auto DefaultFloat = + makeMultilib("").flag("-msoft-float").flag("-mnan=2008"); - auto BigEndian = makeMultilib("") - .flag("+EB").flag("-EL"); + auto BigEndian = makeMultilib("").flag("+EB").flag("-EL"); - auto LittleEndian = makeMultilib("/el") - .flag("+EL").flag("-EB"); + auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB"); // Note that this one's osSuffix is "" auto MAbi64 = makeMultilib("") - .gccSuffix("/64") - .includeSuffix("/64") - .flag("+mabi=n64").flag("-mabi=n32").flag("-m32"); - - CSMipsMultilibs = MultilibSet() - .Either(MArchMips16, MArchMicroMips, MArchDefault) - .Maybe(UCLibc) - .Either(SoftFloat, Nan2008, DefaultFloat) - .FilterOut("/micromips/nan2008") - .FilterOut("/mips16/nan2008") - .Either(BigEndian, LittleEndian) - .Maybe(MAbi64) - .FilterOut("/mips16.*/64") - .FilterOut("/micromips.*/64") - .FilterOut(NonExistent) - .setIncludeDirsCallback([]( - StringRef InstallDir, StringRef TripleStr, const Multilib &M) { - std::vector<std::string> Dirs; - Dirs.push_back((InstallDir + "/include").str()); - std::string SysRootInc = - InstallDir.str() + "/../../../../" + TripleStr.str(); - if (StringRef(M.includeSuffix()).startswith("/uclibc")) - Dirs.push_back(SysRootInc + "/libc/uclibc/usr/include"); - else - Dirs.push_back(SysRootInc + "/libc/usr/include"); - return Dirs; - }); - } - - MultilibSet AndroidMipsMultilibs = MultilibSet() - .Maybe(Multilib("/mips-r2").flag("+march=mips32r2")) - .Maybe(Multilib("/mips-r6").flag("+march=mips32r6")) - .FilterOut(NonExistent); + .gccSuffix("/64") + .includeSuffix("/64") + .flag("+mabi=n64") + .flag("-mabi=n32") + .flag("-m32"); + + CSMipsMultilibs = + MultilibSet() + .Either(MArchMips16, MArchMicroMips, MArchDefault) + .Maybe(UCLibc) + .Either(SoftFloat, Nan2008, DefaultFloat) + .FilterOut("/micromips/nan2008") + .FilterOut("/mips16/nan2008") + .Either(BigEndian, LittleEndian) + .Maybe(MAbi64) + .FilterOut("/mips16.*/64") + .FilterOut("/micromips.*/64") + .FilterOut(NonExistent) + .setIncludeDirsCallback([](StringRef InstallDir, + StringRef TripleStr, const Multilib &M) { + std::vector<std::string> Dirs; + Dirs.push_back((InstallDir + "/include").str()); + std::string SysRootInc = + InstallDir.str() + "/../../../../" + TripleStr.str(); + if (StringRef(M.includeSuffix()).startswith("/uclibc")) + Dirs.push_back(SysRootInc + "/libc/uclibc/usr/include"); + else + Dirs.push_back(SysRootInc + "/libc/usr/include"); + return Dirs; + }); + } + + MultilibSet AndroidMipsMultilibs = + MultilibSet() + .Maybe(Multilib("/mips-r2").flag("+march=mips32r2")) + .Maybe(Multilib("/mips-r6").flag("+march=mips32r6")) + .FilterOut(NonExistent); MultilibSet DebianMipsMultilibs; { - Multilib MAbiN32 = Multilib() - .gccSuffix("/n32") - .includeSuffix("/n32") - .flag("+mabi=n32"); + Multilib MAbiN32 = + Multilib().gccSuffix("/n32").includeSuffix("/n32").flag("+mabi=n32"); Multilib M64 = Multilib() - .gccSuffix("/64") - .includeSuffix("/64") - .flag("+m64").flag("-m32").flag("-mabi=n32"); + .gccSuffix("/64") + .includeSuffix("/64") + .flag("+m64") + .flag("-m32") + .flag("-mabi=n32"); - Multilib M32 = Multilib() - .flag("-m64").flag("+m32").flag("-mabi=n32"); + Multilib M32 = Multilib().flag("-m64").flag("+m32").flag("-mabi=n32"); - DebianMipsMultilibs = MultilibSet() - .Either(M32, M64, MAbiN32) - .FilterOut(NonExistent); + DebianMipsMultilibs = + MultilibSet().Either(M32, M64, MAbiN32).FilterOut(NonExistent); } MultilibSet ImgMultilibs; { - auto Mips64r6 = makeMultilib("/mips64r6") - .flag("+m64").flag("-m32"); + auto Mips64r6 = makeMultilib("/mips64r6").flag("+m64").flag("-m32"); - auto LittleEndian = makeMultilib("/el") - .flag("+EL").flag("-EB"); + auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB"); - auto MAbi64 = makeMultilib("/64") - .flag("+mabi=n64").flag("-mabi=n32").flag("-m32"); + auto MAbi64 = + makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32"); - ImgMultilibs = MultilibSet() - .Maybe(Mips64r6) - .Maybe(MAbi64) - .Maybe(LittleEndian) - .FilterOut(NonExistent) - .setIncludeDirsCallback([]( - StringRef InstallDir, StringRef TripleStr, const Multilib &M) { - std::vector<std::string> Dirs; - Dirs.push_back((InstallDir + "/include").str()); - Dirs.push_back((InstallDir + "/../../../../sysroot/usr/include").str()); - return Dirs; - }); + ImgMultilibs = + MultilibSet() + .Maybe(Mips64r6) + .Maybe(MAbi64) + .Maybe(LittleEndian) + .FilterOut(NonExistent) + .setIncludeDirsCallback([](StringRef InstallDir, + StringRef TripleStr, const Multilib &M) { + std::vector<std::string> Dirs; + Dirs.push_back((InstallDir + "/include").str()); + Dirs.push_back( + (InstallDir + "/../../../../sysroot/usr/include").str()); + return Dirs; + }); } StringRef CPUName; @@ -1816,8 +1793,8 @@ static bool findMIPSMultilibs(const llvm::Triple &TargetTriple, StringRef Path, // Sort candidates. Toolchain that best meets the directories goes first. // Then select the first toolchains matches command line flags. - MultilibSet *candidates[] = { &DebianMipsMultilibs, &FSFMipsMultilibs, - &CSMipsMultilibs }; + MultilibSet *candidates[] = {&DebianMipsMultilibs, &FSFMipsMultilibs, + &CSMipsMultilibs}; std::sort( std::begin(candidates), std::end(candidates), [](MultilibSet *a, MultilibSet *b) { return a->size() > b->size(); }); @@ -1859,17 +1836,23 @@ static bool findBiarchMultilibs(const llvm::Triple &TargetTriple, Multilib Default; Multilib Alt64 = Multilib() - .gccSuffix("/64") - .includeSuffix("/64") - .flag("-m32").flag("+m64").flag("-mx32"); + .gccSuffix("/64") + .includeSuffix("/64") + .flag("-m32") + .flag("+m64") + .flag("-mx32"); Multilib Alt32 = Multilib() - .gccSuffix("/32") - .includeSuffix("/32") - .flag("+m32").flag("-m64").flag("-mx32"); + .gccSuffix("/32") + .includeSuffix("/32") + .flag("+m32") + .flag("-m64") + .flag("-mx32"); Multilib Altx32 = Multilib() - .gccSuffix("/x32") - .includeSuffix("/x32") - .flag("-m32").flag("-m64").flag("+mx32"); + .gccSuffix("/x32") + .includeSuffix("/x32") + .flag("-m32") + .flag("-m64") + .flag("+mx32"); FilterNonExistent NonExistent(Path); @@ -1916,8 +1899,7 @@ static bool findBiarchMultilibs(const llvm::Triple &TargetTriple, if (!Result.Multilibs.select(Flags, Result.SelectedMultilib)) return false; - if (Result.SelectedMultilib == Alt64 || - Result.SelectedMultilib == Alt32 || + if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 || Result.SelectedMultilib == Altx32) Result.BiarchSibling = Default; @@ -1933,27 +1915,26 @@ void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple( // check for. We also record what is necessary to walk from each back // up to the lib directory. const std::string LibSuffixes[] = { - "/gcc/" + CandidateTriple.str(), - // Debian puts cross-compilers in gcc-cross - "/gcc-cross/" + CandidateTriple.str(), - "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(), - - // The Freescale PPC SDK has the gcc libraries in - // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well. - "/" + CandidateTriple.str(), - - // Ubuntu has a strange mis-matched pair of triples that this happens to - // match. - // FIXME: It may be worthwhile to generalize this and look for a second - // triple. - "/i386-linux-gnu/gcc/" + CandidateTriple.str() - }; + "/gcc/" + CandidateTriple.str(), + // Debian puts cross-compilers in gcc-cross + "/gcc-cross/" + CandidateTriple.str(), + "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(), + + // The Freescale PPC SDK has the gcc libraries in + // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well. + "/" + CandidateTriple.str(), + + // Ubuntu has a strange mis-matched pair of triples that this happens to + // match. + // FIXME: It may be worthwhile to generalize this and look for a second + // triple. + "/i386-linux-gnu/gcc/" + CandidateTriple.str()}; const std::string InstallSuffixes[] = { - "/../../..", // gcc/ - "/../../..", // gcc-cross/ - "/../../../..", // <triple>/gcc/ - "/../..", // <triple>/ - "/../../../.." // i386-linux-gnu/gcc/<triple>/ + "/../../..", // gcc/ + "/../../..", // gcc-cross/ + "/../../../..", // <triple>/gcc/ + "/../..", // <triple>/ + "/../../../.." // i386-linux-gnu/gcc/<triple>/ }; // Only look at the final, weird Ubuntu suffix for i386-linux-gnu. const unsigned NumLibSuffixes = @@ -2000,26 +1981,25 @@ void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple( } } -Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple& Triple, +Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) - : ToolChain(D, Triple, Args), GCCInstallation() { + : ToolChain(D, Triple, Args), GCCInstallation() { getProgramPaths().push_back(getDriver().getInstalledDir()); if (getDriver().getInstalledDir() != getDriver().Dir) getProgramPaths().push_back(getDriver().Dir); } -Generic_GCC::~Generic_GCC() { -} +Generic_GCC::~Generic_GCC() {} Tool *Generic_GCC::getTool(Action::ActionClass AC) const { switch (AC) { case Action::PreprocessJobClass: if (!Preprocess) - Preprocess.reset(new tools::gcc::Preprocess(*this)); + Preprocess.reset(new tools::gcc::Preprocessor(*this)); return Preprocess.get(); case Action::CompileJobClass: if (!Compile) - Compile.reset(new tools::gcc::Compile(*this)); + Compile.reset(new tools::gcc::Compiler(*this)); return Compile.get(); default: return ToolChain::getTool(AC); @@ -2027,12 +2007,10 @@ Tool *Generic_GCC::getTool(Action::ActionClass AC) const { } Tool *Generic_GCC::buildAssembler() const { - return new tools::gnutools::Assemble(*this); + return new tools::gnutools::Assembler(*this); } -Tool *Generic_GCC::buildLinker() const { - return new tools::gcc::Link(*this); -} +Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); } void Generic_GCC::printVerboseInfo(raw_ostream &OS) const { // Print the information about how we detected the GCC installation. @@ -2044,15 +2022,13 @@ bool Generic_GCC::IsUnwindTablesDefault() const { } bool Generic_GCC::isPICDefault() const { - return false; + return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows(); } -bool Generic_GCC::isPIEDefault() const { - return false; -} +bool Generic_GCC::isPIEDefault() const { return false; } bool Generic_GCC::isPICDefaultForced() const { - return false; + return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows(); } bool Generic_GCC::IsIntegratedAssemblerDefault() const { @@ -2092,8 +2068,7 @@ void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs, getTriple().getOS() == llvm::Triple::NaCl; if (DriverArgs.hasFlag(options::OPT_fuse_init_array, - options::OPT_fno_use_init_array, - UseInitArrayDefault)) + options::OPT_fno_use_init_array, UseInitArrayDefault)) CC1Args.push_back("-fuse-init-array"); } @@ -2119,18 +2094,15 @@ std::string Hexagon_TC::GetGnuDir(const std::string &InstalledDir, return InstallRelDir; } -const char *Hexagon_TC::GetSmallDataThreshold(const ArgList &Args) -{ +const char *Hexagon_TC::GetSmallDataThreshold(const ArgList &Args) { Arg *A; - A = Args.getLastArg(options::OPT_G, - options::OPT_G_EQ, + A = Args.getLastArg(options::OPT_G, options::OPT_G_EQ, options::OPT_msmall_data_threshold_EQ); if (A) return A->getValue(); - A = Args.getLastArg(options::OPT_shared, - options::OPT_fpic, + A = Args.getLastArg(options::OPT_shared, options::OPT_fpic, options::OPT_fPIC); if (A) return "0"; @@ -2138,26 +2110,22 @@ const char *Hexagon_TC::GetSmallDataThreshold(const ArgList &Args) return 0; } -bool Hexagon_TC::UsesG0(const char* smallDataThreshold) -{ +bool Hexagon_TC::UsesG0(const char *smallDataThreshold) { return smallDataThreshold && smallDataThreshold[0] == '0'; } -static void GetHexagonLibraryPaths( - const ArgList &Args, - const std::string &Ver, - const std::string &MarchString, - const std::string &InstalledDir, - ToolChain::path_list *LibPaths) -{ +static void GetHexagonLibraryPaths(const ArgList &Args, const std::string &Ver, + const std::string &MarchString, + const std::string &InstalledDir, + ToolChain::path_list *LibPaths) { bool buildingLib = Args.hasArg(options::OPT_shared); //---------------------------------------------------------------------------- // -L Args //---------------------------------------------------------------------------- - for (const Arg *A : Args.filtered(options::OPT_L)) - for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) - LibPaths->push_back(A->getValue(i)); + for (Arg *A : Args.filtered(options::OPT_L)) + for (const char *Value : A->getValues()) + LibPaths->push_back(Value); //---------------------------------------------------------------------------- // Other standard paths @@ -2191,7 +2159,7 @@ static void GetHexagonLibraryPaths( Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) - : Linux(D, Triple, Args) { + : Linux(D, Triple, Args) { const std::string InstalledDir(getDriver().getInstalledDir()); const std::string GnuDir = Hexagon_TC::GetGnuDir(InstalledDir, Args); @@ -2204,7 +2172,7 @@ Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple &Triple, // Determine version of GCC libraries and headers to use. const std::string HexagonDir(GnuDir + "/lib/gcc/hexagon"); std::error_code ec; - GCCVersion MaxVersion= GCCVersion::Parse("0.0.0"); + GCCVersion MaxVersion = GCCVersion::Parse("0.0.0"); for (llvm::sys::fs::directory_iterator di(HexagonDir, ec), de; !ec && di != de; di = di.increment(ec)) { GCCVersion cv = GCCVersion::Parse(llvm::sys::path::filename(di->path())); @@ -2213,30 +2181,25 @@ Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple &Triple, } GCCLibAndIncVersion = MaxVersion; - ToolChain::path_list *LibPaths= &getFilePaths(); + ToolChain::path_list *LibPaths = &getFilePaths(); // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets // 'elf' OS type, so the Linux paths are not appropriate. When we actually // support 'linux' we'll need to fix this up LibPaths->clear(); - GetHexagonLibraryPaths( - Args, - GetGCCLibAndIncVersion(), - GetTargetCPU(Args), - InstalledDir, - LibPaths); + GetHexagonLibraryPaths(Args, GetGCCLibAndIncVersion(), GetTargetCPU(Args), + InstalledDir, LibPaths); } -Hexagon_TC::~Hexagon_TC() { -} +Hexagon_TC::~Hexagon_TC() {} Tool *Hexagon_TC::buildAssembler() const { - return new tools::hexagon::Assemble(*this); + return new tools::hexagon::Assembler(*this); } Tool *Hexagon_TC::buildLinker() const { - return new tools::hexagon::Link(*this); + return new tools::hexagon::Linker(*this); } void Hexagon_TC::AddClangSystemIncludeArgs(const ArgList &DriverArgs, @@ -2280,8 +2243,7 @@ Hexagon_TC::GetCXXStdlibType(const ArgList &Args) const { StringRef Value = A->getValue(); if (Value != "libstdc++") { - getDriver().Diag(diag::err_drv_invalid_stdlib_name) - << A->getAsString(Args); + getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args); } return ToolChain::CST_Libstdcxx; @@ -2310,8 +2272,7 @@ static int getHexagonVersion(const ArgList &Args) { return 4; } -StringRef Hexagon_TC::GetTargetCPU(const ArgList &Args) -{ +StringRef Hexagon_TC::GetTargetCPU(const ArgList &Args) { int V = getHexagonVersion(Args); // FIXME: We don't support versions < 4. We should error on them. switch (V) { @@ -2334,13 +2295,13 @@ StringRef Hexagon_TC::GetTargetCPU(const ArgList &Args) /// NaCl Toolchain NaCl_TC::NaCl_TC(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) - : Generic_ELF(D, Triple, Args) { + : Generic_ELF(D, Triple, Args) { // Remove paths added by Generic_GCC. NaCl Toolchain cannot use the // default paths, and must instead only use the paths provided // with this toolchain based on architecture. - path_list& file_paths = getFilePaths(); - path_list& prog_paths = getProgramPaths(); + path_list &file_paths = getFilePaths(); + path_list &prog_paths = getProgramPaths(); file_paths.clear(); prog_paths.clear(); @@ -2354,30 +2315,30 @@ NaCl_TC::NaCl_TC(const Driver &D, const llvm::Triple &Triple, // Path for toolchain libraries (libgcc.a, ...) std::string ToolPath(getDriver().ResourceDir + "/lib/"); - switch(Triple.getArch()) { - case llvm::Triple::x86: { - file_paths.push_back(FilePath + "x86_64-nacl/lib32"); - file_paths.push_back(FilePath + "x86_64-nacl/usr/lib32"); - prog_paths.push_back(ProgPath + "x86_64-nacl/bin"); - file_paths.push_back(ToolPath + "i686-nacl"); - break; - } - case llvm::Triple::x86_64: { - file_paths.push_back(FilePath + "x86_64-nacl/lib"); - file_paths.push_back(FilePath + "x86_64-nacl/usr/lib"); - prog_paths.push_back(ProgPath + "x86_64-nacl/bin"); - file_paths.push_back(ToolPath + "x86_64-nacl"); - break; - } - case llvm::Triple::arm: { - file_paths.push_back(FilePath + "arm-nacl/lib"); - file_paths.push_back(FilePath + "arm-nacl/usr/lib"); - prog_paths.push_back(ProgPath + "arm-nacl/bin"); - file_paths.push_back(ToolPath + "arm-nacl"); - break; - } - default: - break; + switch (Triple.getArch()) { + case llvm::Triple::x86: { + file_paths.push_back(FilePath + "x86_64-nacl/lib32"); + file_paths.push_back(FilePath + "x86_64-nacl/usr/lib32"); + prog_paths.push_back(ProgPath + "x86_64-nacl/bin"); + file_paths.push_back(ToolPath + "i686-nacl"); + break; + } + case llvm::Triple::x86_64: { + file_paths.push_back(FilePath + "x86_64-nacl/lib"); + file_paths.push_back(FilePath + "x86_64-nacl/usr/lib"); + prog_paths.push_back(ProgPath + "x86_64-nacl/bin"); + file_paths.push_back(ToolPath + "x86_64-nacl"); + break; + } + case llvm::Triple::arm: { + file_paths.push_back(FilePath + "arm-nacl/lib"); + file_paths.push_back(FilePath + "arm-nacl/usr/lib"); + prog_paths.push_back(ProgPath + "arm-nacl/bin"); + file_paths.push_back(ToolPath + "arm-nacl"); + break; + } + default: + break; } // Use provided linker, not system linker @@ -2401,13 +2362,17 @@ void NaCl_TC::AddClangSystemIncludeArgs(const ArgList &DriverArgs, return; SmallString<128> P(D.Dir + "/../"); - if (getTriple().getArch() == llvm::Triple::arm) { + switch (getTriple().getArch()) { + case llvm::Triple::arm: llvm::sys::path::append(P, "arm-nacl/usr/include"); - } else if (getTriple().getArch() == llvm::Triple::x86) { + break; + case llvm::Triple::x86: llvm::sys::path::append(P, "x86_64-nacl/usr/include"); - } else if (getTriple().getArch() == llvm::Triple::x86_64) { + break; + case llvm::Triple::x86_64: llvm::sys::path::append(P, "x86_64-nacl/usr/include"); - } else { + break; + default: return; } @@ -2437,18 +2402,22 @@ void NaCl_TC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, // if the value is libc++, and emits an error for other values. GetCXXStdlibType(DriverArgs); - if (getTriple().getArch() == llvm::Triple::arm) { - SmallString<128> P(D.Dir + "/../"); + SmallString<128> P(D.Dir + "/../"); + switch (getTriple().getArch()) { + case llvm::Triple::arm: llvm::sys::path::append(P, "arm-nacl/include/c++/v1"); addSystemInclude(DriverArgs, CC1Args, P.str()); - } else if (getTriple().getArch() == llvm::Triple::x86) { - SmallString<128> P(D.Dir + "/../"); + break; + case llvm::Triple::x86: llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1"); addSystemInclude(DriverArgs, CC1Args, P.str()); - } else if (getTriple().getArch() == llvm::Triple::x86_64) { - SmallString<128> P(D.Dir + "/../"); + break; + case llvm::Triple::x86_64: llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1"); addSystemInclude(DriverArgs, CC1Args, P.str()); + break; + default: + break; } } @@ -2457,15 +2426,14 @@ ToolChain::CXXStdlibType NaCl_TC::GetCXXStdlibType(const ArgList &Args) const { StringRef Value = A->getValue(); if (Value == "libc++") return ToolChain::CST_Libcxx; - getDriver().Diag(diag::err_drv_invalid_stdlib_name) - << A->getAsString(Args); + getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args); } return ToolChain::CST_Libcxx; } -std::string NaCl_TC::ComputeEffectiveClangTriple( - const ArgList &Args, types::ID InputType) const { +std::string NaCl_TC::ComputeEffectiveClangTriple(const ArgList &Args, + types::ID InputType) const { llvm::Triple TheTriple(ComputeLLVMTriple(Args, InputType)); if (TheTriple.getArch() == llvm::Triple::arm && TheTriple.getEnvironment() == llvm::Triple::UnknownEnvironment) @@ -2474,13 +2442,13 @@ std::string NaCl_TC::ComputeEffectiveClangTriple( } Tool *NaCl_TC::buildLinker() const { - return new tools::nacltools::Link(*this); + return new tools::nacltools::Linker(*this); } Tool *NaCl_TC::buildAssembler() const { if (getTriple().getArch() == llvm::Triple::arm) - return new tools::nacltools::AssembleARM(*this); - return new tools::gnutools::Assemble(*this); + return new tools::nacltools::AssemblerARM(*this); + return new tools::gnutools::Assembler(*this); } // End NaCl @@ -2488,9 +2456,9 @@ Tool *NaCl_TC::buildAssembler() const { /// all subcommands. See http://tce.cs.tut.fi for our peculiar target. /// Currently does not support anything else but compilation. -TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple& Triple, +TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) - : ToolChain(D, Triple, Args) { + : ToolChain(D, Triple, Args) { // Path mangling to find libexec std::string Path(getDriver().Dir); @@ -2498,24 +2466,15 @@ TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple& Triple, getProgramPaths().push_back(Path); } -TCEToolChain::~TCEToolChain() { -} +TCEToolChain::~TCEToolChain() {} -bool TCEToolChain::IsMathErrnoDefault() const { - return true; -} +bool TCEToolChain::IsMathErrnoDefault() const { return true; } -bool TCEToolChain::isPICDefault() const { - return false; -} +bool TCEToolChain::isPICDefault() const { return false; } -bool TCEToolChain::isPIEDefault() const { - return false; -} +bool TCEToolChain::isPIEDefault() const { return false; } -bool TCEToolChain::isPICDefaultForced() const { - return false; -} +bool TCEToolChain::isPICDefaultForced() const { return false; } // CloudABI - CloudABI tool chain which can call ld(1) directly. @@ -2545,42 +2504,40 @@ void CloudABI::AddCXXStdlibLibArgs(const ArgList &Args, CmdArgs.push_back("-lunwind"); } -Tool *CloudABI::buildLinker() const { return new tools::cloudabi::Link(*this); } +Tool *CloudABI::buildLinker() const { + return new tools::cloudabi::Linker(*this); +} /// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly. -OpenBSD::OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) - : Generic_ELF(D, Triple, Args) { +OpenBSD::OpenBSD(const Driver &D, const llvm::Triple &Triple, + const ArgList &Args) + : Generic_ELF(D, Triple, Args) { getFilePaths().push_back(getDriver().Dir + "/../lib"); getFilePaths().push_back("/usr/lib"); } Tool *OpenBSD::buildAssembler() const { - return new tools::openbsd::Assemble(*this); + return new tools::openbsd::Assembler(*this); } -Tool *OpenBSD::buildLinker() const { - return new tools::openbsd::Link(*this); -} +Tool *OpenBSD::buildLinker() const { return new tools::openbsd::Linker(*this); } /// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly. -Bitrig::Bitrig(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) - : Generic_ELF(D, Triple, Args) { +Bitrig::Bitrig(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) + : Generic_ELF(D, Triple, Args) { getFilePaths().push_back(getDriver().Dir + "/../lib"); getFilePaths().push_back("/usr/lib"); } Tool *Bitrig::buildAssembler() const { - return new tools::bitrig::Assemble(*this); + return new tools::bitrig::Assembler(*this); } -Tool *Bitrig::buildLinker() const { - return new tools::bitrig::Link(*this); -} +Tool *Bitrig::buildLinker() const { return new tools::bitrig::Linker(*this); } -ToolChain::CXXStdlibType -Bitrig::GetCXXStdlibType(const ArgList &Args) const { +ToolChain::CXXStdlibType Bitrig::GetCXXStdlibType(const ArgList &Args) const { if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) { StringRef Value = A->getValue(); if (Value == "libstdc++") @@ -2588,8 +2545,7 @@ Bitrig::GetCXXStdlibType(const ArgList &Args) const { if (Value == "libc++") return ToolChain::CST_Libcxx; - getDriver().Diag(diag::err_drv_invalid_stdlib_name) - << A->getAsString(Args); + getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args); } return ToolChain::CST_Libcxx; } @@ -2615,11 +2571,11 @@ void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, if (Triple.startswith("amd64")) addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot + "/usr/include/c++/stdc++/x86_64" + - Triple.substr(5)); + Triple.substr(5)); else - addSystemInclude(DriverArgs, CC1Args, - getDriver().SysRoot + "/usr/include/c++/stdc++/" + - Triple); + addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot + + "/usr/include/c++/stdc++/" + + Triple); break; } } @@ -2640,8 +2596,9 @@ void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args, /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly. -FreeBSD::FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) - : Generic_ELF(D, Triple, Args) { +FreeBSD::FreeBSD(const Driver &D, const llvm::Triple &Triple, + const ArgList &Args) + : Generic_ELF(D, Triple, Args) { // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall // back to '/usr/lib' if it doesn't exist. @@ -2653,8 +2610,7 @@ FreeBSD::FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Arg getFilePaths().push_back(getDriver().SysRoot + "/usr/lib"); } -ToolChain::CXXStdlibType -FreeBSD::GetCXXStdlibType(const ArgList &Args) const { +ToolChain::CXXStdlibType FreeBSD::GetCXXStdlibType(const ArgList &Args) const { if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) { StringRef Value = A->getValue(); if (Value == "libstdc++") @@ -2662,10 +2618,9 @@ FreeBSD::GetCXXStdlibType(const ArgList &Args) const { if (Value == "libc++") return ToolChain::CST_Libcxx; - getDriver().Diag(diag::err_drv_invalid_stdlib_name) - << A->getAsString(Args); + getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args); } - if (getTriple().getOSMajorVersion() >= 10) + if (getTriple().getOSMajorVersion() >= 10) return ToolChain::CST_Libcxx; return ToolChain::CST_Libstdcxx; } @@ -2691,12 +2646,10 @@ void FreeBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, } Tool *FreeBSD::buildAssembler() const { - return new tools::freebsd::Assemble(*this); + return new tools::freebsd::Assembler(*this); } -Tool *FreeBSD::buildLinker() const { - return new tools::freebsd::Link(*this); -} +Tool *FreeBSD::buildLinker() const { return new tools::freebsd::Linker(*this); } bool FreeBSD::UseSjLjExceptions() const { // FreeBSD uses SjLj exceptions on ARM oabi. @@ -2712,13 +2665,9 @@ bool FreeBSD::UseSjLjExceptions() const { } } -bool FreeBSD::HasNativeLLVMSupport() const { - return true; -} +bool FreeBSD::HasNativeLLVMSupport() const { return true; } -bool FreeBSD::isPIEDefault() const { - return getSanitizerArgs().requiresPIE(); -} +bool FreeBSD::isPIEDefault() const { return getSanitizerArgs().requiresPIE(); } SanitizerMask FreeBSD::getSupportedSanitizers() const { const bool IsX86 = getTriple().getArch() == llvm::Triple::x86; @@ -2740,8 +2689,8 @@ SanitizerMask FreeBSD::getSupportedSanitizers() const { /// 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) - : Generic_ELF(D, Triple, Args) { +NetBSD::NetBSD(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) + : Generic_ELF(D, Triple, Args) { if (getDriver().UseStdLib) { // When targeting a 32-bit platform, try the special directory used on @@ -2793,15 +2742,12 @@ NetBSD::NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) } Tool *NetBSD::buildAssembler() const { - return new tools::netbsd::Assemble(*this); + return new tools::netbsd::Assembler(*this); } -Tool *NetBSD::buildLinker() const { - return new tools::netbsd::Link(*this); -} +Tool *NetBSD::buildLinker() const { return new tools::netbsd::Linker(*this); } -ToolChain::CXXStdlibType -NetBSD::GetCXXStdlibType(const ArgList &Args) const { +ToolChain::CXXStdlibType NetBSD::GetCXXStdlibType(const ArgList &Args) const { if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) { StringRef Value = A->getValue(); if (Value == "libstdc++") @@ -2809,8 +2755,7 @@ NetBSD::GetCXXStdlibType(const ArgList &Args) const { if (Value == "libc++") return ToolChain::CST_Libcxx; - getDriver().Diag(diag::err_drv_invalid_stdlib_name) - << A->getAsString(Args); + getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args); } unsigned Major, Minor, Micro; @@ -2857,25 +2802,23 @@ void NetBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, /// Minix - Minix tool chain which can call as(1) and ld(1) directly. -Minix::Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) - : Generic_ELF(D, Triple, Args) { +Minix::Minix(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) + : Generic_ELF(D, Triple, Args) { getFilePaths().push_back(getDriver().Dir + "/../lib"); getFilePaths().push_back("/usr/lib"); } Tool *Minix::buildAssembler() const { - return new tools::minix::Assemble(*this); + return new tools::minix::Assembler(*this); } -Tool *Minix::buildLinker() const { - return new tools::minix::Link(*this); -} +Tool *Minix::buildLinker() const { return new tools::minix::Linker(*this); } /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly. -Solaris::Solaris(const Driver &D, const llvm::Triple& Triple, +Solaris::Solaris(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) - : Generic_GCC(D, Triple, Args) { + : Generic_GCC(D, Triple, Args) { getProgramPaths().push_back(getDriver().getInstalledDir()); if (getDriver().getInstalledDir() != getDriver().Dir) @@ -2886,16 +2829,17 @@ Solaris::Solaris(const Driver &D, const llvm::Triple& Triple, } Tool *Solaris::buildAssembler() const { - return new tools::solaris::Assemble(*this); + return new tools::solaris::Assembler(*this); } -Tool *Solaris::buildLinker() const { - return new tools::solaris::Link(*this); -} +Tool *Solaris::buildLinker() const { return new tools::solaris::Linker(*this); } /// Distribution (very bare-bones at the moment). enum Distro { + // NB: Releases of a particular Linux distro should be kept together + // in this enum, because some tests are done by integer comparison against + // the first and last known member in the family, e.g. IsRedHat(). ArchLinux, DebianLenny, DebianSqueeze, @@ -2931,9 +2875,7 @@ static bool IsRedhat(enum Distro Distro) { return Distro == Fedora || (Distro >= RHEL4 && Distro <= RHEL7); } -static bool IsOpenSUSE(enum Distro Distro) { - return Distro == OpenSUSE; -} +static bool IsOpenSUSE(enum Distro Distro) { return Distro == OpenSUSE; } static bool IsDebian(enum Distro Distro) { return Distro >= DebianLenny && Distro <= DebianStretch; @@ -2951,25 +2893,25 @@ static Distro DetectDistro(llvm::Triple::ArchType Arch) { SmallVector<StringRef, 16> Lines; Data.split(Lines, "\n"); Distro Version = UnknownDistro; - for (unsigned i = 0, s = Lines.size(); i != s; ++i) - if (Version == UnknownDistro && Lines[i].startswith("DISTRIB_CODENAME=")) - Version = llvm::StringSwitch<Distro>(Lines[i].substr(17)) - .Case("hardy", UbuntuHardy) - .Case("intrepid", UbuntuIntrepid) - .Case("jaunty", UbuntuJaunty) - .Case("karmic", UbuntuKarmic) - .Case("lucid", UbuntuLucid) - .Case("maverick", UbuntuMaverick) - .Case("natty", UbuntuNatty) - .Case("oneiric", UbuntuOneiric) - .Case("precise", UbuntuPrecise) - .Case("quantal", UbuntuQuantal) - .Case("raring", UbuntuRaring) - .Case("saucy", UbuntuSaucy) - .Case("trusty", UbuntuTrusty) - .Case("utopic", UbuntuUtopic) - .Case("vivid", UbuntuVivid) - .Default(UnknownDistro); + for (const StringRef Line : Lines) + if (Version == UnknownDistro && Line.startswith("DISTRIB_CODENAME=")) + Version = llvm::StringSwitch<Distro>(Line.substr(17)) + .Case("hardy", UbuntuHardy) + .Case("intrepid", UbuntuIntrepid) + .Case("jaunty", UbuntuJaunty) + .Case("karmic", UbuntuKarmic) + .Case("lucid", UbuntuLucid) + .Case("maverick", UbuntuMaverick) + .Case("natty", UbuntuNatty) + .Case("oneiric", UbuntuOneiric) + .Case("precise", UbuntuPrecise) + .Case("quantal", UbuntuQuantal) + .Case("raring", UbuntuRaring) + .Case("saucy", UbuntuSaucy) + .Case("trusty", UbuntuTrusty) + .Case("utopic", UbuntuUtopic) + .Case("vivid", UbuntuVivid) + .Default(UnknownDistro); return Version; } @@ -2999,9 +2941,9 @@ static Distro DetectDistro(llvm::Triple::ArchType Arch) { return DebianLenny; else if (Data.startswith("squeeze/sid") || Data[0] == '6') return DebianSqueeze; - else if (Data.startswith("wheezy/sid") || Data[0] == '7') + else if (Data.startswith("wheezy/sid") || Data[0] == '7') return DebianWheezy; - else if (Data.startswith("jessie/sid") || Data[0] == '8') + else if (Data.startswith("jessie/sid") || Data[0] == '8') return DebianJessie; else if (Data.startswith("stretch/sid") || Data[0] == '9') return DebianStretch; @@ -3028,100 +2970,105 @@ static Distro DetectDistro(llvm::Triple::ArchType Arch) { /// so we provide a rough mapping here. static std::string getMultiarchTriple(const llvm::Triple &TargetTriple, StringRef SysRoot) { + llvm::Triple::EnvironmentType TargetEnvironment = TargetTriple.getEnvironment(); + // For most architectures, just use whatever we have rather than trying to be // clever. switch (TargetTriple.getArch()) { default: - return TargetTriple.str(); + break; - // We use the existence of '/lib/<triple>' as a directory to detect some - // common linux triples that don't quite match the Clang triple for both - // 32-bit and 64-bit targets. Multiarch fixes its install triples to these - // regardless of what the actual target triple is. + // We use the existence of '/lib/<triple>' as a directory to detect some + // common linux triples that don't quite match the Clang triple for both + // 32-bit and 64-bit targets. Multiarch fixes its install triples to these + // regardless of what the actual target triple is. case llvm::Triple::arm: case llvm::Triple::thumb: - if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) { + if (TargetEnvironment == llvm::Triple::GNUEABIHF) { if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabihf")) return "arm-linux-gnueabihf"; } else { if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabi")) return "arm-linux-gnueabi"; } - return TargetTriple.str(); + break; case llvm::Triple::armeb: case llvm::Triple::thumbeb: - if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) { + if (TargetEnvironment == llvm::Triple::GNUEABIHF) { if (llvm::sys::fs::exists(SysRoot + "/lib/armeb-linux-gnueabihf")) return "armeb-linux-gnueabihf"; } else { if (llvm::sys::fs::exists(SysRoot + "/lib/armeb-linux-gnueabi")) return "armeb-linux-gnueabi"; } - return TargetTriple.str(); + break; case llvm::Triple::x86: if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu")) return "i386-linux-gnu"; - return TargetTriple.str(); + break; case llvm::Triple::x86_64: // We don't want this for x32, otherwise it will match x86_64 libs - if (TargetTriple.getEnvironment() != llvm::Triple::GNUX32 && + if (TargetEnvironment != llvm::Triple::GNUX32 && llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu")) return "x86_64-linux-gnu"; - return TargetTriple.str(); + break; case llvm::Triple::aarch64: if (llvm::sys::fs::exists(SysRoot + "/lib/aarch64-linux-gnu")) return "aarch64-linux-gnu"; - return TargetTriple.str(); + break; case llvm::Triple::aarch64_be: if (llvm::sys::fs::exists(SysRoot + "/lib/aarch64_be-linux-gnu")) return "aarch64_be-linux-gnu"; - return TargetTriple.str(); + break; case llvm::Triple::mips: if (llvm::sys::fs::exists(SysRoot + "/lib/mips-linux-gnu")) return "mips-linux-gnu"; - return TargetTriple.str(); + break; case llvm::Triple::mipsel: if (llvm::sys::fs::exists(SysRoot + "/lib/mipsel-linux-gnu")) return "mipsel-linux-gnu"; - return TargetTriple.str(); + break; case llvm::Triple::mips64: if (llvm::sys::fs::exists(SysRoot + "/lib/mips64-linux-gnu")) return "mips64-linux-gnu"; if (llvm::sys::fs::exists(SysRoot + "/lib/mips64-linux-gnuabi64")) return "mips64-linux-gnuabi64"; - return TargetTriple.str(); + break; case llvm::Triple::mips64el: if (llvm::sys::fs::exists(SysRoot + "/lib/mips64el-linux-gnu")) return "mips64el-linux-gnu"; if (llvm::sys::fs::exists(SysRoot + "/lib/mips64el-linux-gnuabi64")) return "mips64el-linux-gnuabi64"; - return TargetTriple.str(); + break; case llvm::Triple::ppc: if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnuspe")) return "powerpc-linux-gnuspe"; if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnu")) return "powerpc-linux-gnu"; - return TargetTriple.str(); + break; case llvm::Triple::ppc64: if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64-linux-gnu")) return "powerpc64-linux-gnu"; + break; case llvm::Triple::ppc64le: if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64le-linux-gnu")) return "powerpc64le-linux-gnu"; - return TargetTriple.str(); + break; case llvm::Triple::sparc: if (llvm::sys::fs::exists(SysRoot + "/lib/sparc-linux-gnu")) return "sparc-linux-gnu"; - return TargetTriple.str(); + break; case llvm::Triple::sparcv9: if (llvm::sys::fs::exists(SysRoot + "/lib/sparc64-linux-gnu")) return "sparc64-linux-gnu"; - return TargetTriple.str(); + break; } + return TargetTriple.str(); } static void addPathIfExists(Twine Path, ToolChain::path_list &Paths) { - if (llvm::sys::fs::exists(Path)) Paths.push_back(Path.str()); + if (llvm::sys::fs::exists(Path)) + Paths.push_back(Path.str()); } static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) { @@ -3155,7 +3102,7 @@ static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) { } Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) - : Generic_ELF(D, Triple, Args) { + : Generic_ELF(D, Triple, Args) { GCCInstallation.init(D, Triple, Args); Multilibs = GCCInstallation.getMultilibs(); llvm::Triple::ArchType Arch = Triple.getArch(); @@ -3171,7 +3118,8 @@ Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) // FIXME: This seems unlikely to be Linux-specific. ToolChain::path_list &PPaths = getProgramPaths(); PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" + - GCCInstallation.getTriple().str() + "/bin").str()); + GCCInstallation.getTriple().str() + "/bin") + .str()); Linker = GetLinkerPath(); @@ -3235,8 +3183,7 @@ Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) // Sourcery CodeBench MIPS toolchain holds some libraries under // a biarch-like suffix of the GCC installation. - addPathIfExists((GCCInstallation.getInstallPath() + - Multilib.gccSuffix()), + addPathIfExists((GCCInstallation.getInstallPath() + Multilib.gccSuffix()), Paths); // GCC cross compiling toolchains will install target libraries which ship @@ -3258,7 +3205,7 @@ Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) // Note that this matches the GCC behavior. See the below comment for where // Clang diverges from GCC's behavior. addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" + OSLibDir + - Multilib.osSuffix(), + Multilib.osSuffix(), Paths); // If the GCC installation we found is inside of the sysroot, we want to @@ -3295,13 +3242,14 @@ Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) // installations with strange symlinks. if (GCCInstallation.isValid()) { addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() + - "/../../" + OSLibDir, Paths); + "/../../" + OSLibDir, + Paths); // Add the 'other' biarch variant path Multilib BiarchSibling; if (GCCInstallation.getBiarchSibling(BiarchSibling)) { - addPathIfExists(GCCInstallation.getInstallPath() + - BiarchSibling.gccSuffix(), Paths); + addPathIfExists( + GCCInstallation.getInstallPath() + BiarchSibling.gccSuffix(), Paths); } // See comments above on the multilib variant for details of why this is @@ -3309,8 +3257,9 @@ Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) const std::string &LibPath = GCCInstallation.getParentLibPath(); const llvm::Triple &GCCTriple = GCCInstallation.getTriple(); const Multilib &Multilib = GCCInstallation.getMultilib(); - addPathIfExists(LibPath + "/../" + GCCTriple.str() + - "/lib" + Multilib.osSuffix(), Paths); + addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib" + + Multilib.osSuffix(), + Paths); // See comments above on the multilib variant for details of why this is // only included from within the sysroot. @@ -3330,16 +3279,12 @@ Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) addPathIfExists(SysRoot + "/usr/lib", Paths); } -bool Linux::HasNativeLLVMSupport() const { - return true; -} +bool Linux::HasNativeLLVMSupport() const { return true; } -Tool *Linux::buildLinker() const { - return new tools::gnutools::Link(*this); -} +Tool *Linux::buildLinker() const { return new tools::gnutools::Linker(*this); } Tool *Linux::buildAssembler() const { - return new tools::gnutools::Assemble(*this); + return new tools::gnutools::Assembler(*this); } std::string Linux::computeSysRoot() const { @@ -3357,8 +3302,9 @@ std::string Linux::computeSysRoot() const { const StringRef TripleStr = GCCInstallation.getTriple().str(); const Multilib &Multilib = GCCInstallation.getMultilib(); - std::string Path = (InstallDir + "/../../../../" + TripleStr + "/libc" + - Multilib.osSuffix()).str(); + std::string Path = + (InstallDir + "/../../../../" + TripleStr + "/libc" + Multilib.osSuffix()) + .str(); if (llvm::sys::fs::exists(Path)) return Path; @@ -3421,91 +3367,91 @@ void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs, // Implement generic Debian multiarch support. const StringRef X86_64MultiarchIncludeDirs[] = { - "/usr/include/x86_64-linux-gnu", + "/usr/include/x86_64-linux-gnu", - // FIXME: These are older forms of multiarch. It's not clear that they're - // in use in any released version of Debian, so we should consider - // removing them. - "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64" - }; + // FIXME: These are older forms of multiarch. It's not clear that they're + // in use in any released version of Debian, so we should consider + // removing them. + "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"}; const StringRef X86MultiarchIncludeDirs[] = { - "/usr/include/i386-linux-gnu", + "/usr/include/i386-linux-gnu", - // FIXME: These are older forms of multiarch. It's not clear that they're - // in use in any released version of Debian, so we should consider - // removing them. - "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu", - "/usr/include/i486-linux-gnu" - }; + // FIXME: These are older forms of multiarch. It's not clear that they're + // in use in any released version of Debian, so we should consider + // removing them. + "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu", + "/usr/include/i486-linux-gnu"}; const StringRef AArch64MultiarchIncludeDirs[] = { - "/usr/include/aarch64-linux-gnu" - }; + "/usr/include/aarch64-linux-gnu"}; const StringRef ARMMultiarchIncludeDirs[] = { - "/usr/include/arm-linux-gnueabi" - }; + "/usr/include/arm-linux-gnueabi"}; const StringRef ARMHFMultiarchIncludeDirs[] = { - "/usr/include/arm-linux-gnueabihf" - }; - const StringRef MIPSMultiarchIncludeDirs[] = { - "/usr/include/mips-linux-gnu" - }; + "/usr/include/arm-linux-gnueabihf"}; + const StringRef MIPSMultiarchIncludeDirs[] = {"/usr/include/mips-linux-gnu"}; const StringRef MIPSELMultiarchIncludeDirs[] = { - "/usr/include/mipsel-linux-gnu" - }; + "/usr/include/mipsel-linux-gnu"}; const StringRef MIPS64MultiarchIncludeDirs[] = { - "/usr/include/mips64-linux-gnu", - "/usr/include/mips64-linux-gnuabi64" - }; + "/usr/include/mips64-linux-gnu", "/usr/include/mips64-linux-gnuabi64"}; const StringRef MIPS64ELMultiarchIncludeDirs[] = { - "/usr/include/mips64el-linux-gnu", - "/usr/include/mips64el-linux-gnuabi64" - }; + "/usr/include/mips64el-linux-gnu", + "/usr/include/mips64el-linux-gnuabi64"}; const StringRef PPCMultiarchIncludeDirs[] = { - "/usr/include/powerpc-linux-gnu" - }; + "/usr/include/powerpc-linux-gnu"}; const StringRef PPC64MultiarchIncludeDirs[] = { - "/usr/include/powerpc64-linux-gnu" - }; + "/usr/include/powerpc64-linux-gnu"}; const StringRef PPC64LEMultiarchIncludeDirs[] = { - "/usr/include/powerpc64le-linux-gnu" - }; + "/usr/include/powerpc64le-linux-gnu"}; const StringRef SparcMultiarchIncludeDirs[] = { - "/usr/include/sparc-linux-gnu" - }; + "/usr/include/sparc-linux-gnu"}; const StringRef Sparc64MultiarchIncludeDirs[] = { - "/usr/include/sparc64-linux-gnu" - }; + "/usr/include/sparc64-linux-gnu"}; ArrayRef<StringRef> MultiarchIncludeDirs; - if (getTriple().getArch() == llvm::Triple::x86_64) { + switch (getTriple().getArch()) { + case llvm::Triple::x86_64: MultiarchIncludeDirs = X86_64MultiarchIncludeDirs; - } else if (getTriple().getArch() == llvm::Triple::x86) { + break; + case llvm::Triple::x86: MultiarchIncludeDirs = X86MultiarchIncludeDirs; - } else if (getTriple().getArch() == llvm::Triple::aarch64 || - getTriple().getArch() == llvm::Triple::aarch64_be) { + break; + case llvm::Triple::aarch64: + case llvm::Triple::aarch64_be: MultiarchIncludeDirs = AArch64MultiarchIncludeDirs; - } else if (getTriple().getArch() == llvm::Triple::arm) { + break; + case llvm::Triple::arm: if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF) MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs; else MultiarchIncludeDirs = ARMMultiarchIncludeDirs; - } else if (getTriple().getArch() == llvm::Triple::mips) { + break; + case llvm::Triple::mips: MultiarchIncludeDirs = MIPSMultiarchIncludeDirs; - } else if (getTriple().getArch() == llvm::Triple::mipsel) { + break; + case llvm::Triple::mipsel: MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs; - } else if (getTriple().getArch() == llvm::Triple::mips64) { + break; + case llvm::Triple::mips64: MultiarchIncludeDirs = MIPS64MultiarchIncludeDirs; - } else if (getTriple().getArch() == llvm::Triple::mips64el) { + break; + case llvm::Triple::mips64el: MultiarchIncludeDirs = MIPS64ELMultiarchIncludeDirs; - } else if (getTriple().getArch() == llvm::Triple::ppc) { + break; + case llvm::Triple::ppc: MultiarchIncludeDirs = PPCMultiarchIncludeDirs; - } else if (getTriple().getArch() == llvm::Triple::ppc64) { + break; + case llvm::Triple::ppc64: MultiarchIncludeDirs = PPC64MultiarchIncludeDirs; - } else if (getTriple().getArch() == llvm::Triple::ppc64le) { + break; + case llvm::Triple::ppc64le: MultiarchIncludeDirs = PPC64LEMultiarchIncludeDirs; - } else if (getTriple().getArch() == llvm::Triple::sparc) { + break; + case llvm::Triple::sparc: MultiarchIncludeDirs = SparcMultiarchIncludeDirs; - } else if (getTriple().getArch() == llvm::Triple::sparcv9) { + break; + case llvm::Triple::sparcv9: MultiarchIncludeDirs = Sparc64MultiarchIncludeDirs; + break; + default: + break; } for (StringRef Dir : MultiarchIncludeDirs) { if (llvm::sys::fs::exists(SysRoot + Dir)) { @@ -3526,13 +3472,10 @@ void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs, } /// \brief Helper to add the variant paths of a libstdc++ installation. -/*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine Suffix, - StringRef GCCTriple, - StringRef GCCMultiarchTriple, - StringRef TargetMultiarchTriple, - Twine IncludeSuffix, - const ArgList &DriverArgs, - ArgStringList &CC1Args) { +/*static*/ bool Linux::addLibStdCXXIncludePaths( + Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple, + StringRef TargetMultiarchTriple, Twine IncludeSuffix, + const ArgList &DriverArgs, ArgStringList &CC1Args) { if (!llvm::sys::fs::exists(Base + Suffix)) return false; @@ -3570,15 +3513,15 @@ void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, // Check if libc++ has been enabled and provide its include paths if so. if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) { const std::string LibCXXIncludePathCandidates[] = { - // The primary location is within the Clang installation. - // FIXME: We shouldn't hard code 'v1' here to make Clang future proof to - // newer ABI versions. - getDriver().Dir + "/../include/c++/v1", - - // We also check the system as for a long time this is the only place Clang looked. - // FIXME: We should really remove this. It doesn't make any sense. - getDriver().SysRoot + "/usr/include/c++/v1" - }; + // The primary location is within the Clang installation. + // FIXME: We shouldn't hard code 'v1' here to make Clang future proof to + // newer ABI versions. + getDriver().Dir + "/../include/c++/v1", + + // We also check the system as for a long time this is the only place + // Clang looked. + // FIXME: We should really remove this. It doesn't make any sense. + getDriver().SysRoot + "/usr/include/c++/v1"}; for (const auto &IncludePath : LibCXXIncludePathCandidates) { if (!llvm::sys::fs::exists(IncludePath)) continue; @@ -3609,24 +3552,24 @@ void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, // The primary search for libstdc++ supports multiarch variants. if (addLibStdCXXIncludePaths(LibDir.str() + "/../include", - "/c++/" + Version.Text, TripleStr, GCCMultiarchTriple, - TargetMultiarchTriple, + "/c++/" + Version.Text, TripleStr, + GCCMultiarchTriple, TargetMultiarchTriple, Multilib.includeSuffix(), DriverArgs, CC1Args)) return; // Otherwise, fall back on a bunch of options which don't use multiarch // layouts for simplicity. const std::string LibStdCXXIncludePathCandidates[] = { - // Gentoo is weird and places its headers inside the GCC install, so if the - // first attempt to find the headers fails, try these patterns. - InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." + - Version.MinorStr, - InstallDir.str() + "/include/g++-v" + Version.MajorStr, - // Android standalone toolchain has C++ headers in yet another place. - LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text, - // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++, - // without a subdirectory corresponding to the gcc version. - LibDir.str() + "/../include/c++", + // Gentoo is weird and places its headers inside the GCC install, + // so if the first attempt to find the headers fails, try these patterns. + InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." + + Version.MinorStr, + InstallDir.str() + "/include/g++-v" + Version.MajorStr, + // Android standalone toolchain has C++ headers in yet another place. + LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text, + // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++, + // without a subdirectory corresponding to the gcc version. + LibDir.str() + "/../include/c++", }; for (const auto &IncludePath : LibStdCXXIncludePathCandidates) { @@ -3638,15 +3581,15 @@ void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, } } -bool Linux::isPIEDefault() const { - return getSanitizerArgs().requiresPIE(); -} +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; + const bool IsPowerPC64 = getTriple().getArch() == llvm::Triple::ppc64 || + getTriple().getArch() == llvm::Triple::ppc64le; SanitizerMask Res = ToolChain::getSupportedSanitizers(); Res |= SanitizerKind::Address; Res |= SanitizerKind::KernelAddress; @@ -3654,9 +3597,10 @@ SanitizerMask Linux::getSupportedSanitizers() const { if (IsX86_64 || IsMIPS64) { Res |= SanitizerKind::DataFlow; Res |= SanitizerKind::Leak; - Res |= SanitizerKind::Memory; Res |= SanitizerKind::Thread; } + if (IsX86_64 || IsMIPS64 || IsPowerPC64) + Res |= SanitizerKind::Memory; if (IsX86 || IsX86_64) { Res |= SanitizerKind::Function; Res |= SanitizerKind::SafeStack; @@ -3666,8 +3610,9 @@ SanitizerMask Linux::getSupportedSanitizers() const { /// 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) - : Generic_ELF(D, Triple, Args) { +DragonFly::DragonFly(const Driver &D, const llvm::Triple &Triple, + const ArgList &Args) + : Generic_ELF(D, Triple, Args) { // Path mangling to find libexec getProgramPaths().push_back(getDriver().getInstalledDir()); @@ -3683,47 +3628,34 @@ DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList } Tool *DragonFly::buildAssembler() const { - return new tools::dragonfly::Assemble(*this); + return new tools::dragonfly::Assembler(*this); } Tool *DragonFly::buildLinker() const { - return new tools::dragonfly::Link(*this); + return new tools::dragonfly::Linker(*this); } - /// XCore tool chain -XCore::XCore(const Driver &D, const llvm::Triple &Triple, - const ArgList &Args) : ToolChain(D, Triple, Args) { +XCore::XCore(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) + : ToolChain(D, Triple, Args) { // ProgramPaths are found via 'PATH' environment variable. } Tool *XCore::buildAssembler() const { - return new tools::XCore::Assemble(*this); + return new tools::XCore::Assembler(*this); } -Tool *XCore::buildLinker() const { - return new tools::XCore::Link(*this); -} +Tool *XCore::buildLinker() const { return new tools::XCore::Linker(*this); } -bool XCore::isPICDefault() const { - return false; -} +bool XCore::isPICDefault() const { return false; } -bool XCore::isPIEDefault() const { - return false; -} +bool XCore::isPIEDefault() const { return false; } -bool XCore::isPICDefaultForced() const { - return false; -} +bool XCore::isPICDefaultForced() const { return false; } -bool XCore::SupportsProfiling() const { - return false; -} +bool XCore::SupportsProfiling() const { return false; } -bool XCore::hasBlocksRuntime() const { - return false; -} +bool XCore::hasBlocksRuntime() const { return false; } void XCore::AddClangSystemIncludeArgs(const ArgList &DriverArgs, ArgStringList &CC1Args) const { @@ -3732,7 +3664,7 @@ void XCore::AddClangSystemIncludeArgs(const ArgList &DriverArgs, return; if (const char *cl_include_dir = getenv("XCC_C_INCLUDE_PATH")) { SmallVector<StringRef, 4> Dirs; - const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,'\0'}; + const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'}; StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr)); ArrayRef<StringRef> DirVec(Dirs); addSystemIncludes(DriverArgs, CC1Args, DirVec); @@ -3752,7 +3684,7 @@ void XCore::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, return; if (const char *cl_include_dir = getenv("XCC_CPLUS_INCLUDE_PATH")) { SmallVector<StringRef, 4> Dirs; - const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,'\0'}; + const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'}; StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr)); ArrayRef<StringRef> DirVec(Dirs); addSystemIncludes(DriverArgs, CC1Args, DirVec); @@ -3770,11 +3702,11 @@ Tool *SHAVEToolChain::SelectTool(const JobAction &JA) const { switch (JA.getKind()) { case Action::CompileJobClass: if (!Compiler) - Compiler.reset(new tools::SHAVE::Compile(*this)); + Compiler.reset(new tools::SHAVE::Compiler(*this)); return Compiler.get(); case Action::AssembleJobClass: if (!Assembler) - Assembler.reset(new tools::SHAVE::Assemble(*this)); + Assembler.reset(new tools::SHAVE::Assembler(*this)); return Assembler.get(); default: return ToolChain::getTool(JA.getKind()); @@ -3782,7 +3714,7 @@ Tool *SHAVEToolChain::SelectTool(const JobAction &JA) const { } SHAVEToolChain::SHAVEToolChain(const Driver &D, const llvm::Triple &Triple, - const ArgList &Args) + const ArgList &Args) : Generic_GCC(D, Triple, Args) {} SHAVEToolChain::~SHAVEToolChain() {} diff --git a/lib/Driver/ToolChains.h b/lib/Driver/ToolChains.h index a48bb5fa5948..629f90ac79f8 100644 --- a/lib/Driver/ToolChains.h +++ b/lib/Driver/ToolChains.h @@ -101,7 +101,7 @@ protected: public: GCCInstallationDetector() : IsValid(false) {} void init(const Driver &D, const llvm::Triple &TargetTriple, - const llvm::opt::ArgList &Args); + const llvm::opt::ArgList &Args); /// \brief Check whether we detected a valid GCC install. bool isValid() const { return IsValid; } @@ -179,8 +179,8 @@ protected: /// @} private: - mutable std::unique_ptr<tools::gcc::Preprocess> Preprocess; - mutable std::unique_ptr<tools::gcc::Compile> Compile; + mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocess; + mutable std::unique_ptr<tools::gcc::Compiler> Compile; }; class LLVM_LIBRARY_VISIBILITY MachO : public ToolChain { @@ -188,6 +188,7 @@ protected: Tool *buildAssembler() const override; Tool *buildLinker() const override; Tool *getTool(Action::ActionClass AC) const override; + private: mutable std::unique_ptr<tools::darwin::Lipo> Lipo; mutable std::unique_ptr<tools::darwin::Dsymutil> Dsymutil; @@ -195,7 +196,7 @@ private: public: MachO(const Driver &D, const llvm::Triple &Triple, - const llvm::opt::ArgList &Args); + const llvm::opt::ArgList &Args); ~MachO() override; /// @name MachO specific toolchain API @@ -205,7 +206,6 @@ public: /// example, Apple treats different ARM variations as distinct architectures. StringRef getMachOArchName(const llvm::opt::ArgList &Args) const; - /// Add the linker arguments to link the ARC runtime library. virtual void AddLinkARCArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const {} @@ -214,30 +214,24 @@ public: virtual void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const; - virtual void - addStartObjectFileArgs(const llvm::opt::ArgList &Args, - llvm::opt::ArgStringList &CmdArgs) const {} + virtual void addStartObjectFileArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const { + } virtual void addMinVersionArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const {} /// On some iOS platforms, kernel and kernel modules were built statically. Is /// this such a target? - virtual bool isKernelStatic() const { - return false; - } + virtual bool isKernelStatic() const { return false; } /// Is the target either iOS or an iOS simulator? - bool isTargetIOSBased() const { - return false; - } + bool isTargetIOSBased() const { return false; } void AddLinkRuntimeLib(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, - StringRef DarwinLibName, - bool AlwaysLink = false, - bool IsEmbedded = false, - bool AddRPath = false) const; + StringRef DarwinLibName, bool AlwaysLink = false, + bool IsEmbedded = false, bool AddRPath = false) const; /// Add any profiling runtime libraries that are needed. This is essentially a /// MachO specific version of addProfileRT in Tools.cpp. @@ -271,22 +265,16 @@ public: return true; } - bool IsMathErrnoDefault() const override { - return false; - } + bool IsMathErrnoDefault() const override { return false; } - bool IsEncodeExtendedBlockSignatureDefault() const override { - return true; - } + bool IsEncodeExtendedBlockSignatureDefault() const override { return true; } bool IsObjCNonFragileABIDefault() const override { // Non-fragile ABI is default for everything but i386. return getTriple().getArch() != llvm::Triple::x86; } - bool UseObjCMixedDispatch() const override { - return true; - } + bool UseObjCMixedDispatch() const override { return true; } bool IsUnwindTablesDefault() const override; @@ -300,20 +288,16 @@ public: bool SupportsProfiling() const override; - bool SupportsObjCGC() const override { - return false; - } + bool SupportsObjCGC() const override { return false; } bool UseDwarfDebugFlags() const override; - bool UseSjLjExceptions() const override { - return false; - } + bool UseSjLjExceptions() const override { return false; } /// } }; - /// Darwin - The base Darwin tool chain. +/// Darwin - The base Darwin tool chain. class LLVM_LIBRARY_VISIBILITY Darwin : public MachO { public: /// Whether the information on the target has been initialized. @@ -323,11 +307,7 @@ public: // the argument translation business. mutable bool TargetInitialized; - enum DarwinPlatformKind { - MacOS, - IPhoneOS, - IPhoneOSSimulator - }; + enum DarwinPlatformKind { MacOS, IPhoneOS, IPhoneOSSimulator }; mutable DarwinPlatformKind TargetPlatform; @@ -348,14 +328,12 @@ public: /// @name Apple Specific Toolchain Implementation /// { - void - addMinVersionArgs(const llvm::opt::ArgList &Args, - llvm::opt::ArgStringList &CmdArgs) const override; - - void - addStartObjectFileArgs(const llvm::opt::ArgList &Args, + void addMinVersionArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override; + void addStartObjectFileArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const override; + bool isKernelStatic() const override { return !isTargetIPhoneOS() || isIPhoneOSVersionLT(6, 0); } @@ -411,12 +389,13 @@ protected: return TargetVersion; } - bool isIPhoneOSVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const { + bool isIPhoneOSVersionLT(unsigned V0, unsigned V1 = 0, + unsigned V2 = 0) const { assert(isTargetIOSBased() && "Unexpected call for non iOS target!"); return TargetVersion < VersionTuple(V0, V1, V2); } - bool isMacosxVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const { + bool isMacosxVersionLT(unsigned V0, unsigned V1 = 0, unsigned V2 = 0) const { assert(isTargetMacOS() && "Unexpected call for non OS X target!"); return TargetVersion < VersionTuple(V0, V1, V2); } @@ -476,23 +455,19 @@ public: /// @name Apple ToolChain Implementation /// { - void - AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args, - llvm::opt::ArgStringList &CmdArgs) const override; + void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const override; - void - AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, - llvm::opt::ArgStringList &CmdArgs) const override; + void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const override; - void - AddCCKextLibArgs(const llvm::opt::ArgList &Args, - llvm::opt::ArgStringList &CmdArgs) const override; + void AddCCKextLibArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const override; void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override; - void - AddLinkARCArgs(const llvm::opt::ArgList &Args, - llvm::opt::ArgStringList &CmdArgs) const override; + void AddLinkARCArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const override; /// } private: @@ -503,6 +478,7 @@ private: class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC { virtual void anchor(); + public: Generic_ELF(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args) @@ -521,8 +497,8 @@ public: bool IsMathErrnoDefault() const override { return false; } bool IsObjCNonFragileABIDefault() const override { return true; } - CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) - const override { + CXXStdlibType + GetCXXStdlibType(const llvm::opt::ArgList &Args) const override { return ToolChain::CST_Libcxx; } void AddClangCXXStdlibIncludeArgs( @@ -543,12 +519,43 @@ public: const llvm::opt::ArgList &Args); bool IsIntegratedAssemblerDefault() const override { return true; } + protected: Tool *buildAssembler() const override; Tool *buildLinker() const override; - }; +class LLVM_LIBRARY_VISIBILITY MinGW : public ToolChain { +public: + MinGW(const Driver &D, const llvm::Triple &Triple, + const llvm::opt::ArgList &Args); + + bool IsIntegratedAssemblerDefault() const override; + bool IsUnwindTablesDefault() const override; + bool isPICDefault() const override; + bool isPIEDefault() const override; + bool isPICDefaultForced() const override; + bool UseSEHExceptions() const; + + void + AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; + void AddClangCXXStdlibIncludeArgs( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; + +protected: + Tool *getTool(Action::ActionClass AC) const override; + Tool *buildLinker() const override; + Tool *buildAssembler() const override; + +private: + std::string Base; + std::string GccLibDir; + std::string Arch; + mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocessor; + mutable std::unique_ptr<tools::gcc::Compiler> Compiler; +}; class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF { public: @@ -577,13 +584,13 @@ public: bool IsObjCNonFragileABIDefault() const override { return true; } CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override; - void - AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, - llvm::opt::ArgStringList &CC1Args) const override; + void AddClangCXXStdlibIncludeArgs( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override; unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override { - return 1; + return 1; } protected: @@ -601,13 +608,14 @@ public: bool IsObjCNonFragileABIDefault() const override { return true; } CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override; - void - AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, - llvm::opt::ArgStringList &CC1Args) const override; + void AddClangCXXStdlibIncludeArgs( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; bool UseSjLjExceptions() const override; bool isPIEDefault() const override; SanitizerMask getSupportedSanitizers() const override; + protected: Tool *buildAssembler() const override; Tool *buildLinker() const override; @@ -623,12 +631,10 @@ public: CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override; - void - AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, - llvm::opt::ArgStringList &CC1Args) const override; - bool IsUnwindTablesDefault() const override { - return true; - } + void AddClangCXXStdlibIncludeArgs( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; + bool IsUnwindTablesDefault() const override { return true; } protected: Tool *buildAssembler() const override; @@ -667,9 +673,9 @@ public: void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override; - void - AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, - llvm::opt::ArgStringList &CC1Args) const override; + void AddClangCXXStdlibIncludeArgs( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; bool isPIEDefault() const override; SanitizerMask getSupportedSanitizers() const override; @@ -706,9 +712,9 @@ public: void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override; - void - AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, - llvm::opt::ArgStringList &CC1Args) const override; + void AddClangCXXStdlibIncludeArgs( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override; StringRef GetGCCLibAndIncVersion() const { return GCCLibAndIncVersion.Text; } @@ -720,7 +726,7 @@ public: static const char *GetSmallDataThreshold(const llvm::opt::ArgList &Args); - static bool UsesG0(const char* smallDataThreshold); + static bool UsesG0(const char *smallDataThreshold); }; class LLVM_LIBRARY_VISIBILITY NaCl_TC : public Generic_ELF { @@ -731,19 +737,16 @@ public: void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override; - void - AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, - llvm::opt::ArgStringList &CC1Args) const override; + void AddClangCXXStdlibIncludeArgs( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; - CXXStdlibType - GetCXXStdlibType(const llvm::opt::ArgList &Args) const override; + CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override; - void - AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, - llvm::opt::ArgStringList &CmdArgs) const override; + void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const override; - bool - IsIntegratedAssemblerDefault() const override { return false; } + bool IsIntegratedAssemblerDefault() const override { return false; } // Get the path to the file containing NaCl's ARM macros. It lives in NaCl_TC // because the AssembleARM tool needs a const char * that it can pass around @@ -790,9 +793,9 @@ public: void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override; - void - AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, - llvm::opt::ArgStringList &CC1Args) const override; + void AddClangCXXStdlibIncludeArgs( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; bool getWindowsSDKDir(std::string &path, int &major, int &minor) const; bool getWindowsSDKLibraryPath(std::string &path) const; @@ -829,12 +832,12 @@ public: return 0; } - void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, - llvm::opt::ArgStringList &CC1Args) - const override; - void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, - llvm::opt::ArgStringList &CC1Args) - const override; + void + AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; + void AddClangCXXStdlibIncludeArgs( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override; @@ -846,22 +849,26 @@ protected: class LLVM_LIBRARY_VISIBILITY XCore : public ToolChain { public: XCore(const Driver &D, const llvm::Triple &Triple, - const llvm::opt::ArgList &Args); + const llvm::opt::ArgList &Args); + protected: Tool *buildAssembler() const override; Tool *buildLinker() const override; + public: bool isPICDefault() const override; bool isPIEDefault() const override; bool isPICDefaultForced() const override; bool SupportsProfiling() const override; bool hasBlocksRuntime() const override; - void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, - llvm::opt::ArgStringList &CC1Args) const override; + void + AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override; - void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, - llvm::opt::ArgStringList &CC1Args) const override; + void AddClangCXXStdlibIncludeArgs( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override; }; @@ -872,7 +879,7 @@ public: class LLVM_LIBRARY_VISIBILITY SHAVEToolChain : public Generic_GCC { public: SHAVEToolChain(const Driver &D, const llvm::Triple &Triple, - const llvm::opt::ArgList &Args); + const llvm::opt::ArgList &Args); ~SHAVEToolChain() override; virtual Tool *SelectTool(const JobAction &JA) const override; diff --git a/lib/Driver/Tools.cpp b/lib/Driver/Tools.cpp index 2367914cc0b4..a2955dbb9e77 100644 --- a/lib/Driver/Tools.cpp +++ b/lib/Driver/Tools.cpp @@ -84,10 +84,10 @@ static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) { static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) { // In gcc, only ARM checks this, but it seems reasonable to check universally. if (Args.hasArg(options::OPT_static)) - if (const Arg *A = Args.getLastArg(options::OPT_dynamic, - options::OPT_mdynamic_no_pic)) - D.Diag(diag::err_drv_argument_not_allowed_with) - << A->getAsString(Args) << "-static"; + if (const Arg *A = + Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic)) + D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args) + << "-static"; } // Add backslashes to escape spaces and other backslashes. @@ -95,9 +95,10 @@ static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) { // the -dwarf-debug-flags option. static void EscapeSpacesAndBackslashes(const char *Arg, SmallVectorImpl<char> &Res) { - for ( ; *Arg; ++Arg) { + for (; *Arg; ++Arg) { switch (*Arg) { - default: break; + default: + break; case ' ': case '\\': Res.push_back('\\'); @@ -109,8 +110,7 @@ static void EscapeSpacesAndBackslashes(const char *Arg, // Quote target names for inclusion in GNU Make dependency files. // Only the characters '$', '#', ' ', '\t' are quoted. -static void QuoteTarget(StringRef Target, - SmallVectorImpl<char> &Res) { +static void QuoteTarget(StringRef Target, SmallVectorImpl<char> &Res) { for (unsigned i = 0, e = Target.size(); i != e; ++i) { switch (Target[i]) { case ' ': @@ -136,10 +136,8 @@ static void QuoteTarget(StringRef Target, } } -static void addDirectoryList(const ArgList &Args, - ArgStringList &CmdArgs, - const char *ArgName, - const char *EnvVar) { +static void addDirectoryList(const ArgList &Args, ArgStringList &CmdArgs, + const char *ArgName, const char *EnvVar) { const char *DirList = ::getenv(EnvVar); bool CombinedArg = false; @@ -165,7 +163,8 @@ static void addDirectoryList(const ArgList &Args, } } else { if (CombinedArg) { - CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim))); + CmdArgs.push_back( + Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim))); } else { CmdArgs.push_back(ArgName); CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim))); @@ -191,9 +190,8 @@ static void addDirectoryList(const ArgList &Args, } } -static void AddLinkerInputs(const ToolChain &TC, - const InputInfoList &Inputs, const ArgList &Args, - ArgStringList &CmdArgs) { +static void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, + const ArgList &Args, ArgStringList &CmdArgs) { const Driver &D = TC.getDriver(); // Add extra linker input arguments which are not treated as inputs @@ -205,10 +203,8 @@ static void AddLinkerInputs(const ToolChain &TC, // Don't try to pass LLVM inputs unless we have native support. if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR || - II.getType() == types::TY_LLVM_BC || - II.getType() == types::TY_LTO_BC) - D.Diag(diag::err_drv_no_linker_llvm_support) - << TC.getTripleString(); + II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC) + D.Diag(diag::err_drv_no_linker_llvm_support) << TC.getTripleString(); } // Add filenames immediately. @@ -230,7 +226,7 @@ static void AddLinkerInputs(const ToolChain &TC, A.claim(); A.render(Args, CmdArgs); } else { - A.renderAsInput(Args, CmdArgs); + A.renderAsInput(Args, CmdArgs); } } @@ -259,14 +255,11 @@ static bool forwardToGCC(const Option &O) { // Don't forward inputs from the original command line. They are added from // InputInfoList. return O.getKind() != Option::InputClass && - !O.hasFlag(options::DriverOption) && - !O.hasFlag(options::LinkerInput); + !O.hasFlag(options::DriverOption) && !O.hasFlag(options::LinkerInput); } -void Clang::AddPreprocessingOptions(Compilation &C, - const JobAction &JA, - const Driver &D, - const ArgList &Args, +void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA, + const Driver &D, const ArgList &Args, ArgStringList &CmdArgs, const InputInfo &Output, const InputInfoList &Inputs) const { @@ -333,7 +326,7 @@ void Clang::AddPreprocessingOptions(Compilation &C, if (Args.hasArg(options::OPT_MG)) { if (!A || A->getOption().matches(options::OPT_MD) || - A->getOption().matches(options::OPT_MMD)) + A->getOption().matches(options::OPT_MMD)) D.Diag(diag::err_drv_mg_requires_m_or_mm); CmdArgs.push_back("-MG"); } @@ -351,7 +344,7 @@ void Clang::AddPreprocessingOptions(Compilation &C, QuoteTarget(A->getValue(), Quoted); CmdArgs.push_back(Args.MakeArgString(Quoted)); - // -MT flag - no change + // -MT flag - no change } else { A->render(Args, CmdArgs); } @@ -408,8 +401,8 @@ void Clang::AddPreprocessingOptions(Compilation &C, continue; } else { // Ignore the PCH if not first on command line and emit warning. - D.Diag(diag::warn_drv_pch_not_first_include) - << P << A->getAsString(Args); + D.Diag(diag::warn_drv_pch_not_first_include) << P + << A->getAsString(Args); } } } @@ -511,8 +504,8 @@ static bool isNoCommonDefault(const llvm::Triple &Triple) { // Handle -mhwdiv=. static void getARMHWDivFeatures(const Driver &D, const Arg *A, - const ArgList &Args, - std::vector<const char *> &Features) { + const ArgList &Args, + std::vector<const char *> &Features) { StringRef HWDiv = A->getValue(); if (HWDiv == "arm") { Features.push_back("+hwdiv-arm"); @@ -556,9 +549,9 @@ static bool isARMMProfile(const llvm::Triple &Triple) { StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args, const llvm::Triple &Triple) { StringRef FloatABI; - if (Arg *A = Args.getLastArg(options::OPT_msoft_float, - options::OPT_mhard_float, - options::OPT_mfloat_abi_EQ)) { + if (Arg *A = + Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float, + options::OPT_mfloat_abi_EQ)) { if (A->getOption().matches(options::OPT_msoft_float)) FloatABI = "soft"; else if (A->getOption().matches(options::OPT_mhard_float)) @@ -566,8 +559,7 @@ StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args, else { FloatABI = A->getValue(); if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") { - D.Diag(diag::err_drv_invalid_mfloat_abi) - << A->getAsString(Args); + D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args); FloatABI = "soft"; } } @@ -595,7 +587,7 @@ StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args, break; case llvm::Triple::FreeBSD: - switch(Triple.getEnvironment()) { + switch (Triple.getEnvironment()) { case llvm::Triple::GNUEABIHF: FloatABI = "hard"; break; @@ -607,7 +599,7 @@ StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args, break; default: - switch(Triple.getEnvironment()) { + switch (Triple.getEnvironment()) { case llvm::Triple::GNUEABIHF: FloatABI = "hard"; break; @@ -715,8 +707,7 @@ static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple, } } -void Clang::AddARMTargetArgs(const ArgList &Args, - ArgStringList &CmdArgs, +void Clang::AddARMTargetArgs(const ArgList &Args, ArgStringList &CmdArgs, bool KernelOrKext) const { const Driver &D = getToolChain().getDriver(); // Get the effective triple, which takes into account the deployment target. @@ -734,8 +725,7 @@ void Clang::AddARMTargetArgs(const ArgList &Args, // The backend is hardwired to assume AAPCS for M-class processors, ensure // the frontend matches that. if (Triple.getEnvironment() == llvm::Triple::EABI || - Triple.getOS() == llvm::Triple::UnknownOS || - isARMMProfile(Triple)) { + Triple.getOS() == llvm::Triple::UnknownOS || isARMMProfile(Triple)) { ABIName = "aapcs"; } else { ABIName = "apcs-gnu"; @@ -745,7 +735,7 @@ void Clang::AddARMTargetArgs(const ArgList &Args, ABIName = "aapcs"; } else { // Select the default based on the platform. - switch(Triple.getEnvironment()) { + switch (Triple.getEnvironment()) { case llvm::Triple::Android: case llvm::Triple::GNUEABI: case llvm::Triple::GNUEABIHF: @@ -827,8 +817,7 @@ void Clang::AddARMTargetArgs(const ArgList &Args, } if (!Args.hasFlag(options::OPT_mimplicit_float, - options::OPT_mno_implicit_float, - true)) + options::OPT_mno_implicit_float, true)) CmdArgs.push_back("-no-implicit-float"); // llvm does not support reserving registers in general. There is support @@ -932,10 +921,8 @@ void Clang::AddAArch64TargetArgs(const ArgList &Args, // Get CPU and ABI names. They are not independent // so we have to calculate them together. -void mips::getMipsCPUAndABI(const ArgList &Args, - const llvm::Triple &Triple, - StringRef &CPUName, - StringRef &ABIName) { +void mips::getMipsCPUAndABI(const ArgList &Args, const llvm::Triple &Triple, + StringRef &CPUName, StringRef &ABIName) { const char *DefMips32CPU = "mips32r2"; const char *DefMips64CPU = "mips64r2"; @@ -951,8 +938,7 @@ void mips::getMipsCPUAndABI(const ArgList &Args, if (Triple.getOS() == llvm::Triple::OpenBSD) DefMips64CPU = "mips3"; - if (Arg *A = Args.getLastArg(options::OPT_march_EQ, - options::OPT_mcpu_EQ)) + if (Arg *A = Args.getLastArg(options::OPT_march_EQ, options::OPT_mcpu_EQ)) CPUName = A->getValue(); if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) { @@ -960,9 +946,9 @@ void mips::getMipsCPUAndABI(const ArgList &Args, // Convert a GNU style Mips ABI name to the name // accepted by LLVM Mips backend. ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName) - .Case("32", "o32") - .Case("64", "n64") - .Default(ABIName); + .Case("32", "o32") + .Case("64", "n64") + .Default(ABIName); } // Setup default CPU and ABI names. @@ -993,9 +979,9 @@ void mips::getMipsCPUAndABI(const ArgList &Args, if (CPUName.empty()) { // Deduce CPU name from ABI name. CPUName = llvm::StringSwitch<const char *>(ABIName) - .Cases("o32", "eabi", DefMips32CPU) - .Cases("n32", "n64", DefMips64CPU) - .Default(""); + .Cases("o32", "eabi", DefMips32CPU) + .Cases("n32", "n64", DefMips64CPU) + .Default(""); } // FIXME: Warn on inconsistent use of -march and -mabi. @@ -1004,18 +990,18 @@ void mips::getMipsCPUAndABI(const ArgList &Args, // Convert ABI name to the GNU tools acceptable variant. static StringRef getGnuCompatibleMipsABIName(StringRef ABI) { return llvm::StringSwitch<llvm::StringRef>(ABI) - .Case("o32", "32") - .Case("n64", "64") - .Default(ABI); + .Case("o32", "32") + .Case("n64", "64") + .Default(ABI); } // Select the MIPS float ABI as determined by -msoft-float, -mhard-float, // and -mfloat-abi=. static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) { StringRef FloatABI; - if (Arg *A = Args.getLastArg(options::OPT_msoft_float, - options::OPT_mhard_float, - options::OPT_mfloat_abi_EQ)) { + if (Arg *A = + Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float, + options::OPT_mfloat_abi_EQ)) { if (A->getOption().matches(options::OPT_msoft_float)) FloatABI = "soft"; else if (A->getOption().matches(options::OPT_mhard_float)) @@ -1143,8 +1129,7 @@ void Clang::AddMIPSTargetArgs(const ArgList &Args, CmdArgs.push_back("-msoft-float"); CmdArgs.push_back("-mfloat-abi"); CmdArgs.push_back("soft"); - } - else { + } else { // Floating point operations and argument passing are hard. assert(FloatABI == "hard" && "Invalid float abi!"); CmdArgs.push_back("-mfloat-abi"); @@ -1196,51 +1181,51 @@ static std::string getPPCTargetCPU(const ArgList &Args) { } return llvm::StringSwitch<const char *>(CPUName) - .Case("common", "generic") - .Case("440", "440") - .Case("440fp", "440") - .Case("450", "450") - .Case("601", "601") - .Case("602", "602") - .Case("603", "603") - .Case("603e", "603e") - .Case("603ev", "603ev") - .Case("604", "604") - .Case("604e", "604e") - .Case("620", "620") - .Case("630", "pwr3") - .Case("G3", "g3") - .Case("7400", "7400") - .Case("G4", "g4") - .Case("7450", "7450") - .Case("G4+", "g4+") - .Case("750", "750") - .Case("970", "970") - .Case("G5", "g5") - .Case("a2", "a2") - .Case("a2q", "a2q") - .Case("e500mc", "e500mc") - .Case("e5500", "e5500") - .Case("power3", "pwr3") - .Case("power4", "pwr4") - .Case("power5", "pwr5") - .Case("power5x", "pwr5x") - .Case("power6", "pwr6") - .Case("power6x", "pwr6x") - .Case("power7", "pwr7") - .Case("power8", "pwr8") - .Case("pwr3", "pwr3") - .Case("pwr4", "pwr4") - .Case("pwr5", "pwr5") - .Case("pwr5x", "pwr5x") - .Case("pwr6", "pwr6") - .Case("pwr6x", "pwr6x") - .Case("pwr7", "pwr7") - .Case("pwr8", "pwr8") - .Case("powerpc", "ppc") - .Case("powerpc64", "ppc64") - .Case("powerpc64le", "ppc64le") - .Default(""); + .Case("common", "generic") + .Case("440", "440") + .Case("440fp", "440") + .Case("450", "450") + .Case("601", "601") + .Case("602", "602") + .Case("603", "603") + .Case("603e", "603e") + .Case("603ev", "603ev") + .Case("604", "604") + .Case("604e", "604e") + .Case("620", "620") + .Case("630", "pwr3") + .Case("G3", "g3") + .Case("7400", "7400") + .Case("G4", "g4") + .Case("7450", "7450") + .Case("G4+", "g4+") + .Case("750", "750") + .Case("970", "970") + .Case("G5", "g5") + .Case("a2", "a2") + .Case("a2q", "a2q") + .Case("e500mc", "e500mc") + .Case("e5500", "e5500") + .Case("power3", "pwr3") + .Case("power4", "pwr4") + .Case("power5", "pwr5") + .Case("power5x", "pwr5x") + .Case("power6", "pwr6") + .Case("power6x", "pwr6x") + .Case("power7", "pwr7") + .Case("power8", "pwr8") + .Case("pwr3", "pwr3") + .Case("pwr4", "pwr4") + .Case("pwr5", "pwr5") + .Case("pwr5x", "pwr5x") + .Case("pwr6", "pwr6") + .Case("pwr6x", "pwr6x") + .Case("pwr7", "pwr7") + .Case("pwr8", "pwr8") + .Case("powerpc", "ppc") + .Case("powerpc64", "ppc64") + .Case("powerpc64le", "ppc64le") + .Default(""); } return ""; @@ -1282,7 +1267,7 @@ void Clang::AddPPCTargetArgs(const ArgList &Args, if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) { ABIName = A->getValue(); } else if (getToolChain().getTriple().isOSLinux()) - switch(getToolChain().getArch()) { + switch (getToolChain().getArch()) { case llvm::Triple::ppc64: { // When targeting a processor that supports QPX, or if QPX is // specifically enabled, default to using the ABI that supports QPX (so @@ -1304,7 +1289,7 @@ void Clang::AddPPCTargetArgs(const ArgList &Args, break; default: break; - } + } if (ABIName) { CmdArgs.push_back("-target-abi"); @@ -1322,20 +1307,20 @@ static std::string getR600TargetGPU(const ArgList &Args) { if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { const char *GPUName = A->getValue(); return llvm::StringSwitch<const char *>(GPUName) - .Cases("rv630", "rv635", "r600") - .Cases("rv610", "rv620", "rs780", "rs880") - .Case("rv740", "rv770") - .Case("palm", "cedar") - .Cases("sumo", "sumo2", "sumo") - .Case("hemlock", "cypress") - .Case("aruba", "cayman") - .Default(GPUName); + .Cases("rv630", "rv635", "r600") + .Cases("rv610", "rv620", "rs780", "rs880") + .Case("rv740", "rv770") + .Case("palm", "cedar") + .Cases("sumo", "sumo2", "sumo") + .Case("hemlock", "cypress") + .Case("aruba", "cayman") + .Default(GPUName); } return ""; } void Clang::AddSparcTargetArgs(const ArgList &Args, - ArgStringList &CmdArgs) const { + ArgStringList &CmdArgs) const { const Driver &D = getToolChain().getDriver(); std::string Triple = getToolChain().ComputeEffectiveClangTriple(Args); @@ -1352,8 +1337,8 @@ void Clang::AddSparcTargetArgs(const ArgList &Args, // 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; + D.Diag(diag::err_drv_unsupported_opt_for_target) << "-msoft-float" + << Triple; } } @@ -1366,16 +1351,14 @@ static const char *getSystemZTargetCPU(const ArgList &Args) { static void getSystemZTargetFeatures(const ArgList &Args, std::vector<const char *> &Features) { // -m(no-)htm overrides use of the transactional-execution facility. - if (Arg *A = Args.getLastArg(options::OPT_mhtm, - options::OPT_mno_htm)) { + if (Arg *A = Args.getLastArg(options::OPT_mhtm, options::OPT_mno_htm)) { if (A->getOption().matches(options::OPT_mhtm)) Features.push_back("+transactional-execution"); else Features.push_back("-transactional-execution"); } // -m(no-)vx overrides use of the vector facility. - if (Arg *A = Args.getLastArg(options::OPT_mvx, - options::OPT_mno_vx)) { + if (Arg *A = Args.getLastArg(options::OPT_mvx, options::OPT_mno_vx)) { if (A->getOption().matches(options::OPT_mvx)) Features.push_back("+vector"); else @@ -1403,6 +1386,28 @@ static const char *getX86TargetCPU(const ArgList &Args, return Args.MakeArgString(CPU); } + if (const Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) { + // Mapping built by referring to X86TargetInfo::getDefaultFeatures(). + StringRef Arch = A->getValue(); + const char *CPU; + if (Triple.getArch() == llvm::Triple::x86) { + CPU = llvm::StringSwitch<const char *>(Arch) + .Case("IA32", "i386") + .Case("SSE", "pentium3") + .Case("SSE2", "pentium4") + .Case("AVX", "sandybridge") + .Case("AVX2", "haswell") + .Default(nullptr); + } else { + CPU = llvm::StringSwitch<const char *>(Arch) + .Case("AVX", "sandybridge") + .Case("AVX2", "haswell") + .Default(nullptr); + } + if (CPU) + return CPU; + } + // Select the default CPU if none was given (or detection failed). if (Triple.getArch() != llvm::Triple::x86_64 && @@ -1446,7 +1451,7 @@ static const char *getX86TargetCPU(const ArgList &Args, } static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) { - switch(T.getArch()) { + switch (T.getArch()) { default: return ""; @@ -1517,7 +1522,8 @@ static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args, // as gold requires -plugin to come before any -plugin-opt that -Wl might // forward. CmdArgs.push_back("-plugin"); - std::string Plugin = ToolChain.getDriver().Dir + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold.so"; + std::string Plugin = + ToolChain.getDriver().Dir + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold.so"; CmdArgs.push_back(Args.MakeArgString(Plugin)); // Try to pass driver level flags relevant to LTO code generation down to @@ -1534,7 +1540,7 @@ static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args, /// 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 Arg &A, size_t &Position) { const char RefinementStepToken = ':'; Position = In.find(RefinementStepToken); if (Position != StringRef::npos) { @@ -1597,14 +1603,14 @@ static void ParseMRecip(const Driver &D, const ArgList &Args, // 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)); + 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); @@ -1636,7 +1642,7 @@ static void ParseMRecip(const Driver &D, const ArgList &Args, return; } } - + if (OptionIter->second == true) { // Duplicate option specified. D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val; @@ -1669,8 +1675,8 @@ static void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple, llvm::StringMap<bool> HostFeatures; if (llvm::sys::getHostCPUFeatures(HostFeatures)) for (auto &F : HostFeatures) - Features.push_back(Args.MakeArgString((F.second ? "+" : "-") + - F.first())); + Features.push_back( + Args.MakeArgString((F.second ? "+" : "-") + F.first())); } } @@ -1739,9 +1745,7 @@ static void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple, void Clang::AddX86TargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const { - if (!Args.hasFlag(options::OPT_mred_zone, - options::OPT_mno_red_zone, - true) || + if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) || Args.hasArg(options::OPT_mkernel) || Args.hasArg(options::OPT_fapple_kext)) CmdArgs.push_back("-disable-red-zone"); @@ -1750,10 +1754,9 @@ void Clang::AddX86TargetArgs(const ArgList &Args, // that to be overridden with -mno-soft-float. bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) || Args.hasArg(options::OPT_fapple_kext)); - if (Arg *A = Args.getLastArg(options::OPT_msoft_float, - options::OPT_mno_soft_float, - options::OPT_mimplicit_float, - options::OPT_mno_implicit_float)) { + if (Arg *A = Args.getLastArg( + options::OPT_msoft_float, options::OPT_mno_soft_float, + options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) { const Option &O = A->getOption(); NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) || O.matches(options::OPT_msoft_float)); @@ -1778,21 +1781,21 @@ void Clang::AddHexagonTargetArgs(const ArgList &Args, CmdArgs.push_back("-mqdsp6-compat"); CmdArgs.push_back("-Wreturn-type"); - if (const char* v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) { - std::string SmallDataThreshold="-hexagon-small-data-threshold="; + if (const char *v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) { + std::string SmallDataThreshold = "-hexagon-small-data-threshold="; SmallDataThreshold += v; - CmdArgs.push_back ("-mllvm"); + CmdArgs.push_back("-mllvm"); CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold)); } if (!Args.hasArg(options::OPT_fno_short_enums)) CmdArgs.push_back("-fshort-enums"); if (Args.getLastArg(options::OPT_mieee_rnd_near)) { - CmdArgs.push_back ("-mllvm"); - CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near"); + CmdArgs.push_back("-mllvm"); + CmdArgs.push_back("-enable-hexagon-ieee-rnd-near"); } - CmdArgs.push_back ("-mllvm"); - CmdArgs.push_back ("-machine-sink-split=0"); + CmdArgs.push_back("-mllvm"); + CmdArgs.push_back("-machine-sink-split=0"); } // Decode AArch64 features from string like +[no]featureA+[no]featureB+... @@ -1801,8 +1804,8 @@ static bool DecodeAArch64Features(const Driver &D, StringRef text, SmallVector<StringRef, 8> Split; text.split(Split, StringRef("+"), -1, false); - for (unsigned I = 0, E = Split.size(); I != E; ++I) { - const char *result = llvm::StringSwitch<const char *>(Split[I]) + for (const StringRef Feature : Split) { + const char *result = llvm::StringSwitch<const char *>(Feature) .Case("fp", "+fp-armv8") .Case("simd", "+neon") .Case("crc", "+crc") @@ -1814,7 +1817,7 @@ static bool DecodeAArch64Features(const Driver &D, StringRef text, .Default(nullptr); if (result) Features.push_back(result); - else if (Split[I] == "neon" || Split[I] == "noneon") + else if (Feature == "neon" || Feature == "noneon") D.Diag(diag::err_drv_no_neon_modifier); else return false; @@ -1828,7 +1831,8 @@ static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU, std::vector<const char *> &Features) { std::pair<StringRef, StringRef> Split = Mcpu.split("+"); CPU = Split.first; - if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57" || CPU == "cortex-a72") { + if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57" || + CPU == "cortex-a72") { Features.push_back("+neon"); Features.push_back("+crc"); Features.push_back("+crypto"); @@ -1851,12 +1855,9 @@ getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March, std::string MarchLowerCase = March.lower(); std::pair<StringRef, StringRef> Split = StringRef(MarchLowerCase).split("+"); - if (Split.first == "armv8-a" || - Split.first == "armv8a") { + if (Split.first == "armv8-a" || Split.first == "armv8a") { // ok, no additional features. - } else if ( - Split.first == "armv8.1-a" || - Split.first == "armv8.1a" ) { + } else if (Split.first == "armv8.1-a" || Split.first == "armv8.1a") { Features.push_back("+v8.1a"); } else { return false; @@ -1941,8 +1942,7 @@ static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args, } // En/disable crc - if (Arg *A = Args.getLastArg(options::OPT_mcrc, - options::OPT_mnocrc)) { + if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) { if (A->getOption().matches(options::OPT_mcrc)) Features.push_back("+crc"); else @@ -2023,7 +2023,7 @@ shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime, if (!Triple.isMacOSX()) return false; - return (!Triple.isMacOSXVersionLT(10,5) && + return (!Triple.isMacOSXVersionLT(10, 5) && (Triple.getArch() == llvm::Triple::x86_64 || Triple.getArch() == llvm::Triple::arm)); } @@ -2069,8 +2069,7 @@ static void addExceptionArgs(const ArgList &Args, types::ID InputType, // is not necessarily sensible, but follows GCC. if (types::isObjC(InputType) && Args.hasFlag(options::OPT_fobjc_exceptions, - options::OPT_fno_objc_exceptions, - true)) { + options::OPT_fno_objc_exceptions, true)) { CmdArgs.push_back("-fobjc-exceptions"); EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple); @@ -2113,8 +2112,7 @@ static void addExceptionArgs(const ArgList &Args, types::ID InputType, CmdArgs.push_back("-fexceptions"); } -static bool ShouldDisableAutolink(const ArgList &Args, - const ToolChain &TC) { +static bool ShouldDisableAutolink(const ArgList &Args, const ToolChain &TC) { bool Default = true; if (TC.getTriple().isOSDarwin()) { // The native darwin assembler doesn't support the linker_option directives, @@ -2127,9 +2125,9 @@ static bool ShouldDisableAutolink(const ArgList &Args, static bool ShouldDisableDwarfDirectory(const ArgList &Args, const ToolChain &TC) { - bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm, - options::OPT_fno_dwarf_directory_asm, - TC.useIntegratedAs()); + bool UseDwarfDirectory = + Args.hasFlag(options::OPT_fdwarf_directory_asm, + options::OPT_fno_dwarf_directory_asm, TC.useIntegratedAs()); return !UseDwarfDirectory; } @@ -2164,79 +2162,78 @@ static bool UseRelaxAll(Compilation &C, const ArgList &Args) { } return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all, - RelaxDefault); + RelaxDefault); } static void CollectArgsForIntegratedAssembler(Compilation &C, const ArgList &Args, ArgStringList &CmdArgs, const Driver &D) { - if (UseRelaxAll(C, Args)) - CmdArgs.push_back("-mrelax-all"); - - // When passing -I arguments to the assembler we sometimes need to - // unconditionally take the next argument. For example, when parsing - // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the - // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo' - // arg after parsing the '-I' arg. - bool TakeNextArg = false; - - // When using an integrated assembler, translate -Wa, and -Xassembler - // options. - bool CompressDebugSections = false; - for (const Arg *A : - Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) { - A->claim(); + if (UseRelaxAll(C, Args)) + CmdArgs.push_back("-mrelax-all"); + + // When passing -I arguments to the assembler we sometimes need to + // unconditionally take the next argument. For example, when parsing + // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the + // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo' + // arg after parsing the '-I' arg. + bool TakeNextArg = false; + + // When using an integrated assembler, translate -Wa, and -Xassembler + // options. + bool CompressDebugSections = false; + for (const Arg *A : + Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) { + A->claim(); - for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) { - StringRef Value = A->getValue(i); + for (const StringRef Value : A->getValues()) { if (TakeNextArg) { CmdArgs.push_back(Value.data()); TakeNextArg = false; continue; } - if (Value == "-force_cpusubtype_ALL") { - // Do nothing, this is the default and we don't support anything else. - } else if (Value == "-L") { - CmdArgs.push_back("-msave-temp-labels"); - } else if (Value == "--fatal-warnings") { - CmdArgs.push_back("-massembler-fatal-warnings"); - } else if (Value == "--noexecstack") { - CmdArgs.push_back("-mnoexecstack"); - } else if (Value == "-compress-debug-sections" || - Value == "--compress-debug-sections") { - CompressDebugSections = true; - } else if (Value == "-nocompress-debug-sections" || - Value == "--nocompress-debug-sections") { - CompressDebugSections = false; - } else if (Value.startswith("-I")) { - CmdArgs.push_back(Value.data()); - // We need to consume the next argument if the current arg is a plain - // -I. The next arg will be the include directory. - if (Value == "-I") - TakeNextArg = true; - } else if (Value.startswith("-gdwarf-")) { - CmdArgs.push_back(Value.data()); - } else { - D.Diag(diag::err_drv_unsupported_option_argument) + if (Value == "-force_cpusubtype_ALL") { + // Do nothing, this is the default and we don't support anything else. + } else if (Value == "-L") { + CmdArgs.push_back("-msave-temp-labels"); + } else if (Value == "--fatal-warnings") { + CmdArgs.push_back("-massembler-fatal-warnings"); + } else if (Value == "--noexecstack") { + CmdArgs.push_back("-mnoexecstack"); + } else if (Value == "-compress-debug-sections" || + Value == "--compress-debug-sections") { + CompressDebugSections = true; + } else if (Value == "-nocompress-debug-sections" || + Value == "--nocompress-debug-sections") { + CompressDebugSections = false; + } else if (Value.startswith("-I")) { + CmdArgs.push_back(Value.data()); + // We need to consume the next argument if the current arg is a plain + // -I. The next arg will be the include directory. + if (Value == "-I") + TakeNextArg = true; + } else if (Value.startswith("-gdwarf-")) { + CmdArgs.push_back(Value.data()); + } else { + D.Diag(diag::err_drv_unsupported_option_argument) << A->getOption().getName() << Value; - } } } - if (CompressDebugSections) { - if (llvm::zlib::isAvailable()) - CmdArgs.push_back("-compress-debug-sections"); - else - D.Diag(diag::warn_debug_compression_unavailable); - } + } + if (CompressDebugSections) { + if (llvm::zlib::isAvailable()) + CmdArgs.push_back("-compress-debug-sections"); + else + D.Diag(diag::warn_debug_compression_unavailable); + } } // Until ARM libraries are build separately, we have them all in one library static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) { - // FIXME: handle 64-bit if (TC.getTriple().isOSWindows() && - !TC.getTriple().isWindowsItaniumEnvironment()) + !TC.getTriple().isWindowsItaniumEnvironment() && + TC.getArch() == llvm::Triple::x86) return "i386"; if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb) return "arm"; @@ -2254,8 +2251,8 @@ static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) { return Res; } -static SmallString<128> getCompilerRT(const ToolChain &TC, StringRef Component, - bool Shared = false) { +SmallString<128> tools::getCompilerRT(const ToolChain &TC, StringRef Component, + bool Shared) { const char *Env = TC.getTriple().getEnvironment() == llvm::Triple::Android ? "-android" : ""; @@ -2334,15 +2331,15 @@ static OpenMPRuntimeKind getOpenMPRuntime(const ToolChain &TC, RuntimeName = A->getValue(); auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName) - .Case("libomp", OMPRT_OMP) - .Case("libgomp", OMPRT_GOMP) - .Case("libiomp5", OMPRT_IOMP5) - .Default(OMPRT_Unknown); + .Case("libomp", OMPRT_OMP) + .Case("libgomp", OMPRT_GOMP) + .Case("libiomp5", OMPRT_IOMP5) + .Default(OMPRT_Unknown); if (RT == OMPRT_Unknown) { if (A) TC.getDriver().Diag(diag::err_drv_unsupported_option_argument) - << A->getOption().getName() << A->getValue(); + << A->getOption().getName() << A->getValue(); else // FIXME: We could use a nicer diagnostic here. TC.getDriver().Diag(diag::err_drv_unsupported_opt) << "-fopenmp"; @@ -2537,8 +2534,7 @@ static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) { } } -static const char *SplitDebugName(const ArgList &Args, - const InputInfo &Input) { +static const char *SplitDebugName(const ArgList &Args, const InputInfo &Input) { Arg *FinalOutput = Args.getLastArg(options::OPT_o); if (FinalOutput && Args.hasArg(options::OPT_c)) { SmallString<128> T(FinalOutput->getValue()); @@ -2555,10 +2551,9 @@ static const char *SplitDebugName(const ArgList &Args, } } -static void SplitDebugInfo(const ToolChain &TC, Compilation &C, - const Tool &T, const JobAction &JA, - const ArgList &Args, const InputInfo &Output, - const char *OutFile) { +static void SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T, + const JobAction &JA, const ArgList &Args, + const InputInfo &Output, const char *OutFile) { ArgStringList ExtractArgs; ExtractArgs.push_back("--extract-dwo"); @@ -2570,8 +2565,7 @@ static void SplitDebugInfo(const ToolChain &TC, Compilation &C, ExtractArgs.push_back(Output.getFilename()); ExtractArgs.push_back(OutFile); - const char *Exec = - Args.MakeArgString(TC.GetProgramPath("objcopy")); + const char *Exec = Args.MakeArgString(TC.GetProgramPath("objcopy")); // First extract the dwo sections. C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs)); @@ -2635,7 +2629,7 @@ static VersionTuple getMSCompatibilityVersion(unsigned Version) { return VersionTuple(Version / 100, Version % 100); unsigned Build = 0, Factor = 1; - for ( ; Version > 10000; Version = Version / 10, Factor = Factor * 10) + for (; Version > 10000; Version = Version / 10, Factor = Factor * 10) Build = Build + (Version % 10) * Factor; return VersionTuple(Version / 100, Version % 100, Build); } @@ -2672,7 +2666,7 @@ static void appendUserToPath(SmallVectorImpl<char> &Result) { } } - // Fallback to user id. +// Fallback to user id. #ifdef LLVM_ON_UNIX std::string UID = llvm::utostr(getuid()); #else @@ -2692,7 +2686,7 @@ VersionTuple visualstudio::getMSVCVersion(const Driver *D, Args.hasArg(options::OPT_fms_compatibility_version)) { const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version); const Arg *MSCompatibilityVersion = - Args.getLastArg(options::OPT_fms_compatibility_version); + Args.getLastArg(options::OPT_fms_compatibility_version); if (MSCVersion && MSCompatibilityVersion) { if (D) @@ -2730,12 +2724,10 @@ VersionTuple visualstudio::getMSVCVersion(const Driver *D, } void Clang::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { - bool KernelOrKext = Args.hasArg(options::OPT_mkernel, - options::OPT_fapple_kext); + const InputInfo &Output, const InputInfoList &Inputs, + const ArgList &Args, const char *LinkingOutput) const { + bool KernelOrKext = + Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext); const Driver &D = getToolChain().getDriver(); ArgStringList CmdArgs; @@ -2775,7 +2767,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // Select the appropriate action. RewriteKind rewriteKind = RK_None; - + if (isa<AnalyzeJobAction>(JA)) { assert(JA.getType() == types::TY_Plist && "Invalid output type."); CmdArgs.push_back("-analyze"); @@ -2796,7 +2788,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D); // Also ignore explicit -force_cpusubtype_ALL option. - (void) Args.hasArg(options::OPT_force__cpusubtype__ALL); + (void)Args.hasArg(options::OPT_force__cpusubtype__ALL); } else if (isa<PrecompileJobAction>(JA)) { // Use PCH if the user requested it. bool UsePCH = D.CCCUsePCH; @@ -2834,8 +2826,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-rewrite-objc"); rewriteKind = RK_Fragile; } else { - assert(JA.getType() == types::TY_PP_Asm && - "Unexpected output type!"); + assert(JA.getType() == types::TY_PP_Asm && "Unexpected output type!"); } // Preserve use-list order by default when emitting bitcode, so that @@ -2852,7 +2843,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (!C.isForDiagnostics()) CmdArgs.push_back("-disable-free"); - // Disable the verification pass in -asserts builds. +// Disable the verification pass in -asserts builds. #ifdef NDEBUG CmdArgs.push_back("-disable-llvm-verifier"); #endif @@ -2885,9 +2876,9 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple) CmdArgs.push_back("-analyzer-checker=osx"); - + CmdArgs.push_back("-analyzer-checker=deadcode"); - + if (types::isCXX(Input.getType())) CmdArgs.push_back("-analyzer-checker=cplusplus"); @@ -2896,7 +2887,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, "-analyzer-checker=security.insecureAPI.UncheckedReturn"); CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw"); CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets"); - CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp"); + CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp"); CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp"); CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork"); } @@ -2980,10 +2971,10 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // used. If the last argument is any flavor of the '-fno-...' arguments, // both PIC and PIE are disabled. Any PIE option implicitly enables PIC // at the same level. - Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, - options::OPT_fpic, options::OPT_fno_pic, - options::OPT_fPIE, options::OPT_fno_PIE, - options::OPT_fpie, options::OPT_fno_pie); + Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, + options::OPT_fpic, options::OPT_fno_pic, + options::OPT_fPIE, options::OPT_fno_PIE, + options::OPT_fpie, options::OPT_fno_pie); // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness // is forced, then neither PIC nor PIE flags will have no effect. if (!getToolChain().isPICDefaultForced()) { @@ -2992,10 +2983,10 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) || O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) { PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie); - PIC = PIE || O.matches(options::OPT_fPIC) || - O.matches(options::OPT_fpic); - IsPICLevelTwo = O.matches(options::OPT_fPIE) || - O.matches(options::OPT_fPIC); + PIC = + PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic); + IsPICLevelTwo = + O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC); } else { PIE = PIC = false; } @@ -3022,7 +3013,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // uses it, and it isn't even valid on any OS but Darwin. if (!getToolChain().getTriple().isOSDarwin()) D.Diag(diag::err_drv_unsupported_opt_for_target) - << A->getSpelling() << getToolChain().getTriple().str(); + << A->getSpelling() << getToolChain().getTriple().str(); // FIXME: Warn when this flag trumps some other PIC or PIE flag. @@ -3092,7 +3083,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, options::OPT_freg_struct_return)) { if (getToolChain().getArch() != llvm::Triple::x86) { D.Diag(diag::err_drv_unsupported_opt_for_target) - << A->getSpelling() << getToolChain().getTriple().str(); + << A->getSpelling() << getToolChain().getTriple().str(); } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) { CmdArgs.push_back("-fpcc-struct-return"); } else { @@ -3113,8 +3104,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, bool OFastEnabled = isOptimizationLevelFast(Args); // If -Ofast is the optimization level, then -fstrict-aliasing should be // enabled. This alias option is being used to simplify the hasFlag logic. - OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast : - options::OPT_fstrict_aliasing; + OptSpecifier StrictAliasingAliasOption = + OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing; // We turn strict aliasing off by default if we're in CL mode, since MSVC // doesn't do any TBAA. bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode(); @@ -3137,30 +3128,28 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // If -Ofast is the optimization level, then -ffast-math should be enabled. // This alias option is being used to simplify the getLastArg logic. - OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast : - options::OPT_ffast_math; - + OptSpecifier FastMathAliasOption = + OFastEnabled ? options::OPT_Ofast : options::OPT_ffast_math; + // Handle various floating point optimization flags, mapping them to the // appropriate LLVM code generation flags. The pattern for all of these is to // default off the codegen optimizations, and if any flag enables them and no // flag disables them after the flag enabling them, enable the codegen // optimization. This is complicated by several "umbrella" flags. - if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, - options::OPT_fno_fast_math, - options::OPT_ffinite_math_only, - options::OPT_fno_finite_math_only, - options::OPT_fhonor_infinities, - options::OPT_fno_honor_infinities)) + if (Arg *A = Args.getLastArg( + options::OPT_ffast_math, FastMathAliasOption, + options::OPT_fno_fast_math, options::OPT_ffinite_math_only, + options::OPT_fno_finite_math_only, options::OPT_fhonor_infinities, + options::OPT_fno_honor_infinities)) if (A->getOption().getID() != options::OPT_fno_fast_math && A->getOption().getID() != options::OPT_fno_finite_math_only && A->getOption().getID() != options::OPT_fhonor_infinities) CmdArgs.push_back("-menable-no-infs"); - if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, - options::OPT_fno_fast_math, - options::OPT_ffinite_math_only, - options::OPT_fno_finite_math_only, - options::OPT_fhonor_nans, - options::OPT_fno_honor_nans)) + if (Arg *A = Args.getLastArg( + options::OPT_ffast_math, FastMathAliasOption, + options::OPT_fno_fast_math, options::OPT_ffinite_math_only, + options::OPT_fno_finite_math_only, options::OPT_fhonor_nans, + options::OPT_fno_honor_nans)) if (A->getOption().getID() != options::OPT_fno_fast_math && A->getOption().getID() != options::OPT_fno_finite_math_only && A->getOption().getID() != options::OPT_fhonor_nans) @@ -3168,10 +3157,10 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes. bool MathErrno = getToolChain().IsMathErrnoDefault(); - if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, - options::OPT_fno_fast_math, - options::OPT_fmath_errno, - options::OPT_fno_math_errno)) { + if (Arg *A = + Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, + options::OPT_fno_fast_math, options::OPT_fmath_errno, + options::OPT_fno_math_errno)) { // Turning on -ffast_math (with either flag) removes the need for MathErrno. // However, turning *off* -ffast_math merely restores the toolchain default // (which may be false). @@ -3190,45 +3179,41 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // entire set of LLVM optimizations, so collect them through all the flag // madness. bool AssociativeMath = false; - if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, - options::OPT_fno_fast_math, - options::OPT_funsafe_math_optimizations, - options::OPT_fno_unsafe_math_optimizations, - options::OPT_fassociative_math, - options::OPT_fno_associative_math)) + if (Arg *A = Args.getLastArg( + options::OPT_ffast_math, FastMathAliasOption, + options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations, + options::OPT_fno_unsafe_math_optimizations, + options::OPT_fassociative_math, options::OPT_fno_associative_math)) if (A->getOption().getID() != options::OPT_fno_fast_math && A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations && A->getOption().getID() != options::OPT_fno_associative_math) AssociativeMath = true; bool ReciprocalMath = false; - if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, - options::OPT_fno_fast_math, - options::OPT_funsafe_math_optimizations, - options::OPT_fno_unsafe_math_optimizations, - options::OPT_freciprocal_math, - options::OPT_fno_reciprocal_math)) + if (Arg *A = Args.getLastArg( + options::OPT_ffast_math, FastMathAliasOption, + options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations, + options::OPT_fno_unsafe_math_optimizations, + options::OPT_freciprocal_math, options::OPT_fno_reciprocal_math)) if (A->getOption().getID() != options::OPT_fno_fast_math && A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations && A->getOption().getID() != options::OPT_fno_reciprocal_math) ReciprocalMath = true; bool SignedZeros = true; - if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, - options::OPT_fno_fast_math, - options::OPT_funsafe_math_optimizations, - options::OPT_fno_unsafe_math_optimizations, - options::OPT_fsigned_zeros, - options::OPT_fno_signed_zeros)) + if (Arg *A = Args.getLastArg( + options::OPT_ffast_math, FastMathAliasOption, + options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations, + options::OPT_fno_unsafe_math_optimizations, + options::OPT_fsigned_zeros, options::OPT_fno_signed_zeros)) if (A->getOption().getID() != options::OPT_fno_fast_math && A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations && A->getOption().getID() != options::OPT_fsigned_zeros) SignedZeros = false; bool TrappingMath = true; - if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, - options::OPT_fno_fast_math, - options::OPT_funsafe_math_optimizations, - options::OPT_fno_unsafe_math_optimizations, - options::OPT_ftrapping_math, - options::OPT_fno_trapping_math)) + if (Arg *A = Args.getLastArg( + options::OPT_ffast_math, FastMathAliasOption, + options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations, + options::OPT_fno_unsafe_math_optimizations, + options::OPT_ftrapping_math, options::OPT_fno_trapping_math)) if (A->getOption().getID() != options::OPT_fno_fast_math && A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations && A->getOption().getID() != options::OPT_ftrapping_math) @@ -3243,7 +3228,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (ReciprocalMath) CmdArgs.push_back("-freciprocal-math"); - // Validate and pass through -fp-contract option. + // Validate and pass through -fp-contract option. if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, options::OPT_fno_fast_math, options::OPT_ffp_contract)) { @@ -3253,7 +3238,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val)); } else { D.Diag(diag::err_drv_unsupported_option_argument) - << A->getOption().getName() << Val; + << A->getOption().getName() << Val; } } else if (A->getOption().matches(options::OPT_ffast_math) || (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) { @@ -3261,7 +3246,7 @@ 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, @@ -3271,8 +3256,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // and deserialization, etc. if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, options::OPT_fno_fast_math)) - if (!A->getOption().matches(options::OPT_fno_fast_math)) - CmdArgs.push_back("-ffast-math"); + if (!A->getOption().matches(options::OPT_fno_fast_math)) + CmdArgs.push_back("-ffast-math"); if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math)) if (A->getOption().matches(options::OPT_ffinite_math_only)) @@ -3335,7 +3320,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, } // FIXME: Handle -mtune=. - (void) Args.hasArg(options::OPT_mtune_EQ); + (void)Args.hasArg(options::OPT_mtune_EQ); if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) { CmdArgs.push_back("-mcode-model"); @@ -3358,7 +3343,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, getTargetFeatures(D, Triple, Args, CmdArgs, false); // Add target specific flags. - switch(getToolChain().getArch()) { + switch (getToolChain().getArch()) { default: break; @@ -3421,13 +3406,12 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, types::ID InputType = Input.getType(); if (!Args.hasArg(options::OPT_fallow_unsupported)) { Arg *Unsupported; - if (types::isCXX(InputType) && - getToolChain().getTriple().isOSDarwin() && + if (types::isCXX(InputType) && getToolChain().getTriple().isOSDarwin() && getToolChain().getArch() == llvm::Triple::x86) { if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) || (Unsupported = Args.getLastArg(options::OPT_mkernel))) D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386) - << Unsupported->getOption().getName(); + << Unsupported->getOption().getName(); } } @@ -3435,16 +3419,16 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, Args.AddLastArg(CmdArgs, options::OPT_H); if (D.CCPrintHeaders && !D.CCGenDiagnostics) { CmdArgs.push_back("-header-include-file"); - CmdArgs.push_back(D.CCPrintHeadersFilename ? - D.CCPrintHeadersFilename : "-"); + CmdArgs.push_back(D.CCPrintHeadersFilename ? D.CCPrintHeadersFilename + : "-"); } Args.AddLastArg(CmdArgs, options::OPT_P); Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout); if (D.CCLogDiagnostics && !D.CCGenDiagnostics) { CmdArgs.push_back("-diagnostic-log-file"); - CmdArgs.push_back(D.CCLogDiagnosticsFilename ? - D.CCLogDiagnosticsFilename : "-"); + CmdArgs.push_back(D.CCLogDiagnosticsFilename ? D.CCLogDiagnosticsFilename + : "-"); } // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x" @@ -3525,8 +3509,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-ffunction-sections"); } - if (Args.hasFlag(options::OPT_fdata_sections, - options::OPT_fno_data_sections, UseSeparateSections)) { + if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections, + UseSeparateSections)) { CmdArgs.push_back("-fdata-sections"); } @@ -3541,7 +3525,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, (Args.hasArg(options::OPT_fprofile_instr_use) || Args.hasArg(options::OPT_fprofile_instr_use_EQ))) D.Diag(diag::err_drv_argument_not_allowed_with) - << "-fprofile-instr-generate" << "-fprofile-instr-use"; + << "-fprofile-instr-generate" + << "-fprofile-instr-use"; if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_generate_EQ)) A->render(Args, CmdArgs); @@ -3565,7 +3550,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, !(Args.hasArg(options::OPT_fprofile_instr_generate) || Args.hasArg(options::OPT_fprofile_instr_generate_EQ))) D.Diag(diag::err_drv_argument_only_allowed_with) - << "-fcoverage-mapping" << "-fprofile-instr-generate"; + << "-fcoverage-mapping" + << "-fprofile-instr-generate"; if (Args.hasArg(options::OPT_fcoverage_mapping)) CmdArgs.push_back("-fcoverage-mapping"); @@ -3597,7 +3583,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-nobuiltininc"); } else { if (Args.hasArg(options::OPT_nostdlibinc)) - CmdArgs.push_back("-nostdsysteminc"); + CmdArgs.push_back("-nostdsysteminc"); Args.AddLastArg(CmdArgs, options::OPT_nostdincxx); Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc); } @@ -3641,8 +3627,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) { if (ARCMTEnabled) { - D.Diag(diag::err_drv_argument_not_allowed_with) - << A->getAsString(Args) << "-ccc-arcmt-migrate"; + D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args) + << "-ccc-arcmt-migrate"; } CmdArgs.push_back("-mt-migrate-directory"); CmdArgs.push_back(A->getValue()); @@ -3745,8 +3731,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // eventually we want to do all the standard defaulting here instead of // splitting it between the driver and clang -cc1. if (!types::isCXX(InputType)) - Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, - "-std=", /*Joined=*/true); + Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, "-std=", + /*Joined=*/true); else if (IsWindowsMSVC) ImplyVCPPCXXVer = true; @@ -3835,7 +3821,6 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value } - if (Args.hasArg(options::OPT_relocatable_pch)) CmdArgs.push_back("-relocatable-pch"); @@ -3917,8 +3902,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug); Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names); // AltiVec language extensions aren't relevant for assembling. - if (!isa<PreprocessJobAction>(JA) || - Output.getType() != types::TY_PP_Asm) + if (!isa<PreprocessJobAction>(JA) || Output.getType() != types::TY_PP_Asm) Args.AddLastArg(CmdArgs, options::OPT_faltivec); Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree); Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type); @@ -3943,7 +3927,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, } const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs(); - Sanitize.addArgs(Args, CmdArgs); + Sanitize.addArgs(getToolChain(), Args, CmdArgs, InputType); // Report an error for -faltivec on anything other than PowerPC. if (const Arg *A = Args.getLastArg(options::OPT_faltivec)) { @@ -3980,8 +3964,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // -fno-strict-overflow implies -fwrapv if it isn't disabled, but // -fstrict-overflow won't turn off an explicitly enabled -fwrapv. - if (Arg *A = Args.getLastArg(options::OPT_fwrapv, - options::OPT_fno_wrapv)) { + if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) { if (A->getOption().matches(options::OPT_fwrapv)) CmdArgs.push_back("-fwrapv"); } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow, @@ -4001,7 +3984,6 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, Args.AddLastArg(CmdArgs, options::OPT_pthread); - // -stack-protector=0 is default. unsigned StackProtectorLevel = 0; if (getToolChain().getSanitizerArgs().needsSafeStackRt()) { @@ -4010,19 +3992,20 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, 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)) { + options::OPT_fstack_protector_all, + options::OPT_fstack_protector_strong, + options::OPT_fstack_protector)) { if (A->getOption().matches(options::OPT_fstack_protector)) { - StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn, - getToolChain().GetDefaultStackProtectorLevel(KernelOrKext)); + StackProtectorLevel = std::max<unsigned>( + LangOptions::SSPOn, + getToolChain().GetDefaultStackProtectorLevel(KernelOrKext)); } else if (A->getOption().matches(options::OPT_fstack_protector_strong)) StackProtectorLevel = LangOptions::SSPStrong; else if (A->getOption().matches(options::OPT_fstack_protector_all)) StackProtectorLevel = LangOptions::SSPReq; } else { StackProtectorLevel = - getToolChain().GetDefaultStackProtectorLevel(KernelOrKext); + getToolChain().GetDefaultStackProtectorLevel(KernelOrKext); } if (StackProtectorLevel) { CmdArgs.push_back("-stack-protector"); @@ -4049,7 +4032,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-force-align-stack"); } if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign, - false)) { + false)) { CmdArgs.push_back(Args.MakeArgString("-mstackrealign")); } @@ -4126,12 +4109,12 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // -fblocks=0 is default. if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks, getToolChain().IsBlocksDefault()) || - (Args.hasArg(options::OPT_fgnu_runtime) && - Args.hasArg(options::OPT_fobjc_nonfragile_abi) && - !Args.hasArg(options::OPT_fno_blocks))) { + (Args.hasArg(options::OPT_fgnu_runtime) && + Args.hasArg(options::OPT_fobjc_nonfragile_abi) && + !Args.hasArg(options::OPT_fno_blocks))) { CmdArgs.push_back("-fblocks"); - if (!Args.hasArg(options::OPT_fgnu_runtime) && + if (!Args.hasArg(options::OPT_fgnu_runtime) && !getToolChain().hasBlocksRuntime()) CmdArgs.push_back("-fblocks-runtime-optional"); } @@ -4141,9 +4124,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // 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, - options::OPT_fno_cxx_modules, - true); + bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules, + options::OPT_fno_cxx_modules, true); if (AllowedInCXX || !types::isCXX(InputType)) { CmdArgs.push_back("-fmodules"); HaveModules = true; @@ -4160,16 +4142,14 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // -fmodules-decluse checks that modules used are declared so (off by // default). if (Args.hasFlag(options::OPT_fmodules_decluse, - options::OPT_fno_modules_decluse, - false)) { + options::OPT_fno_modules_decluse, false)) { CmdArgs.push_back("-fmodules-decluse"); } // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that // all #included headers are part of modules. if (Args.hasFlag(options::OPT_fmodules_strict_decluse, - options::OPT_fno_modules_strict_decluse, - false)) { + options::OPT_fno_modules_strict_decluse, false)) { CmdArgs.push_back("-fmodules-strict-decluse"); } @@ -4264,14 +4244,12 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // -faccess-control is default. if (Args.hasFlag(options::OPT_fno_access_control, - options::OPT_faccess_control, - false)) + options::OPT_faccess_control, false)) CmdArgs.push_back("-fno-access-control"); // -felide-constructors is the default. if (Args.hasFlag(options::OPT_fno_elide_constructors, - options::OPT_felide_constructors, - false)) + options::OPT_felide_constructors, false)) CmdArgs.push_back("-fno-elide-constructors"); ToolChain::RTTIMode RTTIMode = getToolChain().getRTTIMode(); @@ -4282,10 +4260,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-fno-rtti"); // -fshort-enums=0 is default for all architectures except Hexagon. - if (Args.hasFlag(options::OPT_fshort_enums, - options::OPT_fno_short_enums, - getToolChain().getArch() == - llvm::Triple::hexagon)) + if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums, + getToolChain().getArch() == llvm::Triple::hexagon)) CmdArgs.push_back("-fshort-enums"); // -fsigned-char is default. @@ -4304,8 +4280,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (!Args.hasFlag(options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit, !IsWindowsCygnus && !IsWindowsGNU && - getToolChain().getArch() != llvm::Triple::hexagon && - getToolChain().getArch() != llvm::Triple::xcore) || + getToolChain().getArch() != llvm::Triple::hexagon && + getToolChain().getArch() != llvm::Triple::xcore) || KernelOrKext) CmdArgs.push_back("-fno-use-cxa-atexit"); @@ -4320,11 +4296,11 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-fuse-line-directives"); // -fms-compatibility=0 is default. - if (Args.hasFlag(options::OPT_fms_compatibility, + if (Args.hasFlag(options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility, - (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions, - options::OPT_fno_ms_extensions, - true)))) + (IsWindowsMSVC && + Args.hasFlag(options::OPT_fms_extensions, + options::OPT_fno_ms_extensions, true)))) CmdArgs.push_back("-fms-compatibility"); // -fms-compatibility-version=18.00 is default. @@ -4366,8 +4342,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, options::OPT_fno_gnu_keywords)) A->render(Args, CmdArgs); - if (Args.hasFlag(options::OPT_fgnu89_inline, - options::OPT_fno_gnu89_inline, + if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline, false)) CmdArgs.push_back("-fgnu89-inline"); @@ -4387,7 +4362,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch, options::OPT_fno_objc_legacy_dispatch, objcRuntime.isLegacyDispatchDefaultForArch( - getToolChain().getArch()))) { + getToolChain().getArch()))) { if (getToolChain().UseObjCMixedDispatch()) CmdArgs.push_back("-fobjc-dispatch-method=mixed"); else @@ -4404,12 +4379,12 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, objcRuntime.getKind() == ObjCRuntime::FragileMacOSX && objcRuntime.isNeXTFamily()) CmdArgs.push_back("-fobjc-subscripting-legacy-runtime"); - + // -fencode-extended-block-signature=1 is default. if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) { CmdArgs.push_back("-fencode-extended-block-signature"); } - + // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc. // NOTE: This logic is duplicated in ToolChains.cpp. bool ARC = isObjCAutoRefCount(Args); @@ -4448,14 +4423,12 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, GCArg = Args.getLastArg(options::OPT_fobjc_gc); if (GCArg) { if (ARC) { - D.Diag(diag::err_drv_objc_gc_arr) - << GCArg->getAsString(Args); + D.Diag(diag::err_drv_objc_gc_arr) << GCArg->getAsString(Args); } else if (getToolChain().SupportsObjCGC()) { GCArg->render(Args, CmdArgs); } else { // FIXME: We should move this to a hard error. - D.Diag(diag::warn_drv_objc_gc_unsupported) - << GCArg->getAsString(Args); + D.Diag(diag::warn_drv_objc_gc_unsupported) << GCArg->getAsString(Args); } } @@ -4465,8 +4438,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // Handle GCC-style exception args. if (!C.getDriver().IsCLMode()) - addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext, - objcRuntime, CmdArgs); + addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext, objcRuntime, + CmdArgs); if (getToolChain().UseSjLjExceptions()) CmdArgs.push_back("-fsjlj-exceptions"); @@ -4498,8 +4471,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // -fno-pascal-strings is default, only pass non-default. if (Args.hasFlag(options::OPT_fpascal_strings, - options::OPT_fno_pascal_strings, - false)) + options::OPT_fno_pascal_strings, false)) CmdArgs.push_back("-fpascal-strings"); // Honor -fpack-struct= and -fpack-struct, if given. Note that @@ -4543,28 +4515,27 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (!Args.hasFlag(options::OPT_fsigned_bitfields, options::OPT_funsigned_bitfields)) D.Diag(diag::warn_drv_clang_unsupported) - << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); + << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope. - if (!Args.hasFlag(options::OPT_ffor_scope, - options::OPT_fno_for_scope)) + if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope)) D.Diag(diag::err_drv_clang_unsupported) - << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args); + << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args); // -finput_charset=UTF-8 is default. Reject others - if (Arg *inputCharset = Args.getLastArg( - options::OPT_finput_charset_EQ)) { - StringRef value = inputCharset->getValue(); - if (value != "UTF-8") - D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value; + if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) { + StringRef value = inputCharset->getValue(); + if (value != "UTF-8") + D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) + << value; } // -fexec_charset=UTF-8 is default. Reject others - if (Arg *execCharset = Args.getLastArg( - options::OPT_fexec_charset_EQ)) { - StringRef value = execCharset->getValue(); - if (value != "UTF-8") - D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) << value; + if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) { + StringRef value = execCharset->getValue(); + if (value != "UTF-8") + D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) + << value; } // -fcaret-diagnostics is default. @@ -4583,22 +4554,21 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-fdiagnostics-show-option"); if (const Arg *A = - Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) { + Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) { CmdArgs.push_back("-fdiagnostics-show-category"); CmdArgs.push_back(A->getValue()); } - if (const Arg *A = - Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) { + if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) { CmdArgs.push_back("-fdiagnostics-format"); CmdArgs.push_back(A->getValue()); } if (Arg *A = Args.getLastArg( - options::OPT_fdiagnostics_show_note_include_stack, - options::OPT_fno_diagnostics_show_note_include_stack)) { + options::OPT_fdiagnostics_show_note_include_stack, + options::OPT_fno_diagnostics_show_note_include_stack)) { if (A->getOption().matches( - options::OPT_fdiagnostics_show_note_include_stack)) + options::OPT_fdiagnostics_show_note_include_stack)) CmdArgs.push_back("-fdiagnostics-show-note-include-stack"); else CmdArgs.push_back("-fno-diagnostics-show-note-include-stack"); @@ -4636,7 +4606,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, ShowColors = Colors_Auto; else getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) - << ("-fdiagnostics-color=" + value).str(); + << ("-fdiagnostics-color=" + value).str(); } } if (ShowColors == Colors_On || @@ -4650,8 +4620,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, options::OPT_fno_show_source_location)) CmdArgs.push_back("-fno-show-source-location"); - if (!Args.hasFlag(options::OPT_fshow_column, - options::OPT_fno_show_column, + if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column, true)) CmdArgs.push_back("-fno-show-column"); @@ -4659,7 +4628,6 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, options::OPT_fno_spell_checking)) CmdArgs.push_back("-fno-spell-checking"); - // -fno-asm-blocks is default. if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks, false)) @@ -4674,16 +4642,16 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // selected. For optimization levels that want vectorization we use the alias // option to simplify the hasFlag logic. bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false); - OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group : - options::OPT_fvectorize; + OptSpecifier VectorizeAliasOption = + EnableVec ? options::OPT_O_Group : options::OPT_fvectorize; if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption, options::OPT_fno_vectorize, EnableVec)) CmdArgs.push_back("-vectorize-loops"); // -fslp-vectorize is enabled based on the optimization level selected. bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true); - OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group : - options::OPT_fslp_vectorize; + OptSpecifier SLPVectAliasOption = + EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize; if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption, options::OPT_fno_slp_vectorize, EnableSLPVec)) CmdArgs.push_back("-vectorize-slp"); @@ -4718,16 +4686,16 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, options::OPT_fno_apple_pragma_pack, false)) CmdArgs.push_back("-fapple-pragma-pack"); - // le32-specific flags: + // le32-specific flags: // -fno-math-builtin: clang should not convert math builtins to intrinsics // by default. if (getToolChain().getArch() == llvm::Triple::le32) { CmdArgs.push_back("-fno-math-builtin"); } - // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM. - // - // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941. +// Default to -fno-builtin-str{cat,cpy} on Darwin for ARM. +// +// FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941. #if 0 if (getToolChain().getTriple().isOSDarwin() && (getToolChain().getArch() == llvm::Triple::arm || @@ -4759,7 +4727,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, Args.AddLastArg(CmdArgs, options::OPT_dM); Args.AddLastArg(CmdArgs, options::OPT_dD); - + // Handle serialized diagnostics. if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) { CmdArgs.push_back("-serialize-diagnostic-file"); @@ -4828,9 +4796,9 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, SmallString<256> Flags; Flags += Exec; - for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) { + for (const char *OriginalArg : OriginalArgs) { SmallString<128> EscapedArg; - EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg); + EscapeSpacesAndBackslashes(OriginalArg, EscapedArg); Flags += " "; Flags += EscapedArg; } @@ -4841,9 +4809,9 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // Add the split debug info name to the command lines here so we // can propagate it to the backend. bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) && - getToolChain().getTriple().isOSLinux() && - (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) || - isa<BackendJobAction>(JA)); + getToolChain().getTriple().isOSLinux() && + (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) || + isa<BackendJobAction>(JA)); const char *SplitDwarfOut; if (SplitDwarf) { CmdArgs.push_back("-split-dwarf-file"); @@ -4863,7 +4831,6 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } - // Handle the debug info splitting at object creation time if we're // creating an object. // TODO: Currently only works on linux with newer objcopy. @@ -4872,8 +4839,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (Arg *A = Args.getLastArg(options::OPT_pg)) if (Args.hasArg(options::OPT_fomit_frame_pointer)) - D.Diag(diag::err_drv_argument_not_allowed_with) - << "-fomit-frame-pointer" << A->getAsString(Args); + D.Diag(diag::err_drv_argument_not_allowed_with) << "-fomit-frame-pointer" + << A->getAsString(Args); // Claim some arguments which clang supports automatically. @@ -4898,9 +4865,9 @@ ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args, ArgStringList &cmdArgs, RewriteKind rewriteKind) const { // Look for the controlling runtime option. - Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime, - options::OPT_fgnu_runtime, - options::OPT_fobjc_runtime_EQ); + Arg *runtimeArg = + args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime, + options::OPT_fobjc_runtime_EQ); // Just forward -fobjc-runtime= to the frontend. This supercedes // options about fragility. @@ -4910,7 +4877,7 @@ ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args, StringRef value = runtimeArg->getValue(); if (runtime.tryParse(value)) { getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime) - << value; + << value; } runtimeArg->render(args, cmdArgs); @@ -4933,26 +4900,25 @@ ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args, else if (value == "3") objcABIVersion = 3; else - getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) - << value; + getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) << value; } else { // Otherwise, determine if we are using the non-fragile ABI. - bool nonFragileABIIsDefault = - (rewriteKind == RK_NonFragile || - (rewriteKind == RK_None && - getToolChain().IsObjCNonFragileABIDefault())); + bool nonFragileABIIsDefault = + (rewriteKind == RK_NonFragile || + (rewriteKind == RK_None && + getToolChain().IsObjCNonFragileABIDefault())); if (args.hasFlag(options::OPT_fobjc_nonfragile_abi, options::OPT_fno_objc_nonfragile_abi, nonFragileABIIsDefault)) { - // Determine the non-fragile ABI version to use. +// Determine the non-fragile ABI version to use. #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO unsigned nonFragileABIVersion = 1; #else unsigned nonFragileABIVersion = 2; #endif - if (Arg *abiArg = args.getLastArg( - options::OPT_fobjc_nonfragile_abi_version_EQ)) { + if (Arg *abiArg = + args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) { StringRef value = abiArg->getValue(); if (value == "1") nonFragileABIVersion = 1; @@ -4960,7 +4926,7 @@ ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args, nonFragileABIVersion = 2; else getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) - << value; + << value; } objcABIVersion = 1 + nonFragileABIVersion; @@ -4989,30 +4955,30 @@ ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args, break; } - // -fnext-runtime + // -fnext-runtime } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) { // On Darwin, make this use the default behavior for the toolchain. if (getToolChain().getTriple().isOSDarwin()) { runtime = getToolChain().getDefaultObjCRuntime(isNonFragile); - // Otherwise, build for a generic macosx port. + // Otherwise, build for a generic macosx port. } else { runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple()); } - // -fgnu-runtime + // -fgnu-runtime } else { assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime)); // Legacy behaviour is to target the gnustep runtime if we are i // non-fragile mode or the GCC runtime in fragile mode. if (isNonFragile) - runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6)); + runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1, 6)); else runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple()); } - cmdArgs.push_back(args.MakeArgString( - "-fobjc-runtime=" + runtime.getAsString())); + cmdArgs.push_back( + args.MakeArgString("-fobjc-runtime=" + runtime.getAsString())); return runtime; } @@ -5039,14 +5005,22 @@ struct EHFlags { /// The default is /EHs-c-, meaning cleanups are disabled. static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) { EHFlags EH; - std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH); + std::vector<std::string> EHArgs = + Args.getAllArgValues(options::OPT__SLASH_EH); for (auto EHVal : EHArgs) { for (size_t I = 0, E = EHVal.size(); I != E; ++I) { switch (EHVal[I]) { - case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue; - case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue; - case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue; - default: break; + case 'a': + EH.Asynch = maybeConsumeDash(EHVal, I); + continue; + case 'c': + EH.NoExceptC = maybeConsumeDash(EHVal, I); + continue; + case 's': + EH.Synch = maybeConsumeDash(EHVal, I); + continue; + default: + break; } D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal; break; @@ -5066,33 +5040,33 @@ void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const { if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group)) RTOptionID = A->getOption().getID(); - switch(RTOptionID) { - case options::OPT__SLASH_MD: - if (Args.hasArg(options::OPT__SLASH_LDd)) - CmdArgs.push_back("-D_DEBUG"); - CmdArgs.push_back("-D_MT"); - CmdArgs.push_back("-D_DLL"); - CmdArgs.push_back("--dependent-lib=msvcrt"); - break; - case options::OPT__SLASH_MDd: + switch (RTOptionID) { + case options::OPT__SLASH_MD: + if (Args.hasArg(options::OPT__SLASH_LDd)) CmdArgs.push_back("-D_DEBUG"); - CmdArgs.push_back("-D_MT"); - CmdArgs.push_back("-D_DLL"); - CmdArgs.push_back("--dependent-lib=msvcrtd"); - break; - case options::OPT__SLASH_MT: - if (Args.hasArg(options::OPT__SLASH_LDd)) - CmdArgs.push_back("-D_DEBUG"); - CmdArgs.push_back("-D_MT"); - CmdArgs.push_back("--dependent-lib=libcmt"); - break; - case options::OPT__SLASH_MTd: + CmdArgs.push_back("-D_MT"); + CmdArgs.push_back("-D_DLL"); + CmdArgs.push_back("--dependent-lib=msvcrt"); + break; + case options::OPT__SLASH_MDd: + CmdArgs.push_back("-D_DEBUG"); + CmdArgs.push_back("-D_MT"); + CmdArgs.push_back("-D_DLL"); + CmdArgs.push_back("--dependent-lib=msvcrtd"); + break; + case options::OPT__SLASH_MT: + if (Args.hasArg(options::OPT__SLASH_LDd)) CmdArgs.push_back("-D_DEBUG"); - CmdArgs.push_back("-D_MT"); - CmdArgs.push_back("--dependent-lib=libcmtd"); - break; - default: - llvm_unreachable("Unexpected option ID."); + CmdArgs.push_back("-D_MT"); + CmdArgs.push_back("--dependent-lib=libcmt"); + break; + case options::OPT__SLASH_MTd: + CmdArgs.push_back("-D_DEBUG"); + CmdArgs.push_back("-D_MT"); + CmdArgs.push_back("--dependent-lib=libcmtd"); + break; + default: + llvm_unreachable("Unexpected option ID."); } // This provides POSIX compatibility (maps 'open' to '_open'), which most @@ -5176,9 +5150,9 @@ void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const { } } -visualstudio::Compile *Clang::getCLFallback() const { +visualstudio::Compiler *Clang::getCLFallback() const { if (!CLFallback) - CLFallback.reset(new visualstudio::Compile(getToolChain())); + CLFallback.reset(new visualstudio::Compiler(getToolChain())); return CLFallback.get(); } @@ -5194,8 +5168,7 @@ void ClangAs::AddMIPSTargetArgs(const ArgList &Args, } void ClangAs::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, + const InputInfo &Output, const InputInfoList &Inputs, const ArgList &Args, const char *LinkingOutput) const { ArgStringList CmdArgs; @@ -5217,8 +5190,8 @@ void ClangAs::ConstructJob(Compilation &C, const JobAction &JA, // Add the "effective" target triple. CmdArgs.push_back("-triple"); - std::string TripleStr = - getToolChain().ComputeEffectiveClangTriple(Args, Input.getType()); + std::string TripleStr = + getToolChain().ComputeEffectiveClangTriple(Args, Input.getType()); CmdArgs.push_back(Args.MakeArgString(TripleStr)); // Set the output mode, we currently only expect to be used as a real @@ -5244,7 +5217,10 @@ void ClangAs::ConstructJob(Compilation &C, const JobAction &JA, getTargetFeatures(D, Triple, Args, CmdArgs, true); // Ignore explicit -force_cpusubtype_ALL option. - (void) Args.hasArg(options::OPT_force__cpusubtype__ALL); + (void)Args.hasArg(options::OPT_force__cpusubtype__ALL); + + // Pass along any -I options so we get proper .include search paths. + Args.AddAllArgs(CmdArgs, options::OPT_I_Group); // Determine the original source input. const Action *SourceAction = &JA; @@ -5288,9 +5264,9 @@ void ClangAs::ConstructJob(Compilation &C, const JobAction &JA, SmallString<256> Flags; const char *Exec = getToolChain().getDriver().getClangProgramPath(); Flags += Exec; - for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) { + for (const char *OriginalArg : OriginalArgs) { SmallString<128> EscapedArg; - EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg); + EscapeSpacesAndBackslashes(OriginalArg, EscapedArg); Flags += " "; Flags += EscapedArg; } @@ -5301,7 +5277,7 @@ void ClangAs::ConstructJob(Compilation &C, const JobAction &JA, // FIXME: Add -static support, once we have it. // Add target specific flags. - switch(getToolChain().getArch()) { + switch (getToolChain().getArch()) { default: break; @@ -5349,8 +5325,7 @@ void GnuTool::anchor() {} void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, + const InputInfoList &Inputs, const ArgList &Args, const char *LinkingOutput) const { const Driver &D = getToolChain().getDriver(); ArgStringList CmdArgs; @@ -5382,7 +5357,7 @@ void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, if (getToolChain().getTriple().isOSDarwin()) { CmdArgs.push_back("-arch"); CmdArgs.push_back( - Args.MakeArgString(getToolChain().getDefaultUniversalArchName())); + Args.MakeArgString(getToolChain().getDefaultUniversalArchName())); } // Try to force gcc to match the tool chain we want, if we recognize @@ -5405,8 +5380,7 @@ void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-fsyntax-only"); } - Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, - options::OPT_Xassembler); + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); // Only pass -x if gcc will understand it; otherwise hope gcc // understands the suffix correctly. The main use case this would go @@ -5421,13 +5395,12 @@ void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR || II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC) D.Diag(diag::err_drv_no_linker_llvm_support) - << getToolChain().getTripleString(); + << getToolChain().getTripleString(); else if (II.getType() == types::TY_AST) - D.Diag(diag::err_drv_no_ast_support) - << getToolChain().getTripleString(); + D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString(); else if (II.getType() == types::TY_ModuleFile) D.Diag(diag::err_drv_no_module_support) - << getToolChain().getTripleString(); + << getToolChain().getTripleString(); if (types::canTypeBeUserSpecified(II.getType())) { CmdArgs.push_back("-x"); @@ -5459,18 +5432,17 @@ void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, } else GCCName = "gcc"; - const char *Exec = - Args.MakeArgString(getToolChain().GetProgramPath(GCCName)); + const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName)); C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA, - ArgStringList &CmdArgs) const { +void gcc::Preprocessor::RenderExtraToolArgs(const JobAction &JA, + ArgStringList &CmdArgs) const { CmdArgs.push_back("-E"); } -void gcc::Compile::RenderExtraToolArgs(const JobAction &JA, - ArgStringList &CmdArgs) const { +void gcc::Compiler::RenderExtraToolArgs(const JobAction &JA, + ArgStringList &CmdArgs) const { const Driver &D = getToolChain().getDriver(); switch (JA.getType()) { @@ -5492,21 +5464,19 @@ void gcc::Compile::RenderExtraToolArgs(const JobAction &JA, } } -void gcc::Link::RenderExtraToolArgs(const JobAction &JA, - ArgStringList &CmdArgs) const { +void gcc::Linker::RenderExtraToolArgs(const JobAction &JA, + ArgStringList &CmdArgs) const { // The types are (hopefully) good enough. } // Hexagon tools start. -void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA, - ArgStringList &CmdArgs) const { - -} -void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA, + ArgStringList &CmdArgs) const {} +void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { claimNoWarnArgs(Args); const Driver &D = getToolChain().getDriver(); @@ -5526,11 +5496,10 @@ void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-fsyntax-only"); } - if (const char* v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) + if (const char *v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v)); - Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, - options::OPT_Xassembler); + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); // Only pass -x if gcc will understand it; otherwise hope gcc // understands the suffix correctly. The main use case this would go @@ -5545,18 +5514,19 @@ void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA, if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR || II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC) D.Diag(clang::diag::err_drv_no_linker_llvm_support) - << getToolChain().getTripleString(); + << getToolChain().getTripleString(); else if (II.getType() == types::TY_AST) D.Diag(clang::diag::err_drv_no_ast_support) - << getToolChain().getTripleString(); + << getToolChain().getTripleString(); else if (II.getType() == types::TY_ModuleFile) D.Diag(diag::err_drv_no_module_support) - << getToolChain().getTripleString(); + << getToolChain().getTripleString(); if (II.isFilename()) CmdArgs.push_back(II.getFilename()); else - // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ? + // Don't render as input, we need gcc to do the translations. + // FIXME: Pranav: What is this ? II.getInputArg().render(Args, CmdArgs); } @@ -5565,22 +5535,21 @@ void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void hexagon::Link::RenderExtraToolArgs(const JobAction &JA, - ArgStringList &CmdArgs) const { +void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA, + ArgStringList &CmdArgs) const { // The types are (hopefully) good enough. } static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA, - const toolchains::Hexagon_TC& ToolChain, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - ArgStringList &CmdArgs, - const char *LinkingOutput) { + const toolchains::Hexagon_TC &ToolChain, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + ArgStringList &CmdArgs, + const char *LinkingOutput) { const Driver &D = ToolChain.getDriver(); - //---------------------------------------------------------------------------- // //---------------------------------------------------------------------------- @@ -5624,7 +5593,7 @@ static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA, if (buildPIE && !buildingLib) CmdArgs.push_back("-pie"); - if (const char* v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) { + if (const char *v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) { CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v)); useG0 = toolchains::Hexagon_TC::UsesG0(v); } @@ -5640,15 +5609,14 @@ static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA, const std::string MarchG0Suffix = MarchSuffix + G0Suffix; const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir, Args) + "/"; - const std::string StartFilesDir = RootDir - + "hexagon/lib" - + (useG0 ? MarchG0Suffix : MarchSuffix); + const std::string StartFilesDir = + RootDir + "hexagon/lib" + (useG0 ? MarchG0Suffix : MarchSuffix); //---------------------------------------------------------------------------- // moslib //---------------------------------------------------------------------------- std::vector<std::string> oslibs; - bool hasStandalone= false; + bool hasStandalone = false; for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) { A->claim(); @@ -5668,7 +5636,7 @@ static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA, if (!buildingLib) { if (hasStandalone) { CmdArgs.push_back( - Args.MakeArgString(StartFilesDir + "/crt0_standalone.o")); + Args.MakeArgString(StartFilesDir + "/crt0_standalone.o")); } CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o")); } @@ -5706,9 +5674,8 @@ static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA, CmdArgs.push_back("--start-group"); if (!buildingLib) { - for(std::vector<std::string>::iterator i = oslibs.begin(), - e = oslibs.end(); i != e; ++i) - CmdArgs.push_back(Args.MakeArgString("-l" + *i)); + for (const std::string &Lib : oslibs) + CmdArgs.push_back(Args.MakeArgString("-l" + Lib)); CmdArgs.push_back("-lc"); } CmdArgs.push_back("-lgcc"); @@ -5725,14 +5692,14 @@ static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA, } } -void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { - const toolchains::Hexagon_TC& ToolChain = - static_cast<const toolchains::Hexagon_TC&>(getToolChain()); + const toolchains::Hexagon_TC &ToolChain = + static_cast<const toolchains::Hexagon_TC &>(getToolChain()); ArgStringList CmdArgs; constructHexagonLinkArgs(C, JA, ToolChain, Output, Inputs, Args, CmdArgs, @@ -5764,7 +5731,7 @@ const std::string arm::getARMArch(const ArgList &Args, const char *Suffix = arm::getLLVMArchSuffixForARM(CPU, MArch); // If there is no valid architecture suffix for this CPU we don't know how // to handle it, so return no architecture. - if (strcmp(Suffix,"") == 0) + if (strcmp(Suffix, "") == 0) MArch = ""; else MArch = std::string("arm") + Suffix; @@ -5793,7 +5760,7 @@ const char *arm::getARMCPUForMArch(const ArgList &Args, /// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting. std::string arm::getARMTargetCPU(const ArgList &Args, - const llvm::Triple &Triple) { + const llvm::Triple &Triple) { // FIXME: Warn on inconsistent use of -mcpu and -march. // If we have -mcpu=, use that. if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { @@ -5822,7 +5789,7 @@ const char *arm::getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch) { return llvm::ARMTargetParser::getSubArch(ArchKind); } -void arm::appendEBLinkFlags(const ArgList &Args, ArgStringList &CmdArgs, +void arm::appendEBLinkFlags(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple) { if (Args.hasArg(options::OPT_r)) return; @@ -5866,14 +5833,14 @@ bool mips::isUCLibc(const ArgList &Args) { bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) { if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ)) return llvm::StringSwitch<bool>(NaNArg->getValue()) - .Case("2008", true) - .Case("legacy", false) - .Default(false); + .Case("2008", true) + .Case("legacy", false) + .Default(false); // NaN2008 is the default for MIPS32r6/MIPS64r6. return llvm::StringSwitch<bool>(getCPUName(Args, Triple)) - .Cases("mips32r6", "mips64r6", true) - .Default(false); + .Cases("mips32r6", "mips64r6", true) + .Default(false); return false; } @@ -5893,10 +5860,10 @@ bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName, return false; return llvm::StringSwitch<bool>(CPUName) - .Cases("mips2", "mips3", "mips4", "mips5", true) - .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true) - .Cases("mips64", "mips64r2", "mips64r3", "mips64r5", true) - .Default(false); + .Cases("mips2", "mips3", "mips4", "mips5", true) + .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true) + .Cases("mips64", "mips64r2", "mips64r3", "mips64r5", true) + .Default(false); } bool mips::shouldUseFPXX(const ArgList &Args, const llvm::Triple &Triple, @@ -5927,25 +5894,25 @@ llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) { // translation. return llvm::StringSwitch<llvm::Triple::ArchType>(Str) - .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc) - .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc) - .Case("ppc64", llvm::Triple::ppc64) - .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86) - .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4", - llvm::Triple::x86) - .Cases("x86_64", "x86_64h", llvm::Triple::x86_64) - // This is derived from the driver driver. - .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm) - .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm) - .Cases("armv7s", "xscale", llvm::Triple::arm) - .Case("arm64", llvm::Triple::aarch64) - .Case("r600", llvm::Triple::r600) - .Case("amdgcn", llvm::Triple::amdgcn) - .Case("nvptx", llvm::Triple::nvptx) - .Case("nvptx64", llvm::Triple::nvptx64) - .Case("amdil", llvm::Triple::amdil) - .Case("spir", llvm::Triple::spir) - .Default(llvm::Triple::UnknownArch); + .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc) + .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc) + .Case("ppc64", llvm::Triple::ppc64) + .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86) + .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4", + llvm::Triple::x86) + .Cases("x86_64", "x86_64h", llvm::Triple::x86_64) + // This is derived from the driver driver. + .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm) + .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm) + .Cases("armv7s", "xscale", llvm::Triple::arm) + .Case("arm64", llvm::Triple::aarch64) + .Case("r600", llvm::Triple::r600) + .Case("amdgcn", llvm::Triple::amdgcn) + .Case("nvptx", llvm::Triple::nvptx) + .Case("nvptx64", llvm::Triple::nvptx64) + .Case("amdil", llvm::Triple::amdil) + .Case("spir", llvm::Triple::spir) + .Default(llvm::Triple::UnknownArch); } void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) { @@ -5989,11 +5956,11 @@ const char *Clang::getDependencyFileName(const ArgList &Args, return Args.MakeArgString(Res + ".d"); } -void cloudabi::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void cloudabi::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { const ToolChain &ToolChain = getToolChain(); const Driver &D = ToolChain.getDriver(); ArgStringList CmdArgs; @@ -6059,11 +6026,11 @@ void cloudabi::Link::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void darwin::Assembler::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 && "Unexpected number of inputs."); @@ -6112,8 +6079,7 @@ void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA, Args.hasArg(options::OPT_static))) CmdArgs.push_back("-static"); - Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, - options::OPT_Xassembler); + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); assert(Output.isFilename() && "Unexpected lipo output."); CmdArgs.push_back("-o"); @@ -6124,8 +6090,7 @@ void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA, // asm_final spec is empty. - const char *Exec = - Args.MakeArgString(getToolChain().GetProgramPath("as")); + const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as")); C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } @@ -6144,7 +6109,7 @@ void darwin::MachOTool::AddMachOArch(const ArgList &Args, CmdArgs.push_back("-force_cpusubtype_ALL"); } -bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const { +bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const { // We only need to generate a temp path for LTO if we aren't compiling object // files. When compiling source files, we run 'dsymutil' after linking. We // don't run 'dsymutil' when compiling object files. @@ -6155,21 +6120,19 @@ bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const { return false; } -void darwin::Link::AddLinkArgs(Compilation &C, - const ArgList &Args, - ArgStringList &CmdArgs, - const InputInfoList &Inputs) const { +void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args, + ArgStringList &CmdArgs, + const InputInfoList &Inputs) const { const Driver &D = getToolChain().getDriver(); const toolchains::MachO &MachOTC = getMachOToolChain(); - unsigned Version[3] = { 0, 0, 0 }; + unsigned Version[3] = {0, 0, 0}; if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) { bool HadExtra; - if (!Driver::GetReleaseVersion(A->getValue(), Version[0], - Version[1], Version[2], HadExtra) || + if (!Driver::GetReleaseVersion(A->getValue(), Version[0], Version[1], + Version[2], HadExtra) || HadExtra) - D.Diag(diag::err_drv_invalid_version_number) - << A->getAsString(Args); + D.Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args); } // Newer linkers support -demangle. Pass it if supported and not disabled by @@ -6191,7 +6154,7 @@ void darwin::Link::AddLinkArgs(Compilation &C, // dsymutil step. if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) { const char *TmpPath = C.getArgs().MakeArgString( - D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object))); + D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object))); C.addTempFile(TmpPath); CmdArgs.push_back("-object_path_lto"); CmdArgs.push_back(TmpPath); @@ -6219,8 +6182,8 @@ void darwin::Link::AddLinkArgs(Compilation &C, if ((A = Args.getLastArg(options::OPT_compatibility__version)) || (A = Args.getLastArg(options::OPT_current__version)) || (A = Args.getLastArg(options::OPT_install__name))) - D.Diag(diag::err_drv_argument_only_allowed_with) - << A->getAsString(Args) << "-dynamiclib"; + D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args) + << "-dynamiclib"; Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace); Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs); @@ -6235,8 +6198,8 @@ void darwin::Link::AddLinkArgs(Compilation &C, (A = Args.getLastArg(options::OPT_force__flat__namespace)) || (A = Args.getLastArg(options::OPT_keep__private__externs)) || (A = Args.getLastArg(options::OPT_private__bundle))) - D.Diag(diag::err_drv_argument_not_allowed_with) - << A->getAsString(Args) << "-dynamiclib"; + D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args) + << "-dynamiclib"; Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version, "-dylib_compatibility_version"); @@ -6274,9 +6237,9 @@ void darwin::Link::AddLinkArgs(Compilation &C, Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined); Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused); - if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE, - options::OPT_fno_pie, - options::OPT_fno_PIE)) { + if (const Arg *A = + Args.getLastArg(options::OPT_fpie, options::OPT_fPIE, + options::OPT_fno_pie, options::OPT_fno_PIE)) { if (A->getOption().matches(options::OPT_fpie) || A->getOption().matches(options::OPT_fPIE)) CmdArgs.push_back("-pie"); @@ -6335,11 +6298,11 @@ void darwin::Link::AddLinkArgs(Compilation &C, Args.AddLastArg(CmdArgs, options::OPT_Mach); } -void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { assert(Output.getType() == types::TY_Image && "Invalid linker output type."); // If the number of arguments surpasses the system limits, we will encode the @@ -6359,7 +6322,7 @@ void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, for (const auto &Arg : Args) Arg->claim(); const char *Exec = - Args.MakeArgString(getToolChain().GetProgramPath("touch")); + Args.MakeArgString(getToolChain().GetProgramPath("touch")); CmdArgs.push_back(Output.getFilename()); C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); return; @@ -6437,8 +6400,7 @@ void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, InputFileList.push_back(II.getFilename()); } - if (isObjCRuntimeLinked(Args) && - !Args.hasArg(options::OPT_nostdlib) && + if (isObjCRuntimeLinked(Args) && !Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_nodefaultlibs)) { // We use arclite library for both ARC and subscripting support. getMachOToolChain().AddLinkARCArgs(Args, CmdArgs); @@ -6496,10 +6458,9 @@ void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, } } - const char *Exec = - Args.MakeArgString(getToolChain().GetLinkerPath()); + const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath()); std::unique_ptr<Command> Cmd = - llvm::make_unique<Command>(JA, *this, Exec, CmdArgs); + llvm::make_unique<Command>(JA, *this, Exec, CmdArgs); Cmd->setInputFileList(std::move(InputFileList)); C.addCommand(std::move(Cmd)); } @@ -6542,7 +6503,7 @@ void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back(Input.getFilename()); const char *Exec = - Args.MakeArgString(getToolChain().GetProgramPath("dsymutil")); + Args.MakeArgString(getToolChain().GetProgramPath("dsymutil")); C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } @@ -6565,11 +6526,11 @@ void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back(Input.getFilename()); const char *Exec = - Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump")); + Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump")); C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA, +void solaris::Assembler::ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const ArgList &Args, @@ -6577,8 +6538,7 @@ void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA, claimNoWarnArgs(Args); ArgStringList CmdArgs; - Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, - options::OPT_Xassembler); + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); CmdArgs.push_back("-o"); CmdArgs.push_back(Output.getFilename()); @@ -6590,11 +6550,11 @@ void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { // FIXME: Find a real GCC, don't hard-code versions here std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/"; const llvm::Triple &T = getToolChain().getTriple(); @@ -6690,16 +6650,15 @@ void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA, addProfileRT(getToolChain(), Args, CmdArgs); - const char *Exec = - Args.MakeArgString(getToolChain().GetLinkerPath()); + const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath()); C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void openbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { claimNoWarnArgs(Args); ArgStringList CmdArgs; bool NeedsKPIC = false; @@ -6753,8 +6712,7 @@ void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, if (NeedsKPIC) addAssemblerKPIC(Args, CmdArgs); - Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, - options::OPT_Xassembler); + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); CmdArgs.push_back("-o"); CmdArgs.push_back(Output.getFilename()); @@ -6762,16 +6720,15 @@ void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, for (const auto &II : Inputs) CmdArgs.push_back(II.getFilename()); - const char *Exec = - Args.MakeArgString(getToolChain().GetProgramPath("as")); + const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as")); C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void openbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { const Driver &D = getToolChain().getDriver(); ArgStringList CmdArgs; @@ -6822,25 +6779,25 @@ void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, if (!Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_nostartfiles)) { if (!Args.hasArg(options::OPT_shared)) { - if (Args.hasArg(options::OPT_pg)) - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("gcrt0.o"))); + if (Args.hasArg(options::OPT_pg)) + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("gcrt0.o"))); else - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crt0.o"))); - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtbegin.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crt0.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o"))); } else { - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtbeginS.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o"))); } } std::string Triple = getToolChain().getTripleString(); if (Triple.substr(0, 6) == "x86_64") Triple.replace(0, 6, "amd64"); - CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + - "/4.2.1")); + CmdArgs.push_back( + Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + "/4.2.1")); Args.AddAllArgs(CmdArgs, options::OPT_L); Args.AddAllArgs(CmdArgs, options::OPT_T_Group); @@ -6856,7 +6813,7 @@ void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, !Args.hasArg(options::OPT_nodefaultlibs)) { if (D.CCCIsCXX()) { getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); - if (Args.hasArg(options::OPT_pg)) + if (Args.hasArg(options::OPT_pg)) CmdArgs.push_back("-lm_p"); else CmdArgs.push_back("-lm"); @@ -6867,18 +6824,17 @@ void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-lgcc"); if (Args.hasArg(options::OPT_pthread)) { - if (!Args.hasArg(options::OPT_shared) && - Args.hasArg(options::OPT_pg)) - CmdArgs.push_back("-lpthread_p"); + if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg)) + CmdArgs.push_back("-lpthread_p"); else - CmdArgs.push_back("-lpthread"); + CmdArgs.push_back("-lpthread"); } if (!Args.hasArg(options::OPT_shared)) { if (Args.hasArg(options::OPT_pg)) - CmdArgs.push_back("-lc_p"); + CmdArgs.push_back("-lc_p"); else - CmdArgs.push_back("-lc"); + CmdArgs.push_back("-lc"); } CmdArgs.push_back("-lgcc"); @@ -6887,28 +6843,26 @@ void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, if (!Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_nostartfiles)) { if (!Args.hasArg(options::OPT_shared)) - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtend.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtend.o"))); else - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtendS.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtendS.o"))); } - const char *Exec = - Args.MakeArgString(getToolChain().GetLinkerPath()); + const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath()); C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void bitrig::Assembler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { claimNoWarnArgs(Args); ArgStringList CmdArgs; - Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, - options::OPT_Xassembler); + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); CmdArgs.push_back("-o"); CmdArgs.push_back(Output.getFilename()); @@ -6920,11 +6874,11 @@ void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void bitrig::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { const Driver &D = getToolChain().getDriver(); ArgStringList CmdArgs; @@ -6960,16 +6914,16 @@ void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA, !Args.hasArg(options::OPT_nostartfiles)) { if (!Args.hasArg(options::OPT_shared)) { if (Args.hasArg(options::OPT_pg)) - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("gcrt0.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("gcrt0.o"))); else - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crt0.o"))); - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtbegin.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crt0.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o"))); } else { - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtbeginS.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o"))); } } @@ -6990,8 +6944,7 @@ void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA, } if (Args.hasArg(options::OPT_pthread)) { - if (!Args.hasArg(options::OPT_shared) && - Args.hasArg(options::OPT_pg)) + if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg)) CmdArgs.push_back("-lpthread_p"); else CmdArgs.push_back("-lpthread"); @@ -7024,23 +6977,22 @@ void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA, if (!Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_nostartfiles)) { if (!Args.hasArg(options::OPT_shared)) - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtend.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtend.o"))); else - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtendS.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtendS.o"))); } - const char *Exec = - Args.MakeArgString(getToolChain().GetLinkerPath()); + const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath()); C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void freebsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { claimNoWarnArgs(Args); ArgStringList CmdArgs; @@ -7085,7 +7037,7 @@ void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-mfpu=softvfp"); } - switch(getToolChain().getTriple().getEnvironment()) { + switch (getToolChain().getTriple().getEnvironment()) { case llvm::Triple::GNUEABIHF: case llvm::Triple::GNUEABI: case llvm::Triple::EABI: @@ -7106,8 +7058,7 @@ void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, addAssemblerKPIC(Args, CmdArgs); } - Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, - options::OPT_Xassembler); + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); CmdArgs.push_back("-o"); CmdArgs.push_back(Output.getFilename()); @@ -7119,11 +7070,11 @@ void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void freebsd::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { const toolchains::FreeBSD &ToolChain = static_cast<const toolchains::FreeBSD &>(getToolChain()); const Driver &D = ToolChain.getDriver(); @@ -7298,12 +7249,11 @@ void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA, addProfileRT(ToolChain, Args, CmdArgs); - const char *Exec = - Args.MakeArgString(getToolChain().GetLinkerPath()); + const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath()); C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, +void netbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const ArgList &Args, @@ -7363,11 +7313,10 @@ void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, break; default: - break; + break; } - Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, - options::OPT_Xassembler); + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); CmdArgs.push_back("-o"); CmdArgs.push_back(Output.getFilename()); @@ -7379,11 +7328,11 @@ void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void netbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { const Driver &D = getToolChain().getDriver(); ArgStringList CmdArgs; @@ -7430,7 +7379,8 @@ void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, break; case llvm::Triple::armeb: case llvm::Triple::thumbeb: - arm::appendEBLinkFlags(Args, CmdArgs, + arm::appendEBLinkFlags( + Args, CmdArgs, llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args))); CmdArgs.push_back("-m"); switch (getToolChain().getTriple().getEnvironment()) { @@ -7455,14 +7405,14 @@ void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("elf32btsmip"); else CmdArgs.push_back("elf32ltsmip"); - } else if (mips::hasMipsAbiArg(Args, "64")) { - CmdArgs.push_back("-m"); - if (getToolChain().getArch() == llvm::Triple::mips64) - CmdArgs.push_back("elf64btsmip"); - else - CmdArgs.push_back("elf64ltsmip"); - } - break; + } else if (mips::hasMipsAbiArg(Args, "64")) { + CmdArgs.push_back("-m"); + if (getToolChain().getArch() == llvm::Triple::mips64) + CmdArgs.push_back("elf64btsmip"); + else + CmdArgs.push_back("elf64ltsmip"); + } + break; case llvm::Triple::ppc: CmdArgs.push_back("-m"); CmdArgs.push_back("elf32ppc_nbsd"); @@ -7498,17 +7448,17 @@ void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, if (!Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_nostartfiles)) { if (!Args.hasArg(options::OPT_shared)) { - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crt0.o"))); - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crti.o"))); - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtbegin.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crt0.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o"))); } else { - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crti.o"))); - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtbeginS.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o"))); } } @@ -7526,7 +7476,7 @@ void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, getToolChain().getTriple().getOSVersion(Major, Minor, Micro); bool useLibgcc = true; if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) { - switch(getToolChain().getArch()) { + switch (getToolChain().getArch()) { case llvm::Triple::aarch64: case llvm::Triple::arm: case llvm::Triple::armeb: @@ -7574,13 +7524,12 @@ void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, if (!Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_nostartfiles)) { if (!Args.hasArg(options::OPT_shared)) - CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( - "crtend.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtend.o"))); else - CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( - "crtendS.o"))); - CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( - "crtn.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtendS.o"))); + CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o"))); } addProfileRT(getToolChain(), Args, CmdArgs); @@ -7589,11 +7538,11 @@ void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void gnutools::Assembler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { claimNoWarnArgs(Args); ArgStringList CmdArgs; @@ -7668,8 +7617,8 @@ void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA, // march from being picked in the absence of a cpu flag. Arg *A; if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) && - StringRef(A->getValue()).lower() == "krait") - CmdArgs.push_back("-march=armv7-a"); + StringRef(A->getValue()).lower() == "krait") + CmdArgs.push_back("-march=armv7-a"); else Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ); Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ); @@ -7733,8 +7682,8 @@ void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA, // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of // -mno-mips16 is actually -no-mips16. - if (Arg *A = Args.getLastArg(options::OPT_mips16, - options::OPT_mno_mips16)) { + if (Arg *A = + Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) { if (A->getOption().matches(options::OPT_mips16)) { A->claim(); A->render(Args, CmdArgs); @@ -7780,8 +7729,7 @@ void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA, if (NeedsKPIC) addAssemblerKPIC(Args, CmdArgs); - Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, - options::OPT_Xassembler); + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); CmdArgs.push_back("-o"); CmdArgs.push_back(Output.getFilename()); @@ -7909,7 +7857,8 @@ static void AddRunTimeLibs(const ToolChain &TC, const Driver &D, switch (RLT) { case ToolChain::RLT_CompilerRT: switch (TC.getTriple().getOS()) { - default: llvm_unreachable("unsupported OS"); + default: + llvm_unreachable("unsupported OS"); case llvm::Triple::Win32: case llvm::Triple::Linux: addClangRT(TC, Args, CmdArgs); @@ -7970,11 +7919,11 @@ static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) { } } -void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { const toolchains::Linux &ToolChain = static_cast<const toolchains::Linux &>(getToolChain()); const Driver &D = ToolChain.getDriver(); @@ -8048,7 +7997,7 @@ void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA, !Args.hasArg(options::OPT_nostartfiles)) { if (!isAndroid) { const char *crt1 = nullptr; - if (!Args.hasArg(options::OPT_shared)){ + if (!Args.hasArg(options::OPT_shared)) { if (Args.hasArg(options::OPT_pg)) crt1 = "gcrt1.o"; else if (IsPIE) @@ -8096,11 +8045,10 @@ void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA, // The profile runtime also needs access to system libraries. addProfileRT(getToolChain(), Args, CmdArgs); - if (D.CCCIsCXX() && - !Args.hasArg(options::OPT_nostdlib) && + if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_nodefaultlibs)) { bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) && - !Args.hasArg(options::OPT_static); + !Args.hasArg(options::OPT_static); if (OnlyLibstdcxxStatic) CmdArgs.push_back("-Bstatic"); ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); @@ -8181,37 +8129,35 @@ void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA, llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs)); } - // NaCl ARM assembly (inline or standalone) can be written with a set of macros // for the various SFI requirements like register masking. The assembly tool // inserts the file containing the macros as an input into all the assembly // jobs. -void nacltools::AssembleARM::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { - const toolchains::NaCl_TC& ToolChain = - static_cast<const toolchains::NaCl_TC&>(getToolChain()); +void nacltools::AssemblerARM::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { + const toolchains::NaCl_TC &ToolChain = + static_cast<const toolchains::NaCl_TC &>(getToolChain()); InputInfo NaClMacros(ToolChain.GetNaClArmMacrosPath(), types::TY_PP_Asm, "nacl-arm-macros.s"); InputInfoList NewInputs; NewInputs.push_back(NaClMacros); NewInputs.append(Inputs.begin(), Inputs.end()); - gnutools::Assemble::ConstructJob(C, JA, Output, NewInputs, Args, - LinkingOutput); + gnutools::Assembler::ConstructJob(C, JA, Output, NewInputs, Args, + LinkingOutput); } - -// This is quite similar to gnutools::link::ConstructJob with changes that +// This is quite similar to gnutools::Linker::ConstructJob with changes that // we use static by default, do not yet support sanitizers or LTO, and a few // others. Eventually we can support more of that and hopefully migrate back -// to gnutools::link. -void nacltools::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +// to gnutools::Linker. +void nacltools::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { const toolchains::NaCl_TC &ToolChain = static_cast<const toolchains::NaCl_TC &>(getToolChain()); @@ -8293,11 +8239,10 @@ void nacltools::Link::ConstructJob(Compilation &C, const JobAction &JA, AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs); - if (D.CCCIsCXX() && - !Args.hasArg(options::OPT_nostdlib) && + if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_nodefaultlibs)) { - bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) && - !IsStatic; + bool OnlyLibstdcxxStatic = + Args.hasArg(options::OPT_static_libstdcxx) && !IsStatic; if (OnlyLibstdcxxStatic) CmdArgs.push_back("-Bstatic"); ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); @@ -8314,8 +8259,7 @@ void nacltools::Link::ConstructJob(Compilation &C, const JobAction &JA, // NaCl's libc++ currently requires libpthread, so just always include it // in the group for C++. if (Args.hasArg(options::OPT_pthread) || - Args.hasArg(options::OPT_pthreads) || - D.CCCIsCXX()) { + Args.hasArg(options::OPT_pthreads) || D.CCCIsCXX()) { CmdArgs.push_back("-lpthread"); } @@ -8341,16 +8285,15 @@ void nacltools::Link::ConstructJob(Compilation &C, const JobAction &JA, } } - C.addCommand(llvm::make_unique<Command>(JA, *this, - ToolChain.Linker.c_str(), CmdArgs)); + C.addCommand( + llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs)); } - -void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void minix::Assembler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { claimNoWarnArgs(Args); ArgStringList CmdArgs; @@ -8366,11 +8309,11 @@ void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void minix::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void minix::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { const Driver &D = getToolChain().getDriver(); ArgStringList CmdArgs; @@ -8383,10 +8326,11 @@ void minix::Link::ConstructJob(Compilation &C, const JobAction &JA, if (!Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_nostartfiles)) { - CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o"))); - CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); - CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o"))); - CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o"))); + CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o"))); + CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o"))); + CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o"))); } Args.AddAllArgs(CmdArgs, options::OPT_L); @@ -8413,7 +8357,7 @@ void minix::Link::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-lCompilerRT-Generic"); CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib"); CmdArgs.push_back( - Args.MakeArgString(getToolChain().GetFilePath("crtend.o"))); + Args.MakeArgString(getToolChain().GetFilePath("crtend.o"))); } const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath()); @@ -8424,11 +8368,11 @@ void minix::Link::ConstructJob(Compilation &C, const JobAction &JA, // For now, DragonFly Assemble does just about the same as for // FreeBSD, but this may change soon. -void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void dragonfly::Assembler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { claimNoWarnArgs(Args); ArgStringList CmdArgs; @@ -8449,11 +8393,11 @@ void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void dragonfly::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { const Driver &D = getToolChain().getDriver(); ArgStringList CmdArgs; bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47"); @@ -8494,25 +8438,24 @@ void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA, !Args.hasArg(options::OPT_nostartfiles)) { if (!Args.hasArg(options::OPT_shared)) { if (Args.hasArg(options::OPT_pg)) - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("gcrt1.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("gcrt1.o"))); else { if (Args.hasArg(options::OPT_pie)) - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("Scrt1.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("Scrt1.o"))); else - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crt1.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crt1.o"))); } } - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crti.o"))); + CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtbeginS.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o"))); else - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtbegin.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o"))); } Args.AddAllArgs(CmdArgs, options::OPT_L); @@ -8581,13 +8524,12 @@ void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA, if (!Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_nostartfiles)) { if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtendS.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtendS.o"))); else - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtend.o"))); - CmdArgs.push_back(Args.MakeArgString( - getToolChain().GetFilePath("crtn.o"))); + CmdArgs.push_back( + Args.MakeArgString(getToolChain().GetFilePath("crtend.o"))); + CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o"))); } addProfileRT(getToolChain(), Args, CmdArgs); @@ -8616,18 +8558,18 @@ static std::string FindVisualStudioExecutable(const ToolChain &TC, return Exe; } -void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { ArgStringList CmdArgs; const ToolChain &TC = getToolChain(); assert((Output.isFilename() || Output.isNothing()) && "invalid output"); if (Output.isFilename()) - CmdArgs.push_back(Args.MakeArgString(std::string("-out:") + - Output.getFilename())); + CmdArgs.push_back( + Args.MakeArgString(std::string("-out:") + Output.getFilename())); if (!Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_nostartfiles) && !C.getDriver().IsCLMode()) @@ -8671,16 +8613,14 @@ void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA, if (Args.hasArg(options::OPT_g_Group)) CmdArgs.push_back("-debug"); - bool DLL = Args.hasArg(options::OPT__SLASH_LD, - options::OPT__SLASH_LDd, + bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd, options::OPT_shared); if (DLL) { CmdArgs.push_back(Args.MakeArgString("-dll")); SmallString<128> ImplibName(Output.getFilename()); llvm::sys::path::replace_extension(ImplibName, "lib"); - CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") + - ImplibName)); + CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") + ImplibName)); } if (TC.getSanitizerArgs().needsAsanRt()) { @@ -8688,8 +8628,7 @@ void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back(Args.MakeArgString("-incremental:no")); if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) { static const char *CompilerRTComponents[] = { - "asan_dynamic", - "asan_dynamic_runtime_thunk", + "asan_dynamic", "asan_dynamic_runtime_thunk", }; for (const auto &Component : CompilerRTComponents) CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component))); @@ -8697,11 +8636,11 @@ void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA, // to ensure proper SEH handling. CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor")); } else if (DLL) { - CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "asan_dll_thunk"))); + CmdArgs.push_back( + Args.MakeArgString(getCompilerRT(TC, "asan_dll_thunk"))); } else { static const char *CompilerRTComponents[] = { - "asan", - "asan_cxx", + "asan", "asan_cxx", }; for (const auto &Component : CompilerRTComponents) CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component))); @@ -8760,21 +8699,21 @@ void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void visualstudio::Compiler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput)); } -std::unique_ptr<Command> visualstudio::Compile::GetCommand( +std::unique_ptr<Command> visualstudio::Compiler::GetCommand( Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const ArgList &Args, const char *LinkingOutput) const { ArgStringList CmdArgs; CmdArgs.push_back("/nologo"); - CmdArgs.push_back("/c"); // Compile only. + CmdArgs.push_back("/c"); // Compile only. CmdArgs.push_back("/W0"); // No warnings. // The goal is to be able to invoke this tool correctly based on @@ -8832,7 +8771,6 @@ std::unique_ptr<Command> visualstudio::Compile::GetCommand( options::OPT__SLASH_MT, options::OPT__SLASH_MTd)) A->render(Args, CmdArgs); - // Input filename. assert(Inputs.size() == 1); const InputInfo &II = Inputs[0]; @@ -8845,8 +8783,8 @@ std::unique_ptr<Command> visualstudio::Compile::GetCommand( // Output filename. assert(Output.getType() == types::TY_Object); - const char *Fo = Args.MakeArgString(std::string("/Fo") + - Output.getFilename()); + const char *Fo = + Args.MakeArgString(std::string("/Fo") + Output.getFilename()); CmdArgs.push_back(Fo); const Driver &D = getToolChain().getDriver(); @@ -8856,15 +8794,220 @@ std::unique_ptr<Command> visualstudio::Compile::GetCommand( CmdArgs); } +/// MinGW Tools +void MinGW::Assembler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { + claimNoWarnArgs(Args); + ArgStringList CmdArgs; + + if (getToolChain().getArch() == llvm::Triple::x86) { + CmdArgs.push_back("--32"); + } else if (getToolChain().getArch() == llvm::Triple::x86_64) { + CmdArgs.push_back("--64"); + } + + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); + + CmdArgs.push_back("-o"); + CmdArgs.push_back(Output.getFilename()); + + for (const auto &II : Inputs) + CmdArgs.push_back(II.getFilename()); + + const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as")); + C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); + + if (Args.hasArg(options::OPT_gsplit_dwarf)) + SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, + SplitDebugName(Args, Inputs[0])); +} + +void MinGW::Linker::AddLibGCC(const ArgList &Args, + ArgStringList &CmdArgs) const { + if (Args.hasArg(options::OPT_mthreads)) + CmdArgs.push_back("-lmingwthrd"); + CmdArgs.push_back("-lmingw32"); + if (Args.hasArg(options::OPT_shared) || + Args.hasArg(options::OPT_shared_libgcc) || + !Args.hasArg(options::OPT_static_libgcc)) { + CmdArgs.push_back("-lgcc_s"); + CmdArgs.push_back("-lgcc"); + } else { + CmdArgs.push_back("-lgcc"); + CmdArgs.push_back("-lgcc_eh"); + } + CmdArgs.push_back("-lmoldname"); + CmdArgs.push_back("-lmingwex"); + CmdArgs.push_back("-lmsvcrt"); +} + +void MinGW::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { + const ToolChain &TC = getToolChain(); + const Driver &D = TC.getDriver(); + // const SanitizerArgs &Sanitize = TC.getSanitizerArgs(); + + ArgStringList CmdArgs; + + // Silence warning for "clang -g foo.o -o foo" + Args.ClaimAllArgs(options::OPT_g_Group); + // and "clang -emit-llvm foo.o -o foo" + Args.ClaimAllArgs(options::OPT_emit_llvm); + // and for "clang -w foo.o -o foo". Other warning options are already + // handled somewhere else. + Args.ClaimAllArgs(options::OPT_w); + + if (!D.SysRoot.empty()) + CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); + + if (Args.hasArg(options::OPT_s)) + CmdArgs.push_back("-s"); + + CmdArgs.push_back("-m"); + if (TC.getArch() == llvm::Triple::x86) + CmdArgs.push_back("i386pe"); + if (TC.getArch() == llvm::Triple::x86_64) + CmdArgs.push_back("i386pep"); + + if (Args.hasArg(options::OPT_mwindows)) { + CmdArgs.push_back("--subsystem"); + CmdArgs.push_back("windows"); + } else if (Args.hasArg(options::OPT_mconsole)) { + CmdArgs.push_back("--subsystem"); + CmdArgs.push_back("console"); + } + + if (Args.hasArg(options::OPT_static)) + CmdArgs.push_back("-Bstatic"); + else { + if (Args.hasArg(options::OPT_mdll)) + CmdArgs.push_back("--dll"); + else if (Args.hasArg(options::OPT_shared)) + CmdArgs.push_back("--shared"); + CmdArgs.push_back("-Bdynamic"); + if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) { + CmdArgs.push_back("-e"); + if (TC.getArch() == llvm::Triple::x86) + CmdArgs.push_back("_DllMainCRTStartup@12"); + else + CmdArgs.push_back("DllMainCRTStartup"); + CmdArgs.push_back("--enable-auto-image-base"); + } + } + + CmdArgs.push_back("-o"); + CmdArgs.push_back(Output.getFilename()); + + Args.AddAllArgs(CmdArgs, options::OPT_e); + // FIXME: add -N, -n flags + Args.AddLastArg(CmdArgs, options::OPT_r); + Args.AddLastArg(CmdArgs, options::OPT_s); + Args.AddLastArg(CmdArgs, options::OPT_t); + Args.AddAllArgs(CmdArgs, options::OPT_u_Group); + Args.AddLastArg(CmdArgs, options::OPT_Z_Flag); + + if (!Args.hasArg(options::OPT_nostdlib) && + !Args.hasArg(options::OPT_nostartfiles)) { + if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) { + CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("dllcrt2.o"))); + } else { + if (Args.hasArg(options::OPT_municode)) + CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2u.o"))); + else + CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2.o"))); + } + if (Args.hasArg(options::OPT_pg)) + CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("gcrt2.o"))); + CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o"))); + } + + Args.AddAllArgs(CmdArgs, options::OPT_L); + const ToolChain::path_list Paths = TC.getFilePaths(); + for (const auto &Path : Paths) + CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path)); + + AddLinkerInputs(TC, Inputs, Args, CmdArgs); + + // TODO: Add ASan stuff here + + // TODO: Add profile stuff here + + if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) && + !Args.hasArg(options::OPT_nodefaultlibs)) { + bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) && + !Args.hasArg(options::OPT_static); + if (OnlyLibstdcxxStatic) + CmdArgs.push_back("-Bstatic"); + TC.AddCXXStdlibLibArgs(Args, CmdArgs); + if (OnlyLibstdcxxStatic) + CmdArgs.push_back("-Bdynamic"); + } + + if (!Args.hasArg(options::OPT_nostdlib)) { + if (!Args.hasArg(options::OPT_nodefaultlibs)) { + if (Args.hasArg(options::OPT_static)) + CmdArgs.push_back("--start-group"); + + if (Args.hasArg(options::OPT_fstack_protector) || + Args.hasArg(options::OPT_fstack_protector_strong) || + Args.hasArg(options::OPT_fstack_protector_all)) { + CmdArgs.push_back("-lssp_nonshared"); + CmdArgs.push_back("-lssp"); + } + if (Args.hasArg(options::OPT_fopenmp)) + CmdArgs.push_back("-lgomp"); + + AddLibGCC(Args, CmdArgs); + + if (Args.hasArg(options::OPT_pg)) + CmdArgs.push_back("-lgmon"); + + // FIXME: what to do about pthreads library? + // Currently required for OpenMP and posix-threading libgcc, + // does not exists in mingw.org. + //CmdArgs.push_back("-lpthread"); + + // add system libraries + if (Args.hasArg(options::OPT_mwindows)) { + CmdArgs.push_back("-lgdi32"); + CmdArgs.push_back("-lcomdlg32"); + } + CmdArgs.push_back("-ladvapi32"); + CmdArgs.push_back("-lshell32"); + CmdArgs.push_back("-luser32"); + CmdArgs.push_back("-lkernel32"); + + if (Args.hasArg(options::OPT_static)) + CmdArgs.push_back("--end-group"); + else + AddLibGCC(Args, CmdArgs); + } + + if (!Args.hasArg(options::OPT_nostartfiles)) { + // Add crtfastmath.o if available and fast math is enabled. + TC.AddFastMathRuntimeIfAvailable(Args, CmdArgs); + + CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o"))); + } + } + const char *Exec = Args.MakeArgString(TC.GetProgramPath("ld")); + C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); +} /// XCore Tools // We pass assemble and link construction to the xcc tool. -void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void XCore::Assembler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { claimNoWarnArgs(Args); ArgStringList CmdArgs; @@ -8884,8 +9027,7 @@ void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA, false)) CmdArgs.push_back("-fverbose-asm"); - Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, - options::OPT_Xassembler); + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); for (const auto &II : Inputs) CmdArgs.push_back(II.getFilename()); @@ -8894,11 +9036,11 @@ void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void XCore::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { ArgStringList CmdArgs; if (Output.isFilename()) { @@ -8920,11 +9062,11 @@ void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void CrossWindows::Assemble::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void CrossWindows::Assembler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { claimNoWarnArgs(Args); const auto &TC = static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain()); @@ -8932,7 +9074,8 @@ void CrossWindows::Assemble::ConstructJob(Compilation &C, const JobAction &JA, const char *Exec; switch (TC.getArch()) { - default: llvm_unreachable("unsupported architecture"); + default: + llvm_unreachable("unsupported architecture"); case llvm::Triple::arm: case llvm::Triple::thumb: break; @@ -8958,11 +9101,11 @@ void CrossWindows::Assemble::ConstructJob(Compilation &C, const JobAction &JA, C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs)); } -void CrossWindows::Link::ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - const char *LinkingOutput) const { +void CrossWindows::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { const auto &TC = static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain()); const llvm::Triple &T = TC.getTriple(); @@ -8991,7 +9134,8 @@ void CrossWindows::Link::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-m"); switch (TC.getArch()) { - default: llvm_unreachable("unsupported architecture"); + default: + llvm_unreachable("unsupported architecture"); case llvm::Triple::arm: case llvm::Triple::thumb: // FIXME: this is incorrect for WinCE @@ -9008,7 +9152,8 @@ void CrossWindows::Link::ConstructJob(Compilation &C, const JobAction &JA, if (Args.hasArg(options::OPT_shared)) { switch (T.getArch()) { - default: llvm_unreachable("unsupported architecture"); + default: + llvm_unreachable("unsupported architecture"); case llvm::Triple::arm: case llvm::Triple::thumb: case llvm::Triple::x86_64: @@ -9098,11 +9243,11 @@ 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 { +void tools::SHAVE::Compiler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { ArgStringList CmdArgs; @@ -9143,12 +9288,11 @@ void tools::SHAVE::Compile::ConstructJob(Compilation &C, const JobAction &JA, 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 { +void tools::SHAVE::Assembler::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); diff --git a/lib/Driver/Tools.h b/lib/Driver/Tools.h index 753f542622fe..52ab731cbc46 100644 --- a/lib/Driver/Tools.h +++ b/lib/Driver/Tools.h @@ -32,11 +32,14 @@ namespace toolchains { namespace tools { namespace visualstudio { - class Compile; +class Compiler; } using llvm::opt::ArgStringList; +SmallString<128> getCompilerRT(const ToolChain &TC, StringRef Component, + bool Shared = false); + /// \brief Clang compiler tool. class LLVM_LIBRARY_VISIBILITY Clang : public Tool { public: @@ -86,11 +89,14 @@ using llvm::opt::ArgStringList; void AddClangCLArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const; - visualstudio::Compile *getCLFallback() const; + visualstudio::Compiler *getCLFallback() const; - mutable std::unique_ptr<visualstudio::Compile> CLFallback; + mutable std::unique_ptr<visualstudio::Compiler> CLFallback; public: + // CAUTION! The first constructor argument ("clang") is not arbitrary, + // as it is for other tools. Some operations on a Tool actually test + // whether that tool is Clang based on the Tool's Name as a string. Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC, RF_Full) {} bool hasGoodDiagnostics() const override { return true; } @@ -124,7 +130,7 @@ using llvm::opt::ArgStringList; /// \brief Base class for all GNU tools that provide the same behavior when /// it comes to response files support - class GnuTool : public Tool { + class LLVM_LIBRARY_VISIBILITY GnuTool : public Tool { virtual void anchor(); public: @@ -148,14 +154,14 @@ namespace gcc { /// RenderExtraToolArgs - Render any arguments necessary to force /// the particular tool mode. virtual void - RenderExtraToolArgs(const JobAction &JA, - llvm::opt::ArgStringList &CmdArgs) const = 0; + RenderExtraToolArgs(const JobAction &JA, + llvm::opt::ArgStringList &CmdArgs) const = 0; }; - class LLVM_LIBRARY_VISIBILITY Preprocess : public Common { + class LLVM_LIBRARY_VISIBILITY Preprocessor : public Common { public: - Preprocess(const ToolChain &TC) : Common("gcc::Preprocess", - "gcc preprocessor", TC) {} + Preprocessor(const ToolChain &TC) + : Common("gcc::Preprocessor", "gcc preprocessor", TC) {} bool hasGoodDiagnostics() const override { return true; } bool hasIntegratedCPP() const override { return false; } @@ -164,10 +170,10 @@ namespace gcc { llvm::opt::ArgStringList &CmdArgs) const override; }; - class LLVM_LIBRARY_VISIBILITY Compile : public Common { + class LLVM_LIBRARY_VISIBILITY Compiler : public Common { public: - Compile(const ToolChain &TC) : Common("gcc::Compile", - "gcc frontend", TC) {} + Compiler(const ToolChain &TC) + : Common("gcc::Compiler", "gcc frontend", TC) {} bool hasGoodDiagnostics() const override { return true; } bool hasIntegratedCPP() const override { return true; } @@ -176,10 +182,10 @@ namespace gcc { llvm::opt::ArgStringList &CmdArgs) const override; }; - class LLVM_LIBRARY_VISIBILITY Link : public Common { + class LLVM_LIBRARY_VISIBILITY Linker : public Common { public: - Link(const ToolChain &TC) : Common("gcc::Link", - "linker (via gcc)", TC) {} + Linker(const ToolChain &TC) + : Common("gcc::Linker", "linker (via gcc)", TC) {} bool hasIntegratedCPP() const override { return false; } bool isLinkJob() const override { return true; } @@ -190,14 +196,15 @@ namespace gcc { } // end namespace gcc namespace hexagon { - // For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile and Compile. - // We simply use "clang -cc1" for those actions. - class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool { - public: - Assemble(const ToolChain &TC) : GnuTool("hexagon::Assemble", - "hexagon-as", TC) {} +// For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile +// and Compile. +// We simply use "clang -cc1" for those actions. +class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { +public: + Assembler(const ToolChain &TC) + : GnuTool("hexagon::Assembler", "hexagon-as", TC) {} - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return false; } void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const; @@ -205,14 +212,13 @@ namespace hexagon { const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override; - }; +}; - class LLVM_LIBRARY_VISIBILITY Link : public GnuTool { - public: - Link(const ToolChain &TC) : GnuTool("hexagon::Link", - "hexagon-ld", TC) {} +class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { +public: + Linker(const ToolChain &TC) : GnuTool("hexagon::Linker", "hexagon-ld", TC) {} - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return false; } bool isLinkJob() const override { return true; } virtual void RenderExtraToolArgs(const JobAction &JA, @@ -258,11 +264,11 @@ namespace ppc { bool hasPPCAbiArg(const llvm::opt::ArgList &Args, const char *Value); } - /// cloudabi -- Directly call GNU Binutils linker +/// cloudabi -- Directly call GNU Binutils linker namespace cloudabi { -class LLVM_LIBRARY_VISIBILITY Link : public GnuTool { +class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { public: - Link(const ToolChain &TC) : GnuTool("cloudabi::Link", "linker", TC) {} + Linker(const ToolChain &TC) : GnuTool("cloudabi::Linker", "linker", TC) {} bool hasIntegratedCPP() const override { return false; } bool isLinkJob() const override { return true; } @@ -289,19 +295,19 @@ namespace darwin { } public: - MachOTool( - const char *Name, const char *ShortName, const ToolChain &TC, - ResponseFileSupport ResponseSupport = RF_None, - llvm::sys::WindowsEncodingMethod ResponseEncoding = llvm::sys::WEM_UTF8, - const char *ResponseFlag = "@") - : Tool(Name, ShortName, TC, ResponseSupport, ResponseEncoding, - ResponseFlag) {} + MachOTool( + const char *Name, const char *ShortName, const ToolChain &TC, + ResponseFileSupport ResponseSupport = RF_None, + llvm::sys::WindowsEncodingMethod ResponseEncoding = llvm::sys::WEM_UTF8, + const char *ResponseFlag = "@") + : Tool(Name, ShortName, TC, ResponseSupport, ResponseEncoding, + ResponseFlag) {} }; - class LLVM_LIBRARY_VISIBILITY Assemble : public MachOTool { + class LLVM_LIBRARY_VISIBILITY Assembler : public MachOTool { public: - Assemble(const ToolChain &TC) : MachOTool("darwin::Assemble", - "assembler", TC) {} + Assembler(const ToolChain &TC) + : MachOTool("darwin::Assembler", "assembler", TC) {} bool hasIntegratedCPP() const override { return false; } @@ -311,16 +317,16 @@ namespace darwin { const char *LinkingOutput) const override; }; - class LLVM_LIBRARY_VISIBILITY Link : public MachOTool { + class LLVM_LIBRARY_VISIBILITY Linker : public MachOTool { bool NeedsTempPath(const InputInfoList &Inputs) const; void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const InputInfoList &Inputs) const; public: - Link(const ToolChain &TC) : MachOTool("darwin::Link", "linker", TC, - RF_FileList, llvm::sys::WEM_UTF8, - "-filelist") {} + Linker(const ToolChain &TC) + : MachOTool("darwin::Linker", "linker", TC, RF_FileList, + llvm::sys::WEM_UTF8, "-filelist") {} bool hasIntegratedCPP() const override { return false; } bool isLinkJob() const override { return true; } @@ -373,27 +379,26 @@ namespace darwin { } - /// openbsd -- Directly call GNU Binutils assembler and linker +/// openbsd -- Directly call GNU Binutils assembler and linker namespace openbsd { - class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool { - public: - Assemble(const ToolChain &TC) : GnuTool("openbsd::Assemble", "assembler", - TC) {} +class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { +public: + Assembler(const ToolChain &TC) + : GnuTool("openbsd::Assembler", "assembler", TC) {} - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return false; } - 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 Link : public GnuTool { - public: - Link(const ToolChain &TC) : GnuTool("openbsd::Link", "linker", TC) {} + 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 Linker : public GnuTool { +public: + Linker(const ToolChain &TC) : GnuTool("openbsd::Linker", "linker", TC) {} - bool hasIntegratedCPP() const override { return false; } - bool isLinkJob() const override { return true; } + bool hasIntegratedCPP() const override { return false; } + bool isLinkJob() const override { return true; } void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, @@ -402,26 +407,26 @@ namespace openbsd { }; } // end namespace openbsd - /// bitrig -- Directly call GNU Binutils assembler and linker +/// bitrig -- Directly call GNU Binutils assembler and linker namespace bitrig { - class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool { - public: - Assemble(const ToolChain &TC) : GnuTool("bitrig::Assemble", "assembler", - TC) {} +class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { +public: + Assembler(const ToolChain &TC) + : GnuTool("bitrig::Assembler", "assembler", TC) {} - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return false; } - 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 Link : public GnuTool { - public: - Link(const ToolChain &TC) : GnuTool("bitrig::Link", "linker", TC) {} + 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 Linker : public GnuTool { +public: + Linker(const ToolChain &TC) : GnuTool("bitrig::Linker", "linker", TC) {} - bool hasIntegratedCPP() const override { return false; } - bool isLinkJob() const override { return true; } + bool hasIntegratedCPP() const override { return false; } + bool isLinkJob() const override { return true; } void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, @@ -430,26 +435,26 @@ namespace bitrig { }; } // end namespace bitrig - /// freebsd -- Directly call GNU Binutils assembler and linker +/// freebsd -- Directly call GNU Binutils assembler and linker namespace freebsd { - class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool { - public: - Assemble(const ToolChain &TC) : GnuTool("freebsd::Assemble", "assembler", - TC) {} +class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { +public: + Assembler(const ToolChain &TC) + : GnuTool("freebsd::Assembler", "assembler", TC) {} - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return false; } - 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 Link : public GnuTool { - public: - Link(const ToolChain &TC) : GnuTool("freebsd::Link", "linker", TC) {} + 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 Linker : public GnuTool { +public: + Linker(const ToolChain &TC) : GnuTool("freebsd::Linker", "linker", TC) {} - bool hasIntegratedCPP() const override { return false; } - bool isLinkJob() const override { return true; } + bool hasIntegratedCPP() const override { return false; } + bool isLinkJob() const override { return true; } void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, @@ -458,29 +463,28 @@ namespace freebsd { }; } // end namespace freebsd - /// netbsd -- Directly call GNU Binutils assembler and linker +/// netbsd -- Directly call GNU Binutils assembler and linker namespace netbsd { - class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool { +class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { - public: - Assemble(const ToolChain &TC) - : GnuTool("netbsd::Assemble", "assembler", TC) {} +public: + Assembler(const ToolChain &TC) + : GnuTool("netbsd::Assembler", "assembler", TC) {} - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return false; } - 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 Link : public GnuTool { + 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 Linker : public GnuTool { - public: - Link(const ToolChain &TC) - : GnuTool("netbsd::Link", "linker", TC) {} +public: + Linker(const ToolChain &TC) : GnuTool("netbsd::Linker", "linker", TC) {} - bool hasIntegratedCPP() const override { return false; } - bool isLinkJob() const override { return true; } + bool hasIntegratedCPP() const override { return false; } + bool isLinkJob() const override { return true; } void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, @@ -489,26 +493,25 @@ namespace netbsd { }; } // end namespace netbsd - /// Directly call GNU Binutils' assembler and linker. +/// Directly call GNU Binutils' assembler and linker. namespace gnutools { - class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool { - public: - Assemble(const ToolChain &TC) : GnuTool("GNU::Assemble", "assembler", TC) {} +class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { +public: + Assembler(const ToolChain &TC) : GnuTool("GNU::Assembler", "assembler", TC) {} - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return false; } - 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 Link : public GnuTool { - public: - Link(const ToolChain &TC) : GnuTool("GNU::Link", "linker", TC) {} + 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 Linker : public GnuTool { +public: + Linker(const ToolChain &TC) : GnuTool("GNU::Linker", "linker", TC) {} - bool hasIntegratedCPP() const override { return false; } - bool isLinkJob() const override { return true; } + bool hasIntegratedCPP() const override { return false; } + bool isLinkJob() const override { return true; } void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, @@ -516,22 +519,21 @@ namespace gnutools { const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override; }; -} + } -namespace nacltools { - class LLVM_LIBRARY_VISIBILITY AssembleARM : public gnutools::Assemble { + namespace nacltools { + class LLVM_LIBRARY_VISIBILITY AssemblerARM : public gnutools::Assembler { public: - AssembleARM(const ToolChain &TC) : gnutools::Assemble(TC) {} + AssemblerARM(const ToolChain &TC) : gnutools::Assembler(TC) {} void ConstructJob(Compilation &C, const JobAction &JA, - const InputInfo &Output, - const InputInfoList &Inputs, + const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override; }; - class LLVM_LIBRARY_VISIBILITY Link : public Tool { + class LLVM_LIBRARY_VISIBILITY Linker : public Tool { public: - Link(const ToolChain &TC) : Tool("NaCl::Link", "linker", TC) {} + Linker(const ToolChain &TC) : Tool("NaCl::Linker", "linker", TC) {} bool hasIntegratedCPP() const override { return false; } bool isLinkJob() const override { return true; } @@ -544,27 +546,26 @@ namespace nacltools { }; } - /// minix -- Directly call GNU Binutils assembler and linker +/// minix -- Directly call GNU Binutils assembler and linker namespace minix { - class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool { - public: - Assemble(const ToolChain &TC) : GnuTool("minix::Assemble", "assembler", - TC) {} +class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { +public: + Assembler(const ToolChain &TC) + : GnuTool("minix::Assembler", "assembler", TC) {} - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return false; } - 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 Link : public GnuTool { - public: - Link(const ToolChain &TC) : GnuTool("minix::Link", "linker", TC) {} + 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 Linker : public GnuTool { +public: + Linker(const ToolChain &TC) : GnuTool("minix::Linker", "linker", TC) {} - bool hasIntegratedCPP() const override { return false; } - bool isLinkJob() const override { return true; } + bool hasIntegratedCPP() const override { return false; } + bool isLinkJob() const override { return true; } void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, @@ -574,26 +575,26 @@ namespace minix { }; } // end namespace minix - /// solaris -- Directly call Solaris assembler and linker +/// solaris -- Directly call Solaris assembler and linker namespace solaris { - class LLVM_LIBRARY_VISIBILITY Assemble : public Tool { - public: - Assemble(const ToolChain &TC) : Tool("solaris::Assemble", "assembler", - TC) {} +class LLVM_LIBRARY_VISIBILITY Assembler : public Tool { +public: + Assembler(const ToolChain &TC) + : Tool("solaris::Assembler", "assembler", TC) {} - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return false; } - 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 Link : public Tool { - public: - Link(const ToolChain &TC) : Tool("solaris::Link", "linker", TC) {} + 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 Linker : public Tool { +public: + Linker(const ToolChain &TC) : Tool("solaris::Linker", "linker", TC) {} - bool hasIntegratedCPP() const override { return false; } - bool isLinkJob() const override { return true; } + bool hasIntegratedCPP() const override { return false; } + bool isLinkJob() const override { return true; } void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, @@ -602,26 +603,26 @@ namespace solaris { }; } // end namespace solaris - /// dragonfly -- Directly call GNU Binutils assembler and linker +/// dragonfly -- Directly call GNU Binutils assembler and linker namespace dragonfly { - class LLVM_LIBRARY_VISIBILITY Assemble : public GnuTool { - public: - Assemble(const ToolChain &TC) : GnuTool("dragonfly::Assemble", "assembler", - TC) {} +class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { +public: + Assembler(const ToolChain &TC) + : GnuTool("dragonfly::Assembler", "assembler", TC) {} - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return false; } - 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 Link : public GnuTool { - public: - Link(const ToolChain &TC) : GnuTool("dragonfly::Link", "linker", TC) {} + 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 Linker : public GnuTool { +public: + Linker(const ToolChain &TC) : GnuTool("dragonfly::Linker", "linker", TC) {} - bool hasIntegratedCPP() const override { return false; } - bool isLinkJob() const override { return true; } + bool hasIntegratedCPP() const override { return false; } + bool isLinkJob() const override { return true; } void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, @@ -633,30 +634,31 @@ namespace dragonfly { /// Visual studio tools. namespace visualstudio { - VersionTuple getMSVCVersion(const Driver *D, const llvm::Triple &Triple, - const llvm::opt::ArgList &Args, - bool IsWindowsMSVC); +VersionTuple getMSVCVersion(const Driver *D, const llvm::Triple &Triple, + const llvm::opt::ArgList &Args, bool IsWindowsMSVC); - class LLVM_LIBRARY_VISIBILITY Link : public Tool { - public: - Link(const ToolChain &TC) : Tool("visualstudio::Link", "linker", TC, - RF_Full, llvm::sys::WEM_UTF16) {} +class LLVM_LIBRARY_VISIBILITY Linker : public Tool { +public: + Linker(const ToolChain &TC) + : Tool("visualstudio::Linker", "linker", TC, RF_Full, + llvm::sys::WEM_UTF16) {} - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return false; } bool isLinkJob() 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 Compile : public Tool { - public: - Compile(const ToolChain &TC) : Tool("visualstudio::Compile", "compiler", TC, - RF_Full, llvm::sys::WEM_UTF16) {} +class LLVM_LIBRARY_VISIBILITY Compiler : public Tool { +public: + Compiler(const ToolChain &TC) + : Tool("visualstudio::Compiler", "compiler", TC, RF_Full, + llvm::sys::WEM_UTF16) {} - bool hasIntegratedAssembler() const override { return true; } + bool hasIntegratedAssembler() const override { return true; } bool hasIntegratedCPP() const override { return true; } bool isLinkJob() const override { return false; } @@ -673,58 +675,90 @@ namespace visualstudio { }; } // end namespace visualstudio +/// MinGW -- Directly call GNU Binutils assembler and linker +namespace MinGW { +class LLVM_LIBRARY_VISIBILITY Assembler : public Tool { +public: + Assembler(const ToolChain &TC) : Tool("MinGW::Assemble", "assembler", TC) {} + + bool hasIntegratedCPP() const override { return false; } + + 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 Linker : public Tool { +public: + Linker(const ToolChain &TC) : Tool("MinGW::Linker", "linker", TC) {} + + bool hasIntegratedCPP() const override { return false; } + bool isLinkJob() 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; + +private: + void AddLibGCC(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) const; +}; +} // end namespace MinGW + namespace arm { StringRef getARMFloatABI(const Driver &D, const llvm::opt::ArgList &Args, const llvm::Triple &Triple); } namespace XCore { - // For XCore, we do not need to instantiate tools for PreProcess, PreCompile and Compile. - // We simply use "clang -cc1" for those actions. - class LLVM_LIBRARY_VISIBILITY Assemble : public Tool { - public: - Assemble(const ToolChain &TC) : Tool("XCore::Assemble", - "XCore-as", TC) {} +// For XCore, we do not need to instantiate tools for PreProcess, PreCompile and +// Compile. +// We simply use "clang -cc1" for those actions. +class LLVM_LIBRARY_VISIBILITY Assembler : public Tool { +public: + Assembler(const ToolChain &TC) : Tool("XCore::Assembler", "XCore-as", TC) {} - bool hasIntegratedCPP() const override { return false; } + bool hasIntegratedCPP() const override { return false; } + 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 Linker : public Tool { +public: + Linker(const ToolChain &TC) : Tool("XCore::Linker", "XCore-ld", TC) {} + + bool hasIntegratedCPP() const override { return false; } + bool isLinkJob() 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; }; + } // end namespace XCore. - class LLVM_LIBRARY_VISIBILITY Link : public Tool { + namespace CrossWindows { + class LLVM_LIBRARY_VISIBILITY Assembler : public Tool { public: - Link(const ToolChain &TC) : Tool("XCore::Link", - "XCore-ld", TC) {} + Assembler(const ToolChain &TC) + : Tool("CrossWindows::Assembler", "as", TC) {} bool hasIntegratedCPP() const override { return false; } - bool isLinkJob() 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; }; -} // end namespace XCore. - -namespace CrossWindows { -class LLVM_LIBRARY_VISIBILITY Assemble : public Tool { -public: - Assemble(const ToolChain &TC) : Tool("CrossWindows::Assemble", "as", TC) { } - - bool hasIntegratedCPP() const override { return false; } - 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 Link : public Tool { -public: - Link(const ToolChain &TC) : Tool("CrossWindows::Link", "ld", TC, RF_Full) {} + class LLVM_LIBRARY_VISIBILITY Linker : public Tool { + public: + Linker(const ToolChain &TC) + : Tool("CrossWindows::Linker", "ld", TC, RF_Full) {} - bool hasIntegratedCPP() const override { return false; } - bool isLinkJob() const override { return true; } + bool hasIntegratedCPP() const override { return false; } + bool isLinkJob() const override { return true; } void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, @@ -735,9 +769,9 @@ public: /// SHAVE tools -- Directly call moviCompile and moviAsm namespace SHAVE { -class LLVM_LIBRARY_VISIBILITY Compile : public Tool { +class LLVM_LIBRARY_VISIBILITY Compiler : public Tool { public: - Compile(const ToolChain &TC) : Tool("moviCompile", "movicompile", TC) {} + Compiler(const ToolChain &TC) : Tool("moviCompile", "movicompile", TC) {} bool hasIntegratedCPP() const override { return true; } @@ -747,9 +781,9 @@ public: const char *LinkingOutput) const override; }; -class LLVM_LIBRARY_VISIBILITY Assemble : public Tool { +class LLVM_LIBRARY_VISIBILITY Assembler : public Tool { public: - Assemble(const ToolChain &TC) : Tool("moviAsm", "moviAsm", TC) {} + Assembler(const ToolChain &TC) : Tool("moviAsm", "moviAsm", TC) {} bool hasIntegratedCPP() const override { return false; } // not sure. diff --git a/lib/Format/ContinuationIndenter.cpp b/lib/Format/ContinuationIndenter.cpp index 2357abd7abdb..ed01d689c590 100644 --- a/lib/Format/ContinuationIndenter.cpp +++ b/lib/Format/ContinuationIndenter.cpp @@ -126,7 +126,8 @@ bool ContinuationIndenter::canBreak(const LineState &State) { // Don't break after very short return types (e.g. "void") as that is often // unexpected. if (Current.is(TT_FunctionDeclarationName) && - !Style.AlwaysBreakAfterDefinitionReturnType && State.Column < 6) + Style.AlwaysBreakAfterDefinitionReturnType == FormatStyle::DRTBS_None && + State.Column < 6) return false; return !State.Stack.back().NoLineBreak; @@ -815,7 +816,7 @@ void ContinuationIndenter::moveStatePastFakeLParens(LineState &State, // ParameterToInnerFunction)); if (*I > prec::Unknown) NewParenState.LastSpace = std::max(NewParenState.LastSpace, State.Column); - if (*I != prec::Conditional) + if (*I != prec::Conditional && !Current.is(TT_UnaryOperator)) NewParenState.StartOfFunctionCall = State.Column; // Always indent conditional expressions. Never indent expression where diff --git a/lib/Format/Format.cpp b/lib/Format/Format.cpp index 0feeaa007f3e..2bbe4c63d156 100644 --- a/lib/Format/Format.cpp +++ b/lib/Format/Format.cpp @@ -99,6 +99,18 @@ template <> struct ScalarEnumerationTraits<FormatStyle::BraceBreakingStyle> { } }; +template <> struct ScalarEnumerationTraits<FormatStyle::DefinitionReturnTypeBreakingStyle> { + static void enumeration(IO &IO, FormatStyle::DefinitionReturnTypeBreakingStyle &Value) { + IO.enumCase(Value, "None", FormatStyle::DRTBS_None); + IO.enumCase(Value, "All", FormatStyle::DRTBS_All); + IO.enumCase(Value, "TopLevel", FormatStyle::DRTBS_TopLevel); + + // For backward compatibility. + IO.enumCase(Value, "false", FormatStyle::DRTBS_None); + IO.enumCase(Value, "true", FormatStyle::DRTBS_All); + } +}; + template <> struct ScalarEnumerationTraits<FormatStyle::NamespaceIndentationKind> { static void enumeration(IO &IO, @@ -169,55 +181,70 @@ template <> struct MappingTraits<FormatStyle> { } } + // For backward compatibility. + if (!IO.outputting()) { + IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment); + IO.mapOptional("IndentFunctionDeclarationAfterType", + Style.IndentWrappedFunctionNames); + IO.mapOptional("PointerBindsToType", Style.PointerAlignment); + IO.mapOptional("SpaceAfterControlStatementKeyword", + Style.SpaceBeforeParens); + } + IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset); IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket); + IO.mapOptional("AlignConsecutiveAssignments", + Style.AlignConsecutiveAssignments); IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlinesLeft); IO.mapOptional("AlignOperands", Style.AlignOperands); IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments); - IO.mapOptional("AlignConsecutiveAssignments", - Style.AlignConsecutiveAssignments); IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine", Style.AllowAllParametersOfDeclarationOnNextLine); IO.mapOptional("AllowShortBlocksOnASingleLine", Style.AllowShortBlocksOnASingleLine); IO.mapOptional("AllowShortCaseLabelsOnASingleLine", Style.AllowShortCaseLabelsOnASingleLine); + IO.mapOptional("AllowShortFunctionsOnASingleLine", + Style.AllowShortFunctionsOnASingleLine); IO.mapOptional("AllowShortIfStatementsOnASingleLine", Style.AllowShortIfStatementsOnASingleLine); IO.mapOptional("AllowShortLoopsOnASingleLine", Style.AllowShortLoopsOnASingleLine); - IO.mapOptional("AllowShortFunctionsOnASingleLine", - Style.AllowShortFunctionsOnASingleLine); IO.mapOptional("AlwaysBreakAfterDefinitionReturnType", Style.AlwaysBreakAfterDefinitionReturnType); - IO.mapOptional("AlwaysBreakTemplateDeclarations", - Style.AlwaysBreakTemplateDeclarations); IO.mapOptional("AlwaysBreakBeforeMultilineStrings", Style.AlwaysBreakBeforeMultilineStrings); + IO.mapOptional("AlwaysBreakTemplateDeclarations", + Style.AlwaysBreakTemplateDeclarations); + IO.mapOptional("BinPackArguments", Style.BinPackArguments); + IO.mapOptional("BinPackParameters", Style.BinPackParameters); IO.mapOptional("BreakBeforeBinaryOperators", Style.BreakBeforeBinaryOperators); + IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces); IO.mapOptional("BreakBeforeTernaryOperators", Style.BreakBeforeTernaryOperators); IO.mapOptional("BreakConstructorInitializersBeforeComma", Style.BreakConstructorInitializersBeforeComma); - IO.mapOptional("BinPackParameters", Style.BinPackParameters); - IO.mapOptional("BinPackArguments", Style.BinPackArguments); IO.mapOptional("ColumnLimit", Style.ColumnLimit); + IO.mapOptional("CommentPragmas", Style.CommentPragmas); IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine", Style.ConstructorInitializerAllOnOneLineOrOnePerLine); IO.mapOptional("ConstructorInitializerIndentWidth", Style.ConstructorInitializerIndentWidth); + IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth); + IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle); IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment); + IO.mapOptional("DisableFormat", Style.DisableFormat); IO.mapOptional("ExperimentalAutoDetectBinPacking", Style.ExperimentalAutoDetectBinPacking); + IO.mapOptional("ForEachMacros", Style.ForEachMacros); IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels); + IO.mapOptional("IndentWidth", Style.IndentWidth); IO.mapOptional("IndentWrappedFunctionNames", Style.IndentWrappedFunctionNames); - IO.mapOptional("IndentFunctionDeclarationAfterType", - Style.IndentWrappedFunctionNames); - IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep); IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks", Style.KeepEmptyLinesAtTheStartOfBlocks); + IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep); IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation); IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth); IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty); @@ -226,45 +253,30 @@ template <> struct MappingTraits<FormatStyle> { IO.mapOptional("PenaltyBreakBeforeFirstCallParameter", Style.PenaltyBreakBeforeFirstCallParameter); IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment); - IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString); IO.mapOptional("PenaltyBreakFirstLessLess", Style.PenaltyBreakFirstLessLess); + IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString); IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter); IO.mapOptional("PenaltyReturnTypeOnItsOwnLine", Style.PenaltyReturnTypeOnItsOwnLine); IO.mapOptional("PointerAlignment", Style.PointerAlignment); + IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast); + IO.mapOptional("SpaceBeforeAssignmentOperators", + Style.SpaceBeforeAssignmentOperators); + IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens); + IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses); IO.mapOptional("SpacesBeforeTrailingComments", Style.SpacesBeforeTrailingComments); - IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle); - IO.mapOptional("Standard", Style.Standard); - IO.mapOptional("IndentWidth", Style.IndentWidth); - IO.mapOptional("TabWidth", Style.TabWidth); - IO.mapOptional("UseTab", Style.UseTab); - IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces); - IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses); - IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets); IO.mapOptional("SpacesInAngles", Style.SpacesInAngles); - IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses); - IO.mapOptional("SpacesInCStyleCastParentheses", - Style.SpacesInCStyleCastParentheses); - IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast); IO.mapOptional("SpacesInContainerLiterals", Style.SpacesInContainerLiterals); - IO.mapOptional("SpaceBeforeAssignmentOperators", - Style.SpaceBeforeAssignmentOperators); - IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth); - IO.mapOptional("CommentPragmas", Style.CommentPragmas); - IO.mapOptional("ForEachMacros", Style.ForEachMacros); - - // For backward compatibility. - if (!IO.outputting()) { - IO.mapOptional("SpaceAfterControlStatementKeyword", - Style.SpaceBeforeParens); - IO.mapOptional("PointerBindsToType", Style.PointerAlignment); - IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment); - } - IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens); - IO.mapOptional("DisableFormat", Style.DisableFormat); + IO.mapOptional("SpacesInCStyleCastParentheses", + Style.SpacesInCStyleCastParentheses); + IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses); + IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets); + IO.mapOptional("Standard", Style.Standard); + IO.mapOptional("TabWidth", Style.TabWidth); + IO.mapOptional("UseTab", Style.UseTab); } }; @@ -338,7 +350,7 @@ FormatStyle getLLVMStyle() { LLVMStyle.AllowShortCaseLabelsOnASingleLine = false; LLVMStyle.AllowShortIfStatementsOnASingleLine = false; LLVMStyle.AllowShortLoopsOnASingleLine = false; - LLVMStyle.AlwaysBreakAfterDefinitionReturnType = false; + LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None; LLVMStyle.AlwaysBreakBeforeMultilineStrings = false; LLVMStyle.AlwaysBreakTemplateDeclarations = false; LLVMStyle.BinPackParameters = true; @@ -462,15 +474,19 @@ FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) { FormatStyle getMozillaStyle() { FormatStyle MozillaStyle = getLLVMStyle(); MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false; + MozillaStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; + MozillaStyle.AlwaysBreakAfterDefinitionReturnType = + FormatStyle::DRTBS_TopLevel; + MozillaStyle.AlwaysBreakTemplateDeclarations = true; + MozillaStyle.BreakConstructorInitializersBeforeComma = true; + MozillaStyle.ConstructorInitializerIndentWidth = 2; + MozillaStyle.ContinuationIndentWidth = 2; MozillaStyle.Cpp11BracedListStyle = false; - MozillaStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true; - MozillaStyle.DerivePointerAlignment = true; MozillaStyle.IndentCaseLabels = true; MozillaStyle.ObjCSpaceAfterProperty = true; MozillaStyle.ObjCSpaceBeforeProtocolList = false; MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200; MozillaStyle.PointerAlignment = FormatStyle::PAS_Left; - MozillaStyle.Standard = FormatStyle::LS_Cpp03; return MozillaStyle; } @@ -496,7 +512,7 @@ FormatStyle getWebKitStyle() { FormatStyle getGNUStyle() { FormatStyle Style = getLLVMStyle(); - Style.AlwaysBreakAfterDefinitionReturnType = true; + Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; Style.BreakBeforeBraces = FormatStyle::BS_GNU; Style.BreakBeforeTernaryOperators = true; @@ -738,35 +754,62 @@ private: bool tryMergeJSRegexLiteral() { if (Tokens.size() < 2) return false; + + // If this is a string literal with a slash inside, compute the slash's + // offset and try to find the beginning of the regex literal. + // Also look at tok::unknown, as it can be an unterminated char literal. + size_t SlashInStringPos = StringRef::npos; + if (Tokens.back()->isOneOf(tok::string_literal, tok::char_constant, + tok::unknown)) { + // Start search from position 1 as otherwise, this is an unknown token + // for an unterminated /*-comment which is handled elsewhere. + SlashInStringPos = Tokens.back()->TokenText.find('/', 1); + if (SlashInStringPos == StringRef::npos) + return false; + } + // If a regex literal ends in "\//", this gets represented by an unknown // token "\" and a comment. bool MightEndWithEscapedSlash = Tokens.back()->is(tok::comment) && Tokens.back()->TokenText.startswith("//") && Tokens[Tokens.size() - 2]->TokenText == "\\"; - if (!MightEndWithEscapedSlash && + if (!MightEndWithEscapedSlash && SlashInStringPos == StringRef::npos && (Tokens.back()->isNot(tok::slash) || (Tokens[Tokens.size() - 2]->is(tok::unknown) && Tokens[Tokens.size() - 2]->TokenText == "\\"))) return false; + unsigned TokenCount = 0; - unsigned LastColumn = Tokens.back()->OriginalColumn; for (auto I = Tokens.rbegin() + 1, E = Tokens.rend(); I != E; ++I) { ++TokenCount; - if (I[0]->isOneOf(tok::slash, tok::slashequal) && I + 1 != E && - (I[1]->isOneOf(tok::l_paren, tok::semi, tok::l_brace, tok::r_brace, - tok::exclaim, tok::l_square, tok::colon, tok::comma, - tok::question, tok::kw_return) || - I[1]->isBinaryOperator())) { + auto Prev = I + 1; + while (Prev != E && Prev[0]->is(tok::comment)) + ++Prev; + if (I[0]->isOneOf(tok::slash, tok::slashequal) && + (Prev == E || + ((Prev[0]->isOneOf(tok::l_paren, tok::semi, tok::l_brace, + tok::r_brace, tok::exclaim, tok::l_square, + tok::colon, tok::comma, tok::question, + tok::kw_return) || + Prev[0]->isBinaryOperator())))) { + unsigned LastColumn = Tokens.back()->OriginalColumn; + SourceLocation Loc = Tokens.back()->Tok.getLocation(); if (MightEndWithEscapedSlash) { // This regex literal ends in '\//'. Skip past the '//' of the last // token and re-start lexing from there. - SourceLocation Loc = Tokens.back()->Tok.getLocation(); resetLexer(SourceMgr.getFileOffset(Loc) + 2); + } else if (SlashInStringPos != StringRef::npos) { + // This regex literal ends in a string_literal with a slash inside. + // Calculate end column and reset lexer appropriately. + resetLexer(SourceMgr.getFileOffset(Loc) + SlashInStringPos + 1); + LastColumn += SlashInStringPos; } Tokens.resize(Tokens.size() - TokenCount); Tokens.back()->Tok.setKind(tok::unknown); Tokens.back()->Type = TT_RegexLiteral; + // Treat regex literals like other string_literals. + Tokens.back()->Tok.setKind(tok::string_literal); Tokens.back()->ColumnWidth += LastColumn - I[0]->OriginalColumn; return true; } @@ -801,7 +844,7 @@ private: EndBacktick->OriginalColumn + EndBacktick->ColumnWidth; for (auto I = Tokens.rbegin() + 1, E = Tokens.rend(); I != E; I++) { ++TokenCount; - if (I[0]->NewlinesBefore > 0 || I[0]->IsMultiline) + if (I[0]->IsMultiline) IsMultiline = true; // If there was a preceding template string, this must be the start of a @@ -817,9 +860,10 @@ private: EndColumnInFirstLine = I[0]->OriginalColumn + I[0]->ColumnWidth; // If the token has newlines, the token before it (if it exists) is the // rhs end of the previous line. - if (I[0]->NewlinesBefore > 0 && (I + 1 != E)) + if (I[0]->NewlinesBefore > 0 && (I + 1 != E)) { EndColumnInFirstLine = I[1]->OriginalColumn + I[1]->ColumnWidth; - + IsMultiline = true; + } continue; } @@ -852,7 +896,8 @@ private: // until here`; Tokens.back()->ColumnWidth = EndColumnInFirstLine - Tokens.back()->OriginalColumn; - Tokens.back()->LastLineColumnWidth = EndOriginalColumn; + // +1 for the ` itself. + Tokens.back()->LastLineColumnWidth = EndOriginalColumn + 1; Tokens.back()->IsMultiline = true; } else { // Token simply spans from start to end, +1 for the ` itself. @@ -1044,7 +1089,6 @@ private: break; default: FormatTok->Type = TT_ImplicitStringLiteral; - ++Column; break; } } @@ -1189,6 +1233,7 @@ private: getFormattingLangOpts(Style), Buffer.begin(), Buffer.begin() + Offset, Buffer.end())); Lex->SetKeepWhitespaceMode(true); + TrailingWhitespace = 0; } }; diff --git a/lib/Format/TokenAnnotator.cpp b/lib/Format/TokenAnnotator.cpp index 8d08c3d26227..0e1f14ad05f2 100644 --- a/lib/Format/TokenAnnotator.cpp +++ b/lib/Format/TokenAnnotator.cpp @@ -1008,7 +1008,7 @@ private: if (Tok.isNot(tok::identifier) || !Tok.Previous) return false; - if (Tok.Previous->is(TT_LeadingJavaAnnotation)) + if (Tok.Previous->isOneOf(TT_LeadingJavaAnnotation, Keywords.kw_instanceof)) return false; // Skip "const" as it does not have an influence on whether this is a name. @@ -1123,7 +1123,7 @@ private: return TT_UnaryOperator; const FormatToken *NextToken = Tok.getNextNonComment(); - if (!NextToken || + if (!NextToken || NextToken->is(tok::arrow) || (NextToken->is(tok::l_brace) && !NextToken->getNextNonComment())) return TT_Unknown; @@ -1336,6 +1336,10 @@ private: return 0; if (Current->is(TT_RangeBasedForLoopColon)) return prec::Comma; + if ((Style.Language == FormatStyle::LK_Java || + Style.Language == FormatStyle::LK_JavaScript) && + Current->is(Keywords.kw_instanceof)) + return prec::Relational; if (Current->is(TT_BinaryOperator) || Current->is(tok::comma)) return Current->getPrecedence(); if (Current->isOneOf(tok::period, tok::arrow)) @@ -1539,8 +1543,11 @@ void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) { Current->MustBreakBefore = Current->MustBreakBefore || mustBreakBefore(Line, *Current); - if (Style.AlwaysBreakAfterDefinitionReturnType && InFunctionDecl && - Current->is(TT_FunctionDeclarationName) && + if ((Style.AlwaysBreakAfterDefinitionReturnType == FormatStyle::DRTBS_All || + (Style.AlwaysBreakAfterDefinitionReturnType == + FormatStyle::DRTBS_TopLevel && + Line.Level == 0)) && + InFunctionDecl && Current->is(TT_FunctionDeclarationName) && !Line.Last->isOneOf(tok::semi, tok::comment)) // Only for definitions. // FIXME: Line.Last points to other characters than tok::semi // and tok::lbrace. @@ -1876,7 +1883,12 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, const FormatToken &Right) { const FormatToken &Left = *Right.Previous; - if (Style.Language == FormatStyle::LK_Proto) { + if (Right.Tok.getIdentifierInfo() && Left.Tok.getIdentifierInfo()) + return true; // Never ever merge two identifiers. + if (Style.Language == FormatStyle::LK_Cpp) { + if (Left.is(tok::kw_operator)) + return Right.is(tok::coloncolon); + } else if (Style.Language == FormatStyle::LK_Proto) { if (Right.is(tok::period) && Left.isOneOf(Keywords.kw_optional, Keywords.kw_required, Keywords.kw_repeated)) @@ -1913,8 +1925,6 @@ bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, Right.is(TT_TemplateOpener)) return true; } - if (Right.Tok.getIdentifierInfo() && Left.Tok.getIdentifierInfo()) - return true; // Never ever merge two identifiers. if (Left.is(TT_ImplicitStringLiteral)) return Right.WhitespaceRange.getBegin() != Right.WhitespaceRange.getEnd(); if (Line.Type == LT_ObjCMethodDecl) { @@ -1937,8 +1947,6 @@ bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, return false; if (Right.isOneOf(TT_CtorInitializerColon, TT_ObjCBlockLParen)) return true; - if (Left.is(tok::kw_operator)) - return Right.is(tok::coloncolon); if (Right.is(TT_OverloadedOperatorLParen)) return false; if (Right.is(tok::colon)) { @@ -2128,6 +2136,8 @@ bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line, } else if (Style.Language == FormatStyle::LK_JavaScript) { if (Left.is(TT_JsFatArrow) && Right.is(tok::l_brace)) return false; + if (Left.is(TT_JsTypeColon)) + return true; } if (Left.is(tok::at)) @@ -2234,7 +2244,8 @@ bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line, return true; if (Right.is(tok::kw_typename) && Left.isNot(tok::kw_const)) return true; - if (Left.isBinaryOperator() && !Left.isOneOf(tok::arrowstar, tok::lessless) && + if ((Left.isBinaryOperator() || Left.is(TT_BinaryOperator)) && + !Left.isOneOf(tok::arrowstar, tok::lessless) && Style.BreakBeforeBinaryOperators != FormatStyle::BOS_All && (Style.BreakBeforeBinaryOperators == FormatStyle::BOS_None || Left.getPrecedence() == prec::Assignment)) diff --git a/lib/Format/UnwrappedLineParser.cpp b/lib/Format/UnwrappedLineParser.cpp index ea1ca39870e0..c58e6bccd9bc 100644 --- a/lib/Format/UnwrappedLineParser.cpp +++ b/lib/Format/UnwrappedLineParser.cpp @@ -656,6 +656,16 @@ void UnwrappedLineParser::parseStructuralElement() { nextToken(); addUnwrappedLine(); return; + case tok::objc_autoreleasepool: + nextToken(); + if (FormatTok->Tok.is(tok::l_brace)) { + if (Style.BreakBeforeBraces == FormatStyle::BS_Allman || + Style.BreakBeforeBraces == FormatStyle::BS_GNU) + addUnwrappedLine(); + parseBlock(/*MustBeDeclaration=*/false); + } + addUnwrappedLine(); + return; case tok::objc_try: // This branch isn't strictly necessary (the kw_try case below would // do this too after the tok::at is parsed above). But be explicit. @@ -1101,16 +1111,15 @@ bool UnwrappedLineParser::parseBracedList(bool ContinueOnSemicolons) { FormatTok->BlockKind = BK_BracedInit; parseBracedList(); break; - case tok::r_paren: + case tok::l_paren: + parseParens(); // JavaScript can just have free standing methods and getters/setters in // object literals. Detect them by a "{" following ")". if (Style.Language == FormatStyle::LK_JavaScript) { - nextToken(); if (FormatTok->is(tok::l_brace)) parseChildBlock(); break; } - nextToken(); break; case tok::r_brace: nextToken(); diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp index 85467631c943..dd664ca652f0 100644 --- a/lib/Frontend/CompilerInvocation.cpp +++ b/lib/Frontend/CompilerInvocation.cpp @@ -1521,6 +1521,8 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Args.hasArg(OPT_fmodules_decluse) || Opts.ModulesStrictDeclUse; Opts.ModulesLocalVisibility = Args.hasArg(OPT_fmodules_local_submodule_visibility); + Opts.ModulesHideInternalLinkage = + !Args.hasArg(OPT_fno_modules_hide_internal_linkage); Opts.ModulesSearchAll = Opts.Modules && !Args.hasArg(OPT_fno_modules_search_all) && Args.hasArg(OPT_fmodules_search_all); @@ -1586,6 +1588,7 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Opts.ImplementationOfModule = Args.getLastArgValue(OPT_fmodule_implementation_of); Opts.ModuleFeatures = Args.getAllArgValues(OPT_fmodule_feature); + std::sort(Opts.ModuleFeatures.begin(), Opts.ModuleFeatures.end()); Opts.NativeHalfType |= Args.hasArg(OPT_fnative_half_type); Opts.HalfArgsAndReturns = Args.hasArg(OPT_fallow_half_arguments_and_returns); Opts.GNUAsm = !Args.hasArg(OPT_fno_gnu_inline_asm); @@ -1847,37 +1850,37 @@ bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res, std::unique_ptr<OptTable> Opts(createDriverOptTable()); const unsigned IncludedFlagsBitmask = options::CC1Option; unsigned MissingArgIndex, MissingArgCount; - std::unique_ptr<InputArgList> Args( - Opts->ParseArgs(ArgBegin, ArgEnd, MissingArgIndex, MissingArgCount, - IncludedFlagsBitmask)); + InputArgList Args = + Opts->ParseArgs(llvm::makeArrayRef(ArgBegin, ArgEnd), MissingArgIndex, + MissingArgCount, IncludedFlagsBitmask); // Check for missing argument error. if (MissingArgCount) { Diags.Report(diag::err_drv_missing_argument) - << Args->getArgString(MissingArgIndex) << MissingArgCount; + << Args.getArgString(MissingArgIndex) << MissingArgCount; Success = false; } // Issue errors on unknown arguments. - for (const Arg *A : Args->filtered(OPT_UNKNOWN)) { - Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(*Args); + for (const Arg *A : Args.filtered(OPT_UNKNOWN)) { + Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(Args); Success = false; } - Success &= ParseAnalyzerArgs(*Res.getAnalyzerOpts(), *Args, Diags); - Success &= ParseMigratorArgs(Res.getMigratorOpts(), *Args); - ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), *Args); - Success &= ParseDiagnosticArgs(Res.getDiagnosticOpts(), *Args, &Diags); - ParseCommentArgs(Res.getLangOpts()->CommentOpts, *Args); - ParseFileSystemArgs(Res.getFileSystemOpts(), *Args); + Success &= ParseAnalyzerArgs(*Res.getAnalyzerOpts(), Args, Diags); + Success &= ParseMigratorArgs(Res.getMigratorOpts(), Args); + ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), Args); + Success &= ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, &Diags); + ParseCommentArgs(Res.getLangOpts()->CommentOpts, Args); + ParseFileSystemArgs(Res.getFileSystemOpts(), Args); // FIXME: We shouldn't have to pass the DashX option around here - InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), *Args, Diags); - ParseTargetArgs(Res.getTargetOpts(), *Args); - Success &= ParseCodeGenArgs(Res.getCodeGenOpts(), *Args, DashX, Diags, + InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), Args, Diags); + ParseTargetArgs(Res.getTargetOpts(), Args); + Success &= ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags, Res.getTargetOpts()); - ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), *Args); + ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), Args); if (DashX != IK_AST && DashX != IK_LLVM_IR) { - ParseLangArgs(*Res.getLangOpts(), *Args, DashX, Diags); + ParseLangArgs(*Res.getLangOpts(), Args, DashX, Diags); if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC) Res.getLangOpts()->ObjCExceptions = 1; } @@ -1886,8 +1889,8 @@ bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res, // ParsePreprocessorArgs and remove the FileManager // parameters from the function and the "FileManager.h" #include. FileManager FileMgr(Res.getFileSystemOpts()); - ParsePreprocessorArgs(Res.getPreprocessorOpts(), *Args, FileMgr, Diags); - ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), *Args, + ParsePreprocessorArgs(Res.getPreprocessorOpts(), Args, FileMgr, Diags); + ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), Args, Res.getFrontendOpts().ProgramAction); return Success; } @@ -1965,6 +1968,9 @@ std::string CompilerInvocation::getModuleHash() const { #define BENIGN_LANGOPT(Name, Bits, Default, Description) #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description) #include "clang/Basic/LangOptions.def" + + for (StringRef Feature : LangOpts->ModuleFeatures) + code = hash_combine(code, Feature); // Extend the signature with the target options. code = hash_combine(code, TargetOpts->Triple, TargetOpts->CPU, diff --git a/lib/Frontend/FrontendActions.cpp b/lib/Frontend/FrontendActions.cpp index 6f202a15483a..499776468818 100644 --- a/lib/Frontend/FrontendActions.cpp +++ b/lib/Frontend/FrontendActions.cpp @@ -470,6 +470,13 @@ namespace { #define BENIGN_LANGOPT(Name, Bits, Default, Description) #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description) #include "clang/Basic/LangOptions.def" + + if (!LangOpts.ModuleFeatures.empty()) { + Out.indent(4) << "Module features:\n"; + for (StringRef Feature : LangOpts.ModuleFeatures) + Out.indent(6) << Feature << "\n"; + } + return false; } diff --git a/lib/Frontend/InitHeaderSearch.cpp b/lib/Frontend/InitHeaderSearch.cpp index bf8470ef1e78..e3a17c922fb8 100644 --- a/lib/Frontend/InitHeaderSearch.cpp +++ b/lib/Frontend/InitHeaderSearch.cpp @@ -82,11 +82,6 @@ public: StringRef Arch, StringRef Version); - /// AddMinGW64CXXPaths - Add the necessary paths to support - /// libstdc++ of x86_64-w64-mingw32 aka mingw-w64. - void AddMinGW64CXXPaths(StringRef Base, - StringRef Version); - // AddDefaultCIncludePaths - Add paths that should always be searched. void AddDefaultCIncludePaths(const llvm::Triple &triple, const HeaderSearchOptions &HSOpts); @@ -208,19 +203,6 @@ void InitHeaderSearch::AddMinGWCPlusPlusIncludePaths(StringRef Base, CXXSystem, false); } -void InitHeaderSearch::AddMinGW64CXXPaths(StringRef Base, - StringRef Version) { - // Assumes Base is HeaderSearchOpts' ResourceDir - AddPath(Base + "/../../../include/c++/" + Version, - CXXSystem, false); - AddPath(Base + "/../../../include/c++/" + Version + "/x86_64-w64-mingw32", - CXXSystem, false); - AddPath(Base + "/../../../include/c++/" + Version + "/i686-w64-mingw32", - CXXSystem, false); - AddPath(Base + "/../../../include/c++/" + Version + "/backward", - CXXSystem, false); -} - void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple, const HeaderSearchOptions &HSOpts) { llvm::Triple::OSType os = triple.getOS(); @@ -234,6 +216,9 @@ void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple, case llvm::Triple::Bitrig: case llvm::Triple::NaCl: break; + case llvm::Triple::Win32: + if (triple.getEnvironment() != llvm::Triple::Cygnus) + break; default: // FIXME: temporary hack: hard-coded paths. AddPath("/usr/local/include", System, false); @@ -323,26 +308,6 @@ void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple, AddPath("/usr/include/w32api", System, false); break; case llvm::Triple::GNU: - // mingw-w64 crt include paths - // <sysroot>/i686-w64-mingw32/include - SmallString<128> P = StringRef(HSOpts.ResourceDir); - llvm::sys::path::append(P, "../../../i686-w64-mingw32/include"); - AddPath(P, System, false); - - // <sysroot>/x86_64-w64-mingw32/include - P.resize(HSOpts.ResourceDir.size()); - llvm::sys::path::append(P, "../../../x86_64-w64-mingw32/include"); - AddPath(P, System, false); - - // mingw.org crt include paths - // <sysroot>/include - P.resize(HSOpts.ResourceDir.size()); - llvm::sys::path::append(P, "../../../include"); - AddPath(P, System, false); - AddPath("/mingw/include", System, false); -#if defined(LLVM_ON_WIN32) - AddPath("c:/mingw/include", System, false); -#endif break; } break; @@ -419,27 +384,8 @@ AddDefaultCPlusPlusIncludePaths(const llvm::Triple &triple, const HeaderSearchOp // g++-4 / Cygwin-1.5 AddMinGWCPlusPlusIncludePaths("/usr/lib/gcc", "i686-pc-cygwin", "4.3.2"); break; - case llvm::Triple::GNU: - // mingw-w64 C++ include paths (i686-w64-mingw32 and x86_64-w64-mingw32) - AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.7.0"); - AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.7.1"); - AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.7.2"); - AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.7.3"); - AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.8.0"); - AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.8.1"); - AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.8.2"); - // mingw.org C++ include paths -#if defined(LLVM_ON_WIN32) - AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.7.0"); - AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.7.1"); - AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.7.2"); - AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.7.3"); - AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.8.0"); - AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.8.1"); - AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.8.2"); -#endif - break; } + break; case llvm::Triple::DragonFly: if (llvm::sys::fs::exists("/usr/lib/gcc47")) AddPath("/usr/include/c++/4.7", CXXSystem, false); @@ -482,8 +428,7 @@ void InitHeaderSearch::AddDefaultIncludePaths(const LangOptions &Lang, return; case llvm::Triple::Win32: - if (triple.getEnvironment() == llvm::Triple::MSVC || - triple.getEnvironment() == llvm::Triple::Itanium || + if (triple.getEnvironment() != llvm::Triple::Cygnus || triple.isOSBinFormatMachO()) return; break; diff --git a/lib/Frontend/InitPreprocessor.cpp b/lib/Frontend/InitPreprocessor.cpp index 24171468f1b2..025c8b9d43a9 100644 --- a/lib/Frontend/InitPreprocessor.cpp +++ b/lib/Frontend/InitPreprocessor.cpp @@ -868,6 +868,14 @@ static void InitializePredefinedMacros(const TargetInfo &TI, "__attribute__((objc_ownership(none)))"); } + // On Darwin, there are __double_underscored variants of the type + // nullability qualifiers. + if (TI.getTriple().isOSDarwin()) { + Builder.defineMacro("__nonnull", "_Nonnull"); + Builder.defineMacro("__null_unspecified", "_Null_unspecified"); + Builder.defineMacro("__nullable", "_Nullable"); + } + // OpenMP definition if (LangOpts.OpenMP) { // OpenMP 2.2: diff --git a/lib/Frontend/MultiplexConsumer.cpp b/lib/Frontend/MultiplexConsumer.cpp index a53f4d2a5a17..91ee100f6394 100644 --- a/lib/Frontend/MultiplexConsumer.cpp +++ b/lib/Frontend/MultiplexConsumer.cpp @@ -128,6 +128,8 @@ public: void DeclarationMarkedUsed(const Decl *D) override; void DeclarationMarkedOpenMPThreadPrivate(const Decl *D) override; void RedefinedHiddenDefinition(const NamedDecl *D, Module *M) override; + void AddedAttributeToRecord(const Attr *Attr, + const RecordDecl *Record) override; private: std::vector<ASTMutationListener*> Listeners; @@ -226,6 +228,13 @@ void MultiplexASTMutationListener::RedefinedHiddenDefinition(const NamedDecl *D, for (auto *L : Listeners) L->RedefinedHiddenDefinition(D, M); } + +void MultiplexASTMutationListener::AddedAttributeToRecord( + const Attr *Attr, + const RecordDecl *Record) { + for (auto *L : Listeners) + L->AddedAttributeToRecord(Attr, Record); +} } // end namespace clang diff --git a/lib/Frontend/Rewrite/InclusionRewriter.cpp b/lib/Frontend/Rewrite/InclusionRewriter.cpp index b9ea051662c6..08d6cf1f92c2 100644 --- a/lib/Frontend/Rewrite/InclusionRewriter.cpp +++ b/lib/Frontend/Rewrite/InclusionRewriter.cpp @@ -29,13 +29,11 @@ namespace { class InclusionRewriter : public PPCallbacks { /// Information about which #includes were actually performed, /// created by preprocessor callbacks. - struct FileChange { - const Module *Mod; - SourceLocation From; + struct IncludedFile { FileID Id; SrcMgr::CharacteristicKind FileType; - FileChange(SourceLocation From, const Module *Mod) : Mod(Mod), From(From) { - } + IncludedFile(FileID Id, SrcMgr::CharacteristicKind FileType) + : Id(Id), FileType(FileType) {} }; Preprocessor &PP; ///< Used to find inclusion directives. SourceManager &SM; ///< Used to read and manage source files. @@ -44,11 +42,13 @@ class InclusionRewriter : public PPCallbacks { const llvm::MemoryBuffer *PredefinesBuffer; ///< The preprocessor predefines. bool ShowLineMarkers; ///< Show #line markers. bool UseLineDirectives; ///< Use of line directives or line markers. - typedef std::map<unsigned, FileChange> FileChangeMap; - FileChangeMap FileChanges; ///< Tracks which files were included where. - /// Used transitively for building up the FileChanges mapping over the + /// Tracks where inclusions that change the file are found. + std::map<unsigned, IncludedFile> FileIncludes; + /// Tracks where inclusions that import modules are found. + std::map<unsigned, const Module *> ModuleIncludes; + /// Used transitively for building up the FileIncludes mapping over the /// various \c PPCallbacks callbacks. - FileChangeMap::iterator LastInsertedFileChange; + SourceLocation LastInclusionLocation; public: InclusionRewriter(Preprocessor &PP, raw_ostream &OS, bool ShowLineMarkers, bool UseLineDirectives); @@ -82,7 +82,8 @@ private: bool HandleHasInclude(FileID FileId, Lexer &RawLex, const DirectoryLookup *Lookup, Token &Tok, bool &FileExists); - const FileChange *FindFileChangeLocation(SourceLocation Loc) const; + const IncludedFile *FindIncludeAtLocation(SourceLocation Loc) const; + const Module *FindModuleAtLocation(SourceLocation Loc) const; StringRef NextIdentifierName(Lexer &RawLex, Token &RawToken); }; @@ -95,7 +96,7 @@ InclusionRewriter::InclusionRewriter(Preprocessor &PP, raw_ostream &OS, : PP(PP), SM(PP.getSourceManager()), OS(OS), MainEOL("\n"), PredefinesBuffer(nullptr), ShowLineMarkers(ShowLineMarkers), UseLineDirectives(UseLineDirectives), - LastInsertedFileChange(FileChanges.end()) {} + LastInclusionLocation(SourceLocation()) {} /// Write appropriate line information as either #line directives or GNU line /// markers depending on what mode we're in, including the \p Filename and @@ -143,12 +144,15 @@ void InclusionRewriter::FileChanged(SourceLocation Loc, FileID) { if (Reason != EnterFile) return; - if (LastInsertedFileChange == FileChanges.end()) + if (LastInclusionLocation.isInvalid()) // we didn't reach this file (eg: the main file) via an inclusion directive return; - LastInsertedFileChange->second.Id = FullSourceLoc(Loc, SM).getFileID(); - LastInsertedFileChange->second.FileType = NewFileType; - LastInsertedFileChange = FileChanges.end(); + FileID Id = FullSourceLoc(Loc, SM).getFileID(); + auto P = FileIncludes.insert(std::make_pair( + LastInclusionLocation.getRawEncoding(), IncludedFile(Id, NewFileType))); + (void)P; + assert(P.second && "Unexpected revisitation of the same include directive"); + LastInclusionLocation = SourceLocation(); } /// Called whenever an inclusion is skipped due to canonical header protection @@ -156,10 +160,9 @@ void InclusionRewriter::FileChanged(SourceLocation Loc, void InclusionRewriter::FileSkipped(const FileEntry &/*SkippedFile*/, const Token &/*FilenameTok*/, SrcMgr::CharacteristicKind /*FileType*/) { - assert(LastInsertedFileChange != FileChanges.end() && "A file, that wasn't " - "found via an inclusion directive, was skipped"); - FileChanges.erase(LastInsertedFileChange); - LastInsertedFileChange = FileChanges.end(); + assert(!LastInclusionLocation.isInvalid() && + "A file, that wasn't found via an inclusion directive, was skipped"); + LastInclusionLocation = SourceLocation(); } /// This should be called whenever the preprocessor encounters include @@ -176,25 +179,38 @@ void InclusionRewriter::InclusionDirective(SourceLocation HashLoc, StringRef /*SearchPath*/, StringRef /*RelativePath*/, const Module *Imported) { - assert(LastInsertedFileChange == FileChanges.end() && "Another inclusion " - "directive was found before the previous one was processed"); - std::pair<FileChangeMap::iterator, bool> p = FileChanges.insert( - std::make_pair(HashLoc.getRawEncoding(), FileChange(HashLoc, Imported))); - assert(p.second && "Unexpected revisitation of the same include directive"); - if (!Imported) - LastInsertedFileChange = p.first; + assert(LastInclusionLocation.isInvalid() && + "Another inclusion directive was found before the previous one " + "was processed"); + if (Imported) { + auto P = ModuleIncludes.insert( + std::make_pair(HashLoc.getRawEncoding(), Imported)); + (void)P; + assert(P.second && "Unexpected revisitation of the same include directive"); + } else + LastInclusionLocation = HashLoc; } /// Simple lookup for a SourceLocation (specifically one denoting the hash in /// an inclusion directive) in the map of inclusion information, FileChanges. -const InclusionRewriter::FileChange * -InclusionRewriter::FindFileChangeLocation(SourceLocation Loc) const { - FileChangeMap::const_iterator I = FileChanges.find(Loc.getRawEncoding()); - if (I != FileChanges.end()) +const InclusionRewriter::IncludedFile * +InclusionRewriter::FindIncludeAtLocation(SourceLocation Loc) const { + const auto I = FileIncludes.find(Loc.getRawEncoding()); + if (I != FileIncludes.end()) return &I->second; return nullptr; } +/// Simple lookup for a SourceLocation (specifically one denoting the hash in +/// an inclusion directive) in the map of module inclusion information. +const Module * +InclusionRewriter::FindModuleAtLocation(SourceLocation Loc) const { + const auto I = ModuleIncludes.find(Loc.getRawEncoding()); + if (I != ModuleIncludes.end()) + return I->second; + return nullptr; +} + /// Detect the likely line ending style of \p FromFile by examining the first /// newline found within it. static StringRef DetectEOL(const MemoryBuffer &FromFile) { @@ -388,8 +404,7 @@ bool InclusionRewriter::Process(FileID FileId, { bool Invalid; const MemoryBuffer &FromFile = *SM.getBuffer(FileId, &Invalid); - if (Invalid) // invalid inclusion - return false; + assert(!Invalid && "Attempting to process invalid inclusion"); const char *FileName = FromFile.getBufferIdentifier(); Lexer RawLex(FileId, &FromFile, PP.getSourceManager(), PP.getLangOpts()); RawLex.SetCommentRetentionState(false); @@ -433,13 +448,12 @@ bool InclusionRewriter::Process(FileID FileId, if (FileId != PP.getPredefinesFileID()) WriteLineInfo(FileName, Line - 1, FileType, ""); StringRef LineInfoExtra; - if (const FileChange *Change = FindFileChangeLocation( - HashToken.getLocation())) { - if (Change->Mod) { - WriteImplicitModuleImport(Change->Mod); - - // else now include and recursively process the file - } else if (Process(Change->Id, Change->FileType)) { + SourceLocation Loc = HashToken.getLocation(); + if (const Module *Mod = FindModuleAtLocation(Loc)) + WriteImplicitModuleImport(Mod); + else if (const IncludedFile *Inc = FindIncludeAtLocation(Loc)) { + // include and recursively process the file + if (Process(Inc->Id, Inc->FileType)) { // and set lineinfo back to this file, if the nested one was // actually included // `2' indicates returning to a file (after having included diff --git a/lib/Frontend/Rewrite/RewriteModernObjC.cpp b/lib/Frontend/Rewrite/RewriteModernObjC.cpp index e13cdb3a3e55..2902ba78c4ef 100644 --- a/lib/Frontend/Rewrite/RewriteModernObjC.cpp +++ b/lib/Frontend/Rewrite/RewriteModernObjC.cpp @@ -1932,9 +1932,9 @@ Stmt *RewriteModernObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) void RewriteModernObjC::WarnAboutReturnGotoStmts(Stmt *S) { // Perform a bottom up traversal of all children. - for (Stmt::child_range CI = S->children(); CI; ++CI) - if (*CI) - WarnAboutReturnGotoStmts(*CI); + for (Stmt *SubStmt : S->children()) + if (SubStmt) + WarnAboutReturnGotoStmts(SubStmt); if (isa<ReturnStmt>(S) || isa<GotoStmt>(S)) { Diags.Report(Context->getFullLoc(S->getLocStart()), @@ -4549,12 +4549,12 @@ void RewriteModernObjC::InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD) { } void RewriteModernObjC::GetBlockDeclRefExprs(Stmt *S) { - for (Stmt::child_range CI = S->children(); CI; ++CI) - if (*CI) { - if (BlockExpr *CBE = dyn_cast<BlockExpr>(*CI)) + for (Stmt *SubStmt : S->children()) + if (SubStmt) { + if (BlockExpr *CBE = dyn_cast<BlockExpr>(SubStmt)) GetBlockDeclRefExprs(CBE->getBody()); else - GetBlockDeclRefExprs(*CI); + GetBlockDeclRefExprs(SubStmt); } // Handle specific things. if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S)) @@ -4569,19 +4569,16 @@ void RewriteModernObjC::GetBlockDeclRefExprs(Stmt *S) { void RewriteModernObjC::GetInnerBlockDeclRefExprs(Stmt *S, SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs, llvm::SmallPtrSetImpl<const DeclContext *> &InnerContexts) { - for (Stmt::child_range CI = S->children(); CI; ++CI) - if (*CI) { - if (BlockExpr *CBE = dyn_cast<BlockExpr>(*CI)) { + for (Stmt *SubStmt : S->children()) + if (SubStmt) { + if (BlockExpr *CBE = dyn_cast<BlockExpr>(SubStmt)) { InnerContexts.insert(cast<DeclContext>(CBE->getBlockDecl())); GetInnerBlockDeclRefExprs(CBE->getBody(), InnerBlockDeclRefs, InnerContexts); } else - GetInnerBlockDeclRefExprs(*CI, - InnerBlockDeclRefs, - InnerContexts); - + GetInnerBlockDeclRefExprs(SubStmt, InnerBlockDeclRefs, InnerContexts); } // Handle specific things. if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S)) { @@ -5564,12 +5561,11 @@ Stmt *RewriteModernObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { SourceRange OrigStmtRange = S->getSourceRange(); // Perform a bottom up rewrite of all children. - for (Stmt::child_range CI = S->children(); CI; ++CI) - if (*CI) { - Stmt *childStmt = (*CI); + for (Stmt *&childStmt : S->children()) + if (childStmt) { Stmt *newStmt = RewriteFunctionBodyOrGlobalInitializer(childStmt); if (newStmt) { - *CI = newStmt; + childStmt = newStmt; } } diff --git a/lib/Frontend/Rewrite/RewriteObjC.cpp b/lib/Frontend/Rewrite/RewriteObjC.cpp index b2a45b407bae..204820b3041a 100644 --- a/lib/Frontend/Rewrite/RewriteObjC.cpp +++ b/lib/Frontend/Rewrite/RewriteObjC.cpp @@ -1712,9 +1712,9 @@ Stmt *RewriteObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) { void RewriteObjC::WarnAboutReturnGotoStmts(Stmt *S) { // Perform a bottom up traversal of all children. - for (Stmt::child_range CI = S->children(); CI; ++CI) - if (*CI) - WarnAboutReturnGotoStmts(*CI); + for (Stmt *SubStmt : S->children()) + if (SubStmt) + WarnAboutReturnGotoStmts(SubStmt); if (isa<ReturnStmt>(S) || isa<GotoStmt>(S)) { Diags.Report(Context->getFullLoc(S->getLocStart()), @@ -1726,9 +1726,9 @@ void RewriteObjC::WarnAboutReturnGotoStmts(Stmt *S) void RewriteObjC::HasReturnStmts(Stmt *S, bool &hasReturns) { // Perform a bottom up traversal of all children. - for (Stmt::child_range CI = S->children(); CI; ++CI) - if (*CI) - HasReturnStmts(*CI, hasReturns); + for (Stmt *SubStmt : S->children()) + if (SubStmt) + HasReturnStmts(SubStmt, hasReturns); if (isa<ReturnStmt>(S)) hasReturns = true; @@ -1737,9 +1737,9 @@ void RewriteObjC::HasReturnStmts(Stmt *S, bool &hasReturns) void RewriteObjC::RewriteTryReturnStmts(Stmt *S) { // Perform a bottom up traversal of all children. - for (Stmt::child_range CI = S->children(); CI; ++CI) - if (*CI) { - RewriteTryReturnStmts(*CI); + for (Stmt *SubStmt : S->children()) + if (SubStmt) { + RewriteTryReturnStmts(SubStmt); } if (isa<ReturnStmt>(S)) { SourceLocation startLoc = S->getLocStart(); @@ -1760,9 +1760,9 @@ void RewriteObjC::RewriteTryReturnStmts(Stmt *S) { void RewriteObjC::RewriteSyncReturnStmts(Stmt *S, std::string syncExitBuf) { // Perform a bottom up traversal of all children. - for (Stmt::child_range CI = S->children(); CI; ++CI) - if (*CI) { - RewriteSyncReturnStmts(*CI, syncExitBuf); + for (Stmt *SubStmt : S->children()) + if (SubStmt) { + RewriteSyncReturnStmts(SubStmt, syncExitBuf); } if (isa<ReturnStmt>(S)) { SourceLocation startLoc = S->getLocStart(); @@ -3663,12 +3663,12 @@ void RewriteObjC::InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD) { } void RewriteObjC::GetBlockDeclRefExprs(Stmt *S) { - for (Stmt::child_range CI = S->children(); CI; ++CI) - if (*CI) { - if (BlockExpr *CBE = dyn_cast<BlockExpr>(*CI)) + for (Stmt *SubStmt : S->children()) + if (SubStmt) { + if (BlockExpr *CBE = dyn_cast<BlockExpr>(SubStmt)) GetBlockDeclRefExprs(CBE->getBody()); else - GetBlockDeclRefExprs(*CI); + GetBlockDeclRefExprs(SubStmt); } // Handle specific things. if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S)) @@ -3683,19 +3683,16 @@ void RewriteObjC::GetBlockDeclRefExprs(Stmt *S) { void RewriteObjC::GetInnerBlockDeclRefExprs(Stmt *S, SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs, llvm::SmallPtrSetImpl<const DeclContext *> &InnerContexts) { - for (Stmt::child_range CI = S->children(); CI; ++CI) - if (*CI) { - if (BlockExpr *CBE = dyn_cast<BlockExpr>(*CI)) { + for (Stmt *SubStmt : S->children()) + if (SubStmt) { + if (BlockExpr *CBE = dyn_cast<BlockExpr>(SubStmt)) { InnerContexts.insert(cast<DeclContext>(CBE->getBlockDecl())); GetInnerBlockDeclRefExprs(CBE->getBody(), InnerBlockDeclRefs, InnerContexts); } else - GetInnerBlockDeclRefExprs(*CI, - InnerBlockDeclRefs, - InnerContexts); - + GetInnerBlockDeclRefExprs(SubStmt, InnerBlockDeclRefs, InnerContexts); } // Handle specific things. if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S)) { @@ -4611,12 +4608,11 @@ Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { SourceRange OrigStmtRange = S->getSourceRange(); // Perform a bottom up rewrite of all children. - for (Stmt::child_range CI = S->children(); CI; ++CI) - if (*CI) { - Stmt *childStmt = (*CI); + for (Stmt *&childStmt : S->children()) + if (childStmt) { Stmt *newStmt = RewriteFunctionBodyOrGlobalInitializer(childStmt); if (newStmt) { - *CI = newStmt; + childStmt = newStmt; } } diff --git a/lib/Headers/CMakeLists.txt b/lib/Headers/CMakeLists.txt index 5f8857c41b49..87afc60de996 100644 --- a/lib/Headers/CMakeLists.txt +++ b/lib/Headers/CMakeLists.txt @@ -5,6 +5,7 @@ set(files arm_acle.h avx2intrin.h avx512bwintrin.h + avx512cdintrin.h avx512erintrin.h avx512fintrin.h avx512vlbwintrin.h @@ -21,11 +22,13 @@ set(files float.h fma4intrin.h fmaintrin.h + fxsrintrin.h htmintrin.h htmxlintrin.h ia32intrin.h immintrin.h Intrin.h + inttypes.h iso646.h limits.h lzcntintrin.h diff --git a/lib/Headers/Intrin.h b/lib/Headers/Intrin.h index dd04e06ad8bc..7ba311ea4b94 100644 --- a/lib/Headers/Intrin.h +++ b/lib/Headers/Intrin.h @@ -40,7 +40,7 @@ #endif /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__)) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__)) #ifdef __cplusplus extern "C" { @@ -180,8 +180,6 @@ unsigned long __cdecl _byteswap_ulong(unsigned long); unsigned short __cdecl _byteswap_ushort(unsigned short); void __cdecl _disable(void); void __cdecl _enable(void); -void __cdecl _fxrstor(void const *); -void __cdecl _fxsave(void *); long _InterlockedAddLargeStatistic(__int64 volatile *_Addend, long _Value); static __inline__ long _InterlockedAnd(long volatile *_Value, long _Mask); @@ -358,8 +356,6 @@ unsigned char _bittestandreset64(__int64 *, __int64); static __inline__ unsigned char _bittestandset64(__int64 *, __int64); unsigned __int64 __cdecl _byteswap_uint64(unsigned __int64); -void __cdecl _fxrstor64(void const *); -void __cdecl _fxsave64(void *); long _InterlockedAnd_np(long volatile *_Value, long _Mask); short _InterlockedAnd16_np(short volatile *_Value, short _Mask); __int64 _InterlockedAnd64_np(__int64 volatile *_Value, __int64 _Mask); @@ -424,7 +420,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 DEFAULT_FN_ATTRS +static __inline__ unsigned __int64 __DEFAULT_FN_ATTRS _umul128(unsigned __int64 _Multiplier, unsigned __int64 _Multiplicand, unsigned __int64 *_HighProduct) { unsigned __int128 _FullProduct = @@ -432,7 +428,7 @@ _umul128(unsigned __int64 _Multiplier, unsigned __int64 _Multiplicand, *_HighProduct = _FullProduct >> 64; return _FullProduct; } -static __inline__ unsigned __int64 DEFAULT_FN_ATTRS +static __inline__ unsigned __int64 __DEFAULT_FN_ATTRS __umulh(unsigned __int64 _Multiplier, unsigned __int64 _Multiplicand) { unsigned __int128 _FullProduct = (unsigned __int128)_Multiplier * (unsigned __int128)_Multiplicand; @@ -447,54 +443,54 @@ void __cdecl _xsaveopt64(void *, unsigned __int64); /*----------------------------------------------------------------------------*\ |* Bit Twiddling \*----------------------------------------------------------------------------*/ -static __inline__ unsigned char DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +__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 DEFAULT_FN_ATTRS +__inline__ unsigned __int64 __DEFAULT_FN_ATTRS _rotr64(unsigned __int64 _Value, int _Shift) { _Shift &= 0x3f; return _Shift ? (_Value >> _Shift) | (_Value << (64 - _Shift)) : _Value; @@ -502,52 +498,52 @@ _rotr64(unsigned __int64 _Value, int _Shift) { /*----------------------------------------------------------------------------*\ |* Bit Counting and Testing \*----------------------------------------------------------------------------*/ -static __inline__ unsigned char DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ unsigned short __DEFAULT_FN_ATTRS __popcnt16(unsigned short value) { return __builtin_popcount((int)value); } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __popcnt(unsigned int value) { return __builtin_popcount(value); } -static __inline__ unsigned char DEFAULT_FN_ATTRS +static __inline__ unsigned char __DEFAULT_FN_ATTRS _bittest(long const *a, long b) { return (*a >> b) & 1; } -static __inline__ unsigned char DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ unsigned char __DEFAULT_FN_ATTRS _interlockedbittestandset(long volatile *__BitBase, long __BitPos) { unsigned char __Res; __asm__ ("xor %0, %0\n" @@ -559,14 +555,14 @@ _interlockedbittestandset(long volatile *__BitBase, long __BitPos) { } #endif #ifdef __x86_64__ -static __inline__ unsigned char DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ unsigned char __DEFAULT_FN_ATTRS _BitScanReverse64(unsigned long *_Index, unsigned __int64 _Mask) { if (!_Mask) return 0; @@ -574,33 +570,33 @@ _BitScanReverse64(unsigned long *_Index, unsigned __int64 _Mask) { return 1; } static __inline__ -unsigned __int64 DEFAULT_FN_ATTRS +unsigned __int64 __DEFAULT_FN_ATTRS __popcnt64(unsigned __int64 value) { return __builtin_popcountll(value); } -static __inline__ unsigned char DEFAULT_FN_ATTRS +static __inline__ unsigned char __DEFAULT_FN_ATTRS _bittest64(__int64 const *a, __int64 b) { return (*a >> b) & 1; } -static __inline__ unsigned char DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ unsigned char __DEFAULT_FN_ATTRS _interlockedbittestandset64(__int64 volatile *__BitBase, __int64 __BitPos) { unsigned char __Res; __asm__ ("xor %0, %0\n" @@ -614,16 +610,16 @@ _interlockedbittestandset64(__int64 volatile *__BitBase, __int64 __BitPos) { /*----------------------------------------------------------------------------*\ |* Interlocked Exchange Add \*----------------------------------------------------------------------------*/ -static __inline__ char DEFAULT_FN_ATTRS +static __inline__ char __DEFAULT_FN_ATTRS _InterlockedExchangeAdd8(char volatile *_Addend, char _Value) { return __atomic_add_fetch(_Addend, _Value, 0) - _Value; } -static __inline__ short DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __int64 __DEFAULT_FN_ATTRS _InterlockedExchangeAdd64(__int64 volatile *_Addend, __int64 _Value) { return __atomic_add_fetch(_Addend, _Value, 0) - _Value; } @@ -631,20 +627,20 @@ _InterlockedExchangeAdd64(__int64 volatile *_Addend, __int64 _Value) { /*----------------------------------------------------------------------------*\ |* Interlocked Exchange Sub \*----------------------------------------------------------------------------*/ -static __inline__ char DEFAULT_FN_ATTRS +static __inline__ char __DEFAULT_FN_ATTRS _InterlockedExchangeSub8(char volatile *_Subend, char _Value) { return __atomic_sub_fetch(_Subend, _Value, 0) + _Value; } -static __inline__ short DEFAULT_FN_ATTRS +static __inline__ short __DEFAULT_FN_ATTRS _InterlockedExchangeSub16(short volatile *_Subend, short _Value) { return __atomic_sub_fetch(_Subend, _Value, 0) + _Value; } -static __inline__ long DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __int64 __DEFAULT_FN_ATTRS _InterlockedExchangeSub64(__int64 volatile *_Subend, __int64 _Value) { return __atomic_sub_fetch(_Subend, _Value, 0) + _Value; } @@ -652,12 +648,12 @@ _InterlockedExchangeSub64(__int64 volatile *_Subend, __int64 _Value) { /*----------------------------------------------------------------------------*\ |* Interlocked Increment \*----------------------------------------------------------------------------*/ -static __inline__ short DEFAULT_FN_ATTRS +static __inline__ short __DEFAULT_FN_ATTRS _InterlockedIncrement16(short volatile *_Value) { return __atomic_add_fetch(_Value, 1, 0); } #ifdef __x86_64__ -static __inline__ __int64 DEFAULT_FN_ATTRS +static __inline__ __int64 __DEFAULT_FN_ATTRS _InterlockedIncrement64(__int64 volatile *_Value) { return __atomic_add_fetch(_Value, 1, 0); } @@ -665,12 +661,12 @@ _InterlockedIncrement64(__int64 volatile *_Value) { /*----------------------------------------------------------------------------*\ |* Interlocked Decrement \*----------------------------------------------------------------------------*/ -static __inline__ short DEFAULT_FN_ATTRS +static __inline__ short __DEFAULT_FN_ATTRS _InterlockedDecrement16(short volatile *_Value) { return __atomic_sub_fetch(_Value, 1, 0); } #ifdef __x86_64__ -static __inline__ __int64 DEFAULT_FN_ATTRS +static __inline__ __int64 __DEFAULT_FN_ATTRS _InterlockedDecrement64(__int64 volatile *_Value) { return __atomic_sub_fetch(_Value, 1, 0); } @@ -678,20 +674,20 @@ _InterlockedDecrement64(__int64 volatile *_Value) { /*----------------------------------------------------------------------------*\ |* Interlocked And \*----------------------------------------------------------------------------*/ -static __inline__ char DEFAULT_FN_ATTRS +static __inline__ char __DEFAULT_FN_ATTRS _InterlockedAnd8(char volatile *_Value, char _Mask) { return __atomic_and_fetch(_Value, _Mask, 0); } -static __inline__ short DEFAULT_FN_ATTRS +static __inline__ short __DEFAULT_FN_ATTRS _InterlockedAnd16(short volatile *_Value, short _Mask) { return __atomic_and_fetch(_Value, _Mask, 0); } -static __inline__ long DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __int64 __DEFAULT_FN_ATTRS _InterlockedAnd64(__int64 volatile *_Value, __int64 _Mask) { return __atomic_and_fetch(_Value, _Mask, 0); } @@ -699,20 +695,20 @@ _InterlockedAnd64(__int64 volatile *_Value, __int64 _Mask) { /*----------------------------------------------------------------------------*\ |* Interlocked Or \*----------------------------------------------------------------------------*/ -static __inline__ char DEFAULT_FN_ATTRS +static __inline__ char __DEFAULT_FN_ATTRS _InterlockedOr8(char volatile *_Value, char _Mask) { return __atomic_or_fetch(_Value, _Mask, 0); } -static __inline__ short DEFAULT_FN_ATTRS +static __inline__ short __DEFAULT_FN_ATTRS _InterlockedOr16(short volatile *_Value, short _Mask) { return __atomic_or_fetch(_Value, _Mask, 0); } -static __inline__ long DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __int64 __DEFAULT_FN_ATTRS _InterlockedOr64(__int64 volatile *_Value, __int64 _Mask) { return __atomic_or_fetch(_Value, _Mask, 0); } @@ -720,20 +716,20 @@ _InterlockedOr64(__int64 volatile *_Value, __int64 _Mask) { /*----------------------------------------------------------------------------*\ |* Interlocked Xor \*----------------------------------------------------------------------------*/ -static __inline__ char DEFAULT_FN_ATTRS +static __inline__ char __DEFAULT_FN_ATTRS _InterlockedXor8(char volatile *_Value, char _Mask) { return __atomic_xor_fetch(_Value, _Mask, 0); } -static __inline__ short DEFAULT_FN_ATTRS +static __inline__ short __DEFAULT_FN_ATTRS _InterlockedXor16(short volatile *_Value, short _Mask) { return __atomic_xor_fetch(_Value, _Mask, 0); } -static __inline__ long DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __int64 __DEFAULT_FN_ATTRS _InterlockedXor64(__int64 volatile *_Value, __int64 _Mask) { return __atomic_xor_fetch(_Value, _Mask, 0); } @@ -741,18 +737,18 @@ _InterlockedXor64(__int64 volatile *_Value, __int64 _Mask) { /*----------------------------------------------------------------------------*\ |* Interlocked Exchange \*----------------------------------------------------------------------------*/ -static __inline__ char DEFAULT_FN_ATTRS +static __inline__ char __DEFAULT_FN_ATTRS _InterlockedExchange8(char volatile *_Target, char _Value) { __atomic_exchange(_Target, &_Value, &_Value, 0); return _Value; } -static __inline__ short DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __int64 __DEFAULT_FN_ATTRS _InterlockedExchange64(__int64 volatile *_Target, __int64 _Value) { __atomic_exchange(_Target, &_Value, &_Value, 0); return _Value; @@ -761,19 +757,19 @@ _InterlockedExchange64(__int64 volatile *_Target, __int64 _Value) { /*----------------------------------------------------------------------------*\ |* Interlocked Compare Exchange \*----------------------------------------------------------------------------*/ -static __inline__ char DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __int64 __DEFAULT_FN_ATTRS _InterlockedCompareExchange64(__int64 volatile *_Destination, __int64 _Exchange, __int64 _Comparand) { __atomic_compare_exchange(_Destination, &_Comparand, &_Exchange, 0, 0, 0); @@ -783,24 +779,24 @@ _InterlockedCompareExchange64(__int64 volatile *_Destination, |* Barriers \*----------------------------------------------------------------------------*/ #if defined(__i386__) || defined(__x86_64__) -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS __attribute__((__deprecated__("use other intrinsics or C++11 atomics instead"))) _ReadWriteBarrier(void) { __asm__ volatile ("" : : : "memory"); } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS __attribute__((__deprecated__("use other intrinsics or C++11 atomics instead"))) _ReadBarrier(void) { __asm__ volatile ("" : : : "memory"); } -static __inline__ void DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS __faststorefence(void) { __asm__ volatile("lock orq $0, (%%rsp)" : : : "memory"); } @@ -815,33 +811,33 @@ __faststorefence(void) { (__offset)) #ifdef __i386__ -static __inline__ unsigned char DEFAULT_FN_ATTRS +static __inline__ unsigned char __DEFAULT_FN_ATTRS __readfsbyte(unsigned long __offset) { return *__ptr_to_addr_space(257, unsigned char, __offset); } -static __inline__ unsigned __int64 DEFAULT_FN_ATTRS +static __inline__ unsigned __int64 __DEFAULT_FN_ATTRS __readfsqword(unsigned long __offset) { return *__ptr_to_addr_space(257, unsigned __int64, __offset); } -static __inline__ unsigned short DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ unsigned char __DEFAULT_FN_ATTRS __readgsbyte(unsigned long __offset) { return *__ptr_to_addr_space(256, unsigned char, __offset); } -static __inline__ unsigned long DEFAULT_FN_ATTRS +static __inline__ unsigned long __DEFAULT_FN_ATTRS __readgsdword(unsigned long __offset) { return *__ptr_to_addr_space(256, unsigned long, __offset); } -static __inline__ unsigned __int64 DEFAULT_FN_ATTRS +static __inline__ unsigned __int64 __DEFAULT_FN_ATTRS __readgsqword(unsigned long __offset) { return *__ptr_to_addr_space(256, unsigned __int64, __offset); } -static __inline__ unsigned short DEFAULT_FN_ATTRS +static __inline__ unsigned short __DEFAULT_FN_ATTRS __readgsword(unsigned long __offset) { return *__ptr_to_addr_space(256, unsigned short, __offset); } @@ -851,44 +847,44 @@ __readgsword(unsigned long __offset) { |* movs, stos \*----------------------------------------------------------------------------*/ #if defined(__i386__) || defined(__x86_64__) -static __inline__ void DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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"); @@ -898,32 +894,32 @@ __stosq(unsigned __int64 *__dst, unsigned __int64 __x, size_t __n) { /*----------------------------------------------------------------------------*\ |* Misc \*----------------------------------------------------------------------------*/ -static __inline__ void * DEFAULT_FN_ATTRS +static __inline__ void * __DEFAULT_FN_ATTRS _AddressOfReturnAddress(void) { return (void*)((char*)__builtin_frame_address(0) + sizeof(void*)); } -static __inline__ void * DEFAULT_FN_ATTRS +static __inline__ void * __DEFAULT_FN_ATTRS _ReturnAddress(void) { return __builtin_return_address(0); } #if defined(__i386__) || defined(__x86_64__) -static __inline__ void DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS __halt(void) { __asm__ volatile ("hlt"); } @@ -933,7 +929,7 @@ __halt(void) { |* Privileged intrinsics \*----------------------------------------------------------------------------*/ #if defined(__i386__) || defined(__x86_64__) -static __inline__ unsigned __int64 DEFAULT_FN_ATTRS +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 @@ -947,14 +943,14 @@ __readmsr(unsigned long __register) { return (((unsigned __int64)__edx) << 32) | (unsigned __int64)__eax; } -static __inline__ unsigned long DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS __writecr3(unsigned int __cr3_val) { __asm__ ("mov %0, %%cr3" : : "q"(__cr3_val) : "memory"); } @@ -964,7 +960,7 @@ __writecr3(unsigned int __cr3_val) { } #endif -#undef DEFAULT_FN_ATTRS +#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 17b3f1d55f76..81b2b8d0b0a4 100644 --- a/lib/Headers/__wmmintrin_aes.h +++ b/lib/Headers/__wmmintrin_aes.h @@ -26,33 +26,33 @@ #include <emmintrin.h> /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("aes"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("aes"))) -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_aesenc_si128(__m128i __V, __m128i __R) { return (__m128i)__builtin_ia32_aesenc128(__V, __R); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_aesenclast_si128(__m128i __V, __m128i __R) { return (__m128i)__builtin_ia32_aesenclast128(__V, __R); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_aesdec_si128(__m128i __V, __m128i __R) { return (__m128i)__builtin_ia32_aesdec128(__V, __R); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_aesdeclast_si128(__m128i __V, __m128i __R) { return (__m128i)__builtin_ia32_aesdeclast128(__V, __R); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_aesimc_si128(__m128i __V) { return (__m128i)__builtin_ia32_aesimc128(__V); @@ -61,6 +61,6 @@ _mm_aesimc_si128(__m128i __V) #define _mm_aeskeygenassist_si128(C, R) \ __builtin_ia32_aeskeygenassist128((C), (R)) -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* _WMMINTRIN_AES_H */ diff --git a/lib/Headers/adxintrin.h b/lib/Headers/adxintrin.h index 050dc8aea8b9..ee347284178e 100644 --- a/lib/Headers/adxintrin.h +++ b/lib/Headers/adxintrin.h @@ -29,7 +29,7 @@ #define __ADXINTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__)) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__)) /* Intrinsics that are available only if __ADX__ defined */ static __inline unsigned char __attribute__((__always_inline__, __nodebug__, __target__("adx"))) @@ -49,7 +49,7 @@ _addcarryx_u64(unsigned char __cf, unsigned long long __x, #endif /* Intrinsics that are also available if __ADX__ undefined */ -static __inline unsigned char DEFAULT_FN_ATTRS +static __inline unsigned char __DEFAULT_FN_ATTRS _addcarry_u32(unsigned char __cf, unsigned int __x, unsigned int __y, unsigned int *__p) { @@ -57,7 +57,7 @@ _addcarry_u32(unsigned char __cf, unsigned int __x, unsigned int __y, } #ifdef __x86_64__ -static __inline unsigned char DEFAULT_FN_ATTRS +static __inline unsigned char __DEFAULT_FN_ATTRS _addcarry_u64(unsigned char __cf, unsigned long long __x, unsigned long long __y, unsigned long long *__p) { @@ -65,7 +65,7 @@ _addcarry_u64(unsigned char __cf, unsigned long long __x, } #endif -static __inline unsigned char DEFAULT_FN_ATTRS +static __inline unsigned char __DEFAULT_FN_ATTRS _subborrow_u32(unsigned char __cf, unsigned int __x, unsigned int __y, unsigned int *__p) { @@ -73,7 +73,7 @@ _subborrow_u32(unsigned char __cf, unsigned int __x, unsigned int __y, } #ifdef __x86_64__ -static __inline unsigned char DEFAULT_FN_ATTRS +static __inline unsigned char __DEFAULT_FN_ATTRS _subborrow_u64(unsigned char __cf, unsigned long long __x, unsigned long long __y, unsigned long long *__p) { @@ -81,6 +81,6 @@ _subborrow_u64(unsigned char __cf, unsigned long long __x, } #endif -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __ADXINTRIN_H */ diff --git a/lib/Headers/altivec.h b/lib/Headers/altivec.h index 28df89057205..2c80e24db335 100644 --- a/lib/Headers/altivec.h +++ b/lib/Headers/altivec.h @@ -110,14 +110,28 @@ static vector signed int __ATTRS_o_ai vec_abs(vector signed int __a) { return __builtin_altivec_vmaxsw(__a, -__a); } +#if defined(__POWER8_VECTOR__) && defined(__powerpc64__) +static vector signed long long __ATTRS_o_ai +vec_abs(vector signed long long __a) { + return __builtin_altivec_vmaxsd(__a, -__a); +} +#endif + static vector float __ATTRS_o_ai vec_abs(vector float __a) { vector unsigned int __res = (vector unsigned int)__a & (vector unsigned int)(0x7FFFFFFF); return (vector float)__res; } -/* vec_abss */ +#if defined(__POWER8_VECTOR__) && defined(__powerpc64__) +static vector double __ATTRS_o_ai vec_abs(vector double __a) { + vector unsigned long long __res = { 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF }; + __res &= (vector unsigned int)__a; + return (vector double)__res; +} +#endif +/* vec_abss */ #define __builtin_altivec_abss_v16qi vec_abss #define __builtin_altivec_abss_v8hi vec_abss #define __builtin_altivec_abss_v4si vec_abss @@ -226,6 +240,16 @@ static vector unsigned int __ATTRS_o_ai vec_add(vector unsigned int __a, } #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) +static vector signed long long __ATTRS_o_ai +vec_add(vector signed long long __a, vector signed long long __b) { + return __a + __b; +} + +static vector unsigned long long __ATTRS_o_ai +vec_add(vector unsigned long long __a, vector unsigned long long __b) { + return __a + __b; +} + static vector signed __int128 __ATTRS_o_ai vec_add(vector signed __int128 __a, vector signed __int128 __b) { return __a + __b; @@ -241,6 +265,13 @@ static vector float __ATTRS_o_ai vec_add(vector float __a, vector float __b) { return __a + __b; } +#ifdef __VSX__ +static vector double __ATTRS_o_ai +vec_add(vector double __a, vector double __b) { + return __a + __b; +} +#endif // __VSX__ + /* vec_vaddubm */ #define __builtin_altivec_vaddubm vec_vaddubm @@ -746,6 +777,24 @@ static vector float __ATTRS_o_ai vec_and(vector float __a, } #ifdef __VSX__ +static vector double __ATTRS_o_ai vec_and(vector bool long long __a, vector double __b) { + vector unsigned long long __res = + (vector unsigned long long)__a & (vector unsigned long long)__b; + return (vector double)__res; +} + +static vector double __ATTRS_o_ai vec_and(vector double __a, vector bool long long __b) { + vector unsigned long long __res = + (vector unsigned long long)__a & (vector unsigned long long)__b; + return (vector double)__res; +} + +static vector double __ATTRS_o_ai vec_and(vector double __a, vector double __b) { + vector unsigned long long __res = + (vector unsigned long long)__a & (vector unsigned long long)__b; + return (vector double)__res; +} + static vector signed long long __ATTRS_o_ai vec_and(vector signed long long __a, vector signed long long __b) { return __a & __b; @@ -1068,6 +1117,26 @@ static vector float __ATTRS_o_ai vec_andc(vector float __a, } #ifdef __VSX__ +static vector double __ATTRS_o_ai +vec_andc(vector bool long long __a, vector double __b) { + vector unsigned long long __res = + (vector unsigned long long)__a & ~(vector unsigned long long)__b; + return (vector double)__res; +} + +static vector double __ATTRS_o_ai +vec_andc(vector double __a, vector bool long long __b) { + vector unsigned long long __res = + (vector unsigned long long)__a & ~(vector unsigned long long)__b; + return (vector double)__res; +} + +static vector double __ATTRS_o_ai vec_andc(vector double __a, vector double __b) { + vector unsigned long long __res = + (vector unsigned long long)__a & ~(vector unsigned long long)__b; + return (vector double)__res; +} + static vector signed long long __ATTRS_o_ai vec_andc(vector signed long long __a, vector signed long long __b) { return __a & ~__b; @@ -1338,11 +1407,20 @@ vec_vavguw(vector unsigned int __a, vector unsigned int __b) { /* vec_ceil */ -static vector float __attribute__((__always_inline__)) -vec_ceil(vector float __a) { +static vector float __ATTRS_o_ai vec_ceil(vector float __a) { +#ifdef __VSX__ + return __builtin_vsx_xvrspip(__a); +#else return __builtin_altivec_vrfip(__a); +#endif } +#ifdef __VSX__ +static vector double __ATTRS_o_ai vec_ceil(vector double __a) { + return __builtin_vsx_xvrdpip(__a); +} +#endif + /* vec_vrfip */ static vector float __attribute__((__always_inline__)) @@ -1414,16 +1492,56 @@ vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) { static vector bool int __ATTRS_o_ai vec_cmpeq(vector float __a, vector float __b) { +#ifdef __VSX__ + return (vector bool int)__builtin_vsx_xvcmpeqsp(__a, __b); +#else return (vector bool int)__builtin_altivec_vcmpeqfp(__a, __b); +#endif +} + +#ifdef __VSX__ +static vector bool long long __ATTRS_o_ai +vec_cmpeq(vector double __a, vector double __b) { + return (vector bool long long)__builtin_vsx_xvcmpeqdp(__a, __b); } +#endif /* vec_cmpge */ -static vector bool int __attribute__((__always_inline__)) +static vector bool int __ATTRS_o_ai vec_cmpge(vector float __a, vector float __b) { +#ifdef __VSX__ + return (vector bool int)__builtin_vsx_xvcmpgesp(__a, __b); +#else return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b); +#endif } +#ifdef __VSX__ +static vector bool long long __ATTRS_o_ai +vec_cmpge(vector double __a, vector double __b) { + return (vector bool long long)__builtin_vsx_xvcmpgedp(__a, __b); +} +#endif + +#ifdef __POWER8_VECTOR__ +/* Forwrad declarations as the functions are used here */ +static vector bool long long __ATTRS_o_ai +vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b); +static vector bool long long __ATTRS_o_ai +vec_cmpgt(vector signed long long __a, vector signed long long __b); + +static vector bool long long __ATTRS_o_ai +vec_cmpge(vector signed long long __a, vector signed long long __b) { + return ~(vec_cmpgt(__b, __a)); +} + +static vector bool long long __ATTRS_o_ai +vec_cmpge(vector unsigned long long __a, vector unsigned long long __b) { + return ~(vec_cmpgt(__b, __a)); +} +#endif + /* vec_vcmpgefp */ static vector bool int __attribute__((__always_inline__)) @@ -1476,9 +1594,19 @@ vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) { static vector bool int __ATTRS_o_ai vec_cmpgt(vector float __a, vector float __b) { +#ifdef __VSX__ + return (vector bool int)__builtin_vsx_xvcmpgtsp(__a, __b); +#else return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b); +#endif } +#ifdef __VSX__ +static vector bool long long __ATTRS_o_ai +vec_cmpgt(vector double __a, vector double __b) { + return (vector bool long long)__builtin_vsx_xvcmpgtdp(__a, __b); +} +#endif /* vec_vcmpgtsb */ static vector bool char __attribute__((__always_inline__)) @@ -1530,47 +1658,85 @@ vec_vcmpgtfp(vector float __a, vector float __b) { /* vec_cmple */ -static vector bool int __attribute__((__always_inline__)) +static vector bool int __ATTRS_o_ai vec_cmple(vector float __a, vector float __b) { - return (vector bool int)__builtin_altivec_vcmpgefp(__b, __a); + return vec_cmpge(__b, __a); } +#ifdef __VSX__ +static vector bool long long __ATTRS_o_ai +vec_cmple(vector double __a, vector double __b) { + return vec_cmpge(__b, __a); +} +#endif + +#ifdef __POWER8_VECTOR__ +static vector bool long long __ATTRS_o_ai +vec_cmple(vector signed long long __a, vector signed long long __b) { + return vec_cmpge(__b, __a); +} + +static vector bool long long __ATTRS_o_ai +vec_cmple(vector unsigned long long __a, vector unsigned long long __b) { + return vec_cmpge(__b, __a); +} +#endif + /* vec_cmplt */ static vector bool char __ATTRS_o_ai vec_cmplt(vector signed char __a, vector signed char __b) { - return (vector bool char)__builtin_altivec_vcmpgtsb(__b, __a); + return vec_cmpgt(__b, __a); } static vector bool char __ATTRS_o_ai vec_cmplt(vector unsigned char __a, vector unsigned char __b) { - return (vector bool char)__builtin_altivec_vcmpgtub(__b, __a); + return vec_cmpgt(__b, __a); } static vector bool short __ATTRS_o_ai vec_cmplt(vector short __a, vector short __b) { - return (vector bool short)__builtin_altivec_vcmpgtsh(__b, __a); + return vec_cmpgt(__b, __a); } static vector bool short __ATTRS_o_ai vec_cmplt(vector unsigned short __a, vector unsigned short __b) { - return (vector bool short)__builtin_altivec_vcmpgtuh(__b, __a); + return vec_cmpgt(__b, __a); } static vector bool int __ATTRS_o_ai vec_cmplt(vector int __a, vector int __b) { - return (vector bool int)__builtin_altivec_vcmpgtsw(__b, __a); + return vec_cmpgt(__b, __a); } static vector bool int __ATTRS_o_ai vec_cmplt(vector unsigned int __a, vector unsigned int __b) { - return (vector bool int)__builtin_altivec_vcmpgtuw(__b, __a); + return vec_cmpgt(__b, __a); } static vector bool int __ATTRS_o_ai vec_cmplt(vector float __a, vector float __b) { - return (vector bool int)__builtin_altivec_vcmpgtfp(__b, __a); + return vec_cmpgt(__b, __a); +} + +#ifdef __VSX__ +static vector bool long long __ATTRS_o_ai +vec_cmplt(vector double __a, vector double __b) { + return vec_cmpgt(__b, __a); +} +#endif + +#ifdef __POWER8_VECTOR__ +static vector bool long long __ATTRS_o_ai +vec_cmplt(vector signed long long __a, vector signed long long __b) { + return vec_cmpgt(__b, __a); } +static vector bool long long __ATTRS_o_ai +vec_cmplt(vector unsigned long long __a, vector unsigned long long __b) { + return vec_cmpgt(__b, __a); +} +#endif + /* vec_ctf */ static vector float __ATTRS_o_ai vec_ctf(vector int __a, int __b) { @@ -3014,6 +3180,56 @@ static vector float __ATTRS_o_ai vec_vmrglw(vector float __a, 0x1C, 0x1D, 0x1E, 0x1F)); } + +#ifdef __POWER8_VECTOR__ +/* vec_mergee */ + +static vector bool int __ATTRS_o_ai +vec_mergee(vector bool int __a, vector bool int __b) { + return vec_perm(__a, __b, (vector unsigned char) + (0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13, + 0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19, 0x1A, 0x1B)); +} + +static vector signed int __ATTRS_o_ai +vec_mergee(vector signed int __a, vector signed int __b) { + return vec_perm(__a, __b, (vector unsigned char) + (0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13, + 0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19, 0x1A, 0x1B)); +} + +static vector unsigned int __ATTRS_o_ai +vec_mergee(vector unsigned int __a, vector unsigned int __b) { + return vec_perm(__a, __b, (vector unsigned char) + (0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13, + 0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19, 0x1A, 0x1B)); +} + +/* vec_mergeo */ + +static vector bool int __ATTRS_o_ai +vec_mergeo(vector bool int __a, vector bool int __b) { + return vec_perm(__a, __b, (vector unsigned char) + (0x04, 0x05, 0x06, 0x07, 0x14, 0x15, 0x16, 0x17, + 0x0C, 0x0D, 0x0E, 0x0F, 0x1C, 0x1D, 0x1E, 0x1F)); +} + +static vector signed int __ATTRS_o_ai +vec_mergeo(vector signed int __a, vector signed int __b) { + return vec_perm(__a, __b, (vector unsigned char) + (0x04, 0x05, 0x06, 0x07, 0x14, 0x15, 0x16, 0x17, + 0x0C, 0x0D, 0x0E, 0x0F, 0x1C, 0x1D, 0x1E, 0x1F)); +} + +static vector unsigned int __ATTRS_o_ai +vec_mergeo(vector unsigned int __a, vector unsigned int __b) { + return vec_perm(__a, __b, (vector unsigned char) + (0x04, 0x05, 0x06, 0x07, 0x14, 0x15, 0x16, 0x17, + 0x0C, 0x0D, 0x0E, 0x0F, 0x1C, 0x1D, 0x1E, 0x1F)); +} + +#endif + /* vec_mfvscr */ static vector unsigned short __attribute__((__always_inline__)) diff --git a/lib/Headers/ammintrin.h b/lib/Headers/ammintrin.h index 3f3820576671..91c633305b8b 100644 --- a/lib/Headers/ammintrin.h +++ b/lib/Headers/ammintrin.h @@ -27,7 +27,7 @@ #include <pmmintrin.h> /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse4a"))) +#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. @@ -80,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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_extract_si64(__m128i __x, __m128i __y) { return (__m128i)__builtin_ia32_extrq((__v2di)__x, (__v16qi)__y); @@ -156,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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_insert_si64(__m128i __x, __m128i __y) { return (__m128i)__builtin_ia32_insertq((__v2di)__x, (__v2di)__y); @@ -177,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 DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_stream_sd(double *__p, __m128d __a) { __builtin_ia32_movntsd(__p, (__v2df)__a); @@ -198,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 DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_stream_ss(float *__p, __m128 __a) { __builtin_ia32_movntss(__p, (__v4sf)__a); } -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __AMMINTRIN_H */ diff --git a/lib/Headers/avx2intrin.h b/lib/Headers/avx2intrin.h index 5f1817e45a7a..cfa91410a338 100644 --- a/lib/Headers/avx2intrin.h +++ b/lib/Headers/avx2intrin.h @@ -29,96 +29,96 @@ #define __AVX2INTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx2"))) +#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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_abs_epi8(__m256i __a) { return (__m256i)__builtin_ia32_pabsb256((__v32qi)__a); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_abs_epi16(__m256i __a) { return (__m256i)__builtin_ia32_pabsw256((__v16hi)__a); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_abs_epi32(__m256i __a) { return (__m256i)__builtin_ia32_pabsd256((__v8si)__a); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_add_epi8(__m256i __a, __m256i __b) { return (__m256i)((__v32qi)__a + (__v32qi)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_add_epi16(__m256i __a, __m256i __b) { return (__m256i)((__v16hi)__a + (__v16hi)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_add_epi32(__m256i __a, __m256i __b) { return (__m256i)((__v8si)__a + (__v8si)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_add_epi64(__m256i __a, __m256i __b) { return __a + __b; } -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_adds_epu16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_paddusw256((__v16hi)__a, (__v16hi)__b); @@ -129,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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_and_si256(__m256i __a, __m256i __b) { return __a & __b; } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_andnot_si256(__m256i __a, __m256i __b) { return ~__a & __b; } -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_blendv_epi8(__m256i __V1, __m256i __V2, __m256i __M) { return (__m256i)__builtin_ia32_pblendvb256((__v32qi)__V1, (__v32qi)__V2, @@ -181,307 +181,307 @@ _mm256_blendv_epi8(__m256i __V1, __m256i __V2, __m256i __M) (((M) & 0x40) ? 30 : 14), \ (((M) & 0x80) ? 31 : 15)); }) -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cmpeq_epi8(__m256i __a, __m256i __b) { return (__m256i)((__v32qi)__a == (__v32qi)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cmpeq_epi16(__m256i __a, __m256i __b) { return (__m256i)((__v16hi)__a == (__v16hi)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cmpeq_epi32(__m256i __a, __m256i __b) { return (__m256i)((__v8si)__a == (__v8si)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cmpeq_epi64(__m256i __a, __m256i __b) { return (__m256i)(__a == __b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cmpgt_epi8(__m256i __a, __m256i __b) { return (__m256i)((__v32qi)__a > (__v32qi)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cmpgt_epi16(__m256i __a, __m256i __b) { return (__m256i)((__v16hi)__a > (__v16hi)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cmpgt_epi32(__m256i __a, __m256i __b) { return (__m256i)((__v8si)__a > (__v8si)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cmpgt_epi64(__m256i __a, __m256i __b) { return (__m256i)(__a > __b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm256_movemask_epi8(__m256i __a) { return __builtin_ia32_pmovmskb256((__v32qi)__a); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cvtepi8_epi16(__m128i __V) { return (__m256i)__builtin_ia32_pmovsxbw256((__v16qi)__V); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cvtepi8_epi32(__m128i __V) { return (__m256i)__builtin_ia32_pmovsxbd256((__v16qi)__V); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cvtepi8_epi64(__m128i __V) { return (__m256i)__builtin_ia32_pmovsxbq256((__v16qi)__V); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cvtepi16_epi32(__m128i __V) { return (__m256i)__builtin_ia32_pmovsxwd256((__v8hi)__V); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cvtepi16_epi64(__m128i __V) { return (__m256i)__builtin_ia32_pmovsxwq256((__v8hi)__V); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cvtepi32_epi64(__m128i __V) { return (__m256i)__builtin_ia32_pmovsxdq256((__v4si)__V); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cvtepu8_epi16(__m128i __V) { return (__m256i)__builtin_ia32_pmovzxbw256((__v16qi)__V); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cvtepu8_epi32(__m128i __V) { return (__m256i)__builtin_ia32_pmovzxbd256((__v16qi)__V); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cvtepu8_epi64(__m128i __V) { return (__m256i)__builtin_ia32_pmovzxbq256((__v16qi)__V); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cvtepu16_epi32(__m128i __V) { return (__m256i)__builtin_ia32_pmovzxwd256((__v8hi)__V); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cvtepu16_epi64(__m128i __V) { return (__m256i)__builtin_ia32_pmovzxwq256((__v8hi)__V); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_cvtepu32_epi64(__m128i __V) { return (__m256i)__builtin_ia32_pmovzxdq256((__v4si)__V); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mullo_epi16(__m256i __a, __m256i __b) { return (__m256i)((__v16hi)__a * (__v16hi)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mullo_epi32 (__m256i __a, __m256i __b) { return (__m256i)((__v8si)__a * (__v8si)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mul_epu32(__m256i __a, __m256i __b) { return __builtin_ia32_pmuludq256((__v8si)__a, (__v8si)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_or_si256(__m256i __a, __m256i __b) { return __a | __b; } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_sad_epu8(__m256i __a, __m256i __b) { return __builtin_ia32_psadbw256((__v32qi)__a, (__v32qi)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_shuffle_epi8(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pshufb256((__v32qi)__a, (__v32qi)__b); @@ -523,19 +523,19 @@ _mm256_shuffle_epi8(__m256i __a, __m256i __b) 8 + (((imm) & 0xc0) >> 6), \ 12, 13, 14, 15); }) -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_sign_epi32(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_psignd256((__v8si)__a, (__v8si)__b); @@ -547,61 +547,61 @@ _mm256_sign_epi32(__m256i __a, __m256i __b) #define _mm256_bslli_epi128(a, count) _mm256_slli_si256((a), (count)) -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_slli_epi16(__m256i __a, int __count) { return (__m256i)__builtin_ia32_psllwi256((__v16hi)__a, __count); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_slli_epi32(__m256i __a, int __count) { return (__m256i)__builtin_ia32_pslldi256((__v8si)__a, __count); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_slli_epi64(__m256i __a, int __count) { return __builtin_ia32_psllqi256(__a, __count); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_sll_epi64(__m256i __a, __m128i __count) { return __builtin_ia32_psllq256(__a, __count); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_srai_epi16(__m256i __a, int __count) { return (__m256i)__builtin_ia32_psrawi256((__v16hi)__a, __count); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_srai_epi32(__m256i __a, int __count) { return (__m256i)__builtin_ia32_psradi256((__v8si)__a, __count); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_sra_epi32(__m256i __a, __m128i __count) { return (__m256i)__builtin_ia32_psrad256((__v8si)__a, (__v4si)__count); @@ -613,175 +613,175 @@ _mm256_sra_epi32(__m256i __a, __m128i __count) #define _mm256_bsrli_epi128(a, count) _mm256_srli_si256((a), (count)) -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_srli_epi16(__m256i __a, int __count) { return (__m256i)__builtin_ia32_psrlwi256((__v16hi)__a, __count); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_srli_epi32(__m256i __a, int __count) { return (__m256i)__builtin_ia32_psrldi256((__v8si)__a, __count); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_srli_epi64(__m256i __a, int __count) { return __builtin_ia32_psrlqi256(__a, __count); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_srl_epi64(__m256i __a, __m128i __count) { return __builtin_ia32_psrlq256(__a, __count); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_sub_epi8(__m256i __a, __m256i __b) { return (__m256i)((__v32qi)__a - (__v32qi)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_sub_epi16(__m256i __a, __m256i __b) { return (__m256i)((__v16hi)__a - (__v16hi)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_sub_epi32(__m256i __a, __m256i __b) { return (__m256i)((__v8si)__a - (__v8si)__b); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_sub_epi64(__m256i __a, __m256i __b) { return __a - __b; } -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_xor_si256(__m256i __a, __m256i __b) { return __a ^ __b; } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_stream_load_si256(__m256i *__V) { return (__m256i)__builtin_ia32_movntdqa256((__v4di *)__V); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_broadcastss_ps(__m128 __X) { return (__m128)__builtin_ia32_vbroadcastss_ps((__v4sf)__X); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_broadcastsd_pd(__m128d __a) { return __builtin_shufflevector(__a, __a, 0, 0); } -static __inline__ __m256 DEFAULT_FN_ATTRS +static __inline__ __m256 __DEFAULT_FN_ATTRS _mm256_broadcastss_ps(__m128 __X) { return (__m256)__builtin_ia32_vbroadcastss_ps256((__v4sf)__X); } -static __inline__ __m256d DEFAULT_FN_ATTRS +static __inline__ __m256d __DEFAULT_FN_ATTRS _mm256_broadcastsd_pd(__m128d __X) { return (__m256d)__builtin_ia32_vbroadcastsd_pd256((__v2df)__X); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_broadcastsi128_si256(__m128i __X) { return (__m256i)__builtin_shufflevector(__X, __X, 0, 1, 0, 1); @@ -809,56 +809,56 @@ _mm256_broadcastsi128_si256(__m128i __X) (((M) & 0x40) ? 14 : 6), \ (((M) & 0x80) ? 15 : 7)); }) -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_broadcastb_epi8(__m128i __X) { return (__m256i)__builtin_ia32_pbroadcastb256((__v16qi)__X); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_broadcastw_epi16(__m128i __X) { return (__m256i)__builtin_ia32_pbroadcastw256((__v8hi)__X); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_broadcastd_epi32(__m128i __X) { return (__m256i)__builtin_ia32_pbroadcastd256((__v4si)__X); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_broadcastq_epi64(__m128i __X) { return (__m256i)__builtin_ia32_pbroadcastq256(__X); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_broadcastb_epi8(__m128i __X) { return (__m128i)__builtin_ia32_pbroadcastb128((__v16qi)__X); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_broadcastw_epi16(__m128i __X) { return (__m128i)__builtin_ia32_pbroadcastw128((__v8hi)__X); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_broadcastd_epi32(__m128i __X) { return (__m128i)__builtin_ia32_pbroadcastd128((__v4si)__X); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_broadcastq_epi64(__m128i __X) { return (__m128i)__builtin_ia32_pbroadcastq128(__X); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_permutevar8x32_epi32(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_permvarsi256((__v8si)__a, (__v8si)__b); @@ -870,7 +870,7 @@ _mm256_permutevar8x32_epi32(__m256i __a, __m256i __b) (M) & 0x3, ((M) & 0xc) >> 2, \ ((M) & 0x30) >> 4, ((M) & 0xc0) >> 6); }) -static __inline__ __m256 DEFAULT_FN_ATTRS +static __inline__ __m256 __DEFAULT_FN_ATTRS _mm256_permutevar8x32_ps(__m256 __a, __m256 __b) { return (__m256)__builtin_ia32_permvarsf256((__v8sf)__a, (__v8sf)__b); @@ -903,109 +903,109 @@ _mm256_permutevar8x32_ps(__m256 __a, __m256 __b) (((M) & 1) ? 4 : 2), \ (((M) & 1) ? 5 : 3) );}) -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_sllv_epi64(__m256i __X, __m256i __Y) { return (__m256i)__builtin_ia32_psllv4di(__X, __Y); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sllv_epi64(__m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_psllv2di(__X, __Y); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_srlv_epi64(__m256i __X, __m256i __Y) { return (__m256i)__builtin_ia32_psrlv4di(__X, __Y); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srlv_epi64(__m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_psrlv2di(__X, __Y); @@ -1251,6 +1251,6 @@ _mm_srlv_epi64(__m128i __X, __m128i __Y) (const __v4di *)__m, (__v4di)__i, \ (__v4di)_mm256_set1_epi64x(-1), (s)); }) -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __AVX2INTRIN_H */ diff --git a/lib/Headers/avx512bwintrin.h b/lib/Headers/avx512bwintrin.h index 4eb97471781e..b0d3462d4db6 100644 --- a/lib/Headers/avx512bwintrin.h +++ b/lib/Headers/avx512bwintrin.h @@ -34,9 +34,9 @@ typedef char __v64qi __attribute__ ((__vector_size__ (64))); typedef short __v32hi __attribute__ ((__vector_size__ (64))); /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512bw"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512bw"))) -static __inline __v64qi DEFAULT_FN_ATTRS +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, @@ -48,7 +48,7 @@ _mm512_setzero_qi (void) { 0, 0, 0, 0, 0, 0, 0, 0 }; } -static __inline __v32hi DEFAULT_FN_ATTRS +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, @@ -58,300 +58,300 @@ _mm512_setzero_hi (void) { /* Integer compare */ -static __inline__ __mmask64 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_add_epi8 (__m512i __A, __m512i __B) { return (__m512i) ((__v64qi) __A + (__v64qi) __B); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -359,7 +359,7 @@ _mm512_mask_add_epi8 (__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { (__mmask64) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -368,12 +368,12 @@ _mm512_maskz_add_epi8 (__mmask64 __U, __m512i __A, __m512i __B) { (__mmask64) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_sub_epi8 (__m512i __A, __m512i __B) { return (__m512i) ((__v64qi) __A - (__v64qi) __B); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -381,7 +381,7 @@ _mm512_mask_sub_epi8 (__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { (__mmask64) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -390,12 +390,12 @@ _mm512_maskz_sub_epi8 (__mmask64 __U, __m512i __A, __m512i __B) { (__mmask64) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_add_epi16 (__m512i __A, __m512i __B) { return (__m512i) ((__v32hi) __A + (__v32hi) __B); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -403,7 +403,7 @@ _mm512_mask_add_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { (__mmask32) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -412,12 +412,12 @@ _mm512_maskz_add_epi16 (__mmask32 __U, __m512i __A, __m512i __B) { (__mmask32) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_sub_epi16 (__m512i __A, __m512i __B) { return (__m512i) ((__v32hi) __A - (__v32hi) __B); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -425,7 +425,7 @@ _mm512_mask_sub_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { (__mmask32) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -434,12 +434,12 @@ _mm512_maskz_sub_epi16 (__mmask32 __U, __m512i __A, __m512i __B) { (__mmask32) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_mullo_epi16 (__m512i __A, __m512i __B) { return (__m512i) ((__v32hi) __A * (__v32hi) __B); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -447,7 +447,7 @@ _mm512_mask_mullo_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { (__mmask32) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -456,6 +456,754 @@ _mm512_maskz_mullo_epi16 (__mmask32 __U, __m512i __A, __m512i __B) { (__mmask32) __U); } +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_blend_epi8 (__mmask64 __U, __m512i __A, __m512i __W) +{ + return (__m512i) __builtin_ia32_blendmb_512_mask ((__v64qi) __A, + (__v64qi) __W, + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_blend_epi16 (__mmask32 __U, __m512i __A, __m512i __W) +{ + return (__m512i) __builtin_ia32_blendmw_512_mask ((__v32hi) __A, + (__v32hi) __W, + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_abs_epi8 (__m512i __A) +{ + return (__m512i) __builtin_ia32_pabsb512_mask ((__v64qi) __A, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_abs_epi8 (__m512i __W, __mmask64 __U, __m512i __A) +{ + return (__m512i) __builtin_ia32_pabsb512_mask ((__v64qi) __A, + (__v64qi) __W, + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_abs_epi8 (__mmask64 __U, __m512i __A) +{ + return (__m512i) __builtin_ia32_pabsb512_mask ((__v64qi) __A, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_abs_epi16 (__m512i __A) +{ + return (__m512i) __builtin_ia32_pabsw512_mask ((__v32hi) __A, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_abs_epi16 (__m512i __W, __mmask32 __U, __m512i __A) +{ + return (__m512i) __builtin_ia32_pabsw512_mask ((__v32hi) __A, + (__v32hi) __W, + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_abs_epi16 (__mmask32 __U, __m512i __A) +{ + return (__m512i) __builtin_ia32_pabsw512_mask ((__v32hi) __A, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_packs_epi32 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_packssdw512_mask ((__v16si) __A, + (__v16si) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_packs_epi32 (__mmask32 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_packssdw512_mask ((__v16si) __A, + (__v16si) __B, + (__v32hi) _mm512_setzero_hi(), + __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_packs_epi32 (__m512i __W, __mmask32 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_packssdw512_mask ((__v16si) __A, + (__v16si) __B, + (__v32hi) __W, + __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_packs_epi16 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_packsswb512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_packs_epi16 (__m512i __W, __mmask64 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_packsswb512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v64qi) __W, + (__mmask64) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_packs_epi16 (__mmask64 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_packsswb512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v64qi) _mm512_setzero_qi(), + __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_packus_epi32 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_packusdw512_mask ((__v16si) __A, + (__v16si) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_packus_epi32 (__mmask32 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_packusdw512_mask ((__v16si) __A, + (__v16si) __B, + (__v32hi) _mm512_setzero_hi(), + __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_packus_epi32 (__m512i __W, __mmask32 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_packusdw512_mask ((__v16si) __A, + (__v16si) __B, + (__v32hi) __W, + __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_packus_epi16 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_packuswb512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_packus_epi16 (__m512i __W, __mmask64 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_packuswb512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v64qi) __W, + (__mmask64) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_packus_epi16 (__mmask64 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_packuswb512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v64qi) _mm512_setzero_qi(), + (__mmask64) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_adds_epi8 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_paddsb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_adds_epi8 (__m512i __W, __mmask64 __U, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_paddsb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) __W, + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_adds_epi8 (__mmask64 __U, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_paddsb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_adds_epi16 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_paddsw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_adds_epi16 (__m512i __W, __mmask32 __U, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_paddsw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) __W, + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_adds_epi16 (__mmask32 __U, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_paddsw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_adds_epu8 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_paddusb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_adds_epu8 (__m512i __W, __mmask64 __U, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_paddusb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) __W, + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_adds_epu8 (__mmask64 __U, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_paddusb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_adds_epu16 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_paddusw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_adds_epu16 (__m512i __W, __mmask32 __U, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_paddusw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) __W, + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_adds_epu16 (__mmask32 __U, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_paddusw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_avg_epu8 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pavgb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_avg_epu8 (__m512i __W, __mmask64 __U, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_pavgb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) __W, + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_avg_epu8 (__mmask64 __U, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pavgb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi(), + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_avg_epu16 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pavgw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_avg_epu16 (__m512i __W, __mmask32 __U, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_pavgw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) __W, + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_avg_epu16 (__mmask32 __U, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pavgw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi(), + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_max_epi8 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pmaxsb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_max_epi8 (__mmask64 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pmaxsb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi(), + (__mmask64) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_max_epi8 (__m512i __W, __mmask64 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_pmaxsb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) __W, + (__mmask64) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_max_epi16 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pmaxsw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_max_epi16 (__mmask32 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pmaxsw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi(), + (__mmask32) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_max_epi16 (__m512i __W, __mmask32 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_pmaxsw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) __W, + (__mmask32) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_max_epu8 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pmaxub512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_max_epu8 (__mmask64 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pmaxub512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi(), + (__mmask64) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_max_epu8 (__m512i __W, __mmask64 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_pmaxub512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) __W, + (__mmask64) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_max_epu16 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pmaxuw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_max_epu16 (__mmask32 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pmaxuw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi(), + (__mmask32) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_max_epu16 (__m512i __W, __mmask32 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_pmaxuw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) __W, + (__mmask32) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_min_epi8 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pminsb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_min_epi8 (__mmask64 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pminsb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi(), + (__mmask64) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_min_epi8 (__m512i __W, __mmask64 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_pminsb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) __W, + (__mmask64) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_min_epi16 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pminsw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_min_epi16 (__mmask32 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pminsw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi(), + (__mmask32) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_min_epi16 (__m512i __W, __mmask32 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_pminsw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) __W, + (__mmask32) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_min_epu8 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pminub512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_min_epu8 (__mmask64 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pminub512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi(), + (__mmask64) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_min_epu8 (__m512i __W, __mmask64 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_pminub512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) __W, + (__mmask64) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_min_epu16 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pminuw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_min_epu16 (__mmask32 __M, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pminuw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi(), + (__mmask32) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_min_epu16 (__m512i __W, __mmask32 __M, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_pminuw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) __W, + (__mmask32) __M); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_shuffle_epi8 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pshufb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_shuffle_epi8 (__m512i __W, __mmask64 __U, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_pshufb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) __W, + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_shuffle_epi8 (__mmask64 __U, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_pshufb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_subs_epi8 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_psubsb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_subs_epi8 (__m512i __W, __mmask64 __U, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_psubsb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) __W, + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_subs_epi8 (__mmask64 __U, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_psubsb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_subs_epi16 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_psubsw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_subs_epi16 (__m512i __W, __mmask32 __U, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_psubsw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) __W, + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_subs_epi16 (__mmask32 __U, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_psubsw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_subs_epu8 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_psubusb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_subs_epu8 (__m512i __W, __mmask64 __U, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_psubusb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) __W, + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_subs_epu8 (__mmask64 __U, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_psubusb512_mask ((__v64qi) __A, + (__v64qi) __B, + (__v64qi) _mm512_setzero_qi (), + (__mmask64) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_subs_epu16 (__m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_psubusw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_subs_epu16 (__m512i __W, __mmask32 __U, __m512i __A, + __m512i __B) +{ + return (__m512i) __builtin_ia32_psubusw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) __W, + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_subs_epu16 (__mmask32 __U, __m512i __A, __m512i __B) +{ + return (__m512i) __builtin_ia32_psubusw512_mask ((__v32hi) __A, + (__v32hi) __B, + (__v32hi) _mm512_setzero_hi (), + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask2_permutex2var_epi16 (__m512i __A, __m512i __I, + __mmask32 __U, __m512i __B) +{ + return (__m512i) __builtin_ia32_vpermi2varhi512_mask ((__v32hi) __A, + (__v32hi) __I /* idx */ , + (__v32hi) __B, + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_permutex2var_epi16 (__m512i __A, __m512i __I, __m512i __B) +{ + return (__m512i) __builtin_ia32_vpermt2varhi512_mask ((__v32hi) __I /* idx */, + (__v32hi) __A, + (__v32hi) __B, + (__mmask32) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_permutex2var_epi16 (__m512i __A, __mmask32 __U, + __m512i __I, __m512i __B) +{ + return (__m512i) __builtin_ia32_vpermt2varhi512_mask ((__v32hi) __I /* idx */, + (__v32hi) __A, + (__v32hi) __B, + (__mmask32) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_permutex2var_epi16 (__mmask32 __U, __m512i __A, + __m512i __I, __m512i __B) +{ + return (__m512i) __builtin_ia32_vpermt2varhi512_maskz ((__v32hi) __I + /* idx */ , + (__v32hi) __A, + (__v32hi) __B, + (__mmask32) __U); +} + #define _mm512_cmp_epi8_mask(a, b, p) __extension__ ({ \ (__mmask16)__builtin_ia32_cmpb512_mask((__v64qi)(__m512i)(a), \ (__v64qi)(__m512i)(b), \ @@ -496,6 +1244,7 @@ _mm512_maskz_mullo_epi16 (__mmask32 __U, __m512i __A, __m512i __B) { (__v32hi)(__m512i)(b), \ (p), (__mmask32)(m)); }) -#undef DEFAULT_FN_ATTRS + +#undef __DEFAULT_FN_ATTRS #endif diff --git a/lib/Headers/avx512cdintrin.h b/lib/Headers/avx512cdintrin.h new file mode 100644 index 000000000000..3894b29f5725 --- /dev/null +++ b/lib/Headers/avx512cdintrin.h @@ -0,0 +1,131 @@ +/*===------------- avx512cdintrin.h - AVX512CD intrinsics ------------------=== + * + * + * 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 <avx512cdintrin.h> directly; include <immintrin.h> instead." +#endif + +#ifndef __AVX512CDINTRIN_H +#define __AVX512CDINTRIN_H + +/* Define the default attributes for the functions in this file. */ +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512cd"))) + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_conflict_epi64 (__m512i __A) +{ + return (__m512i) __builtin_ia32_vpconflictdi_512_mask ((__v8di) __A, + (__v8di) _mm512_setzero_si512 (), + (__mmask8) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_conflict_epi64 (__m512i __W, __mmask8 __U, __m512i __A) +{ + return (__m512i) __builtin_ia32_vpconflictdi_512_mask ((__v8di) __A, + (__v8di) __W, + (__mmask8) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_conflict_epi64 (__mmask8 __U, __m512i __A) +{ + return (__m512i) __builtin_ia32_vpconflictdi_512_mask ((__v8di) __A, + (__v8di) _mm512_setzero_si512 (), + (__mmask8) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_conflict_epi32 (__m512i __A) +{ + return (__m512i) __builtin_ia32_vpconflictsi_512_mask ((__v16si) __A, + (__v16si) _mm512_setzero_si512 (), + (__mmask16) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_conflict_epi32 (__m512i __W, __mmask16 __U, __m512i __A) +{ + return (__m512i) __builtin_ia32_vpconflictsi_512_mask ((__v16si) __A, + (__v16si) __W, + (__mmask16) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_conflict_epi32 (__mmask16 __U, __m512i __A) +{ + return (__m512i) __builtin_ia32_vpconflictsi_512_mask ((__v16si) __A, + (__v16si) _mm512_setzero_si512 (), + (__mmask16) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_lzcnt_epi32 (__m512i __A) +{ + return (__m512i) __builtin_ia32_vplzcntd_512_mask ((__v16si) __A, + (__v16si) _mm512_setzero_si512 (), + (__mmask16) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_lzcnt_epi32 (__m512i __W, __mmask16 __U, __m512i __A) +{ + return (__m512i) __builtin_ia32_vplzcntd_512_mask ((__v16si) __A, + (__v16si) __W, + (__mmask16) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_lzcnt_epi32 (__mmask16 __U, __m512i __A) +{ + return (__m512i) __builtin_ia32_vplzcntd_512_mask ((__v16si) __A, + (__v16si) _mm512_setzero_si512 (), + (__mmask16) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_lzcnt_epi64 (__m512i __A) +{ + return (__m512i) __builtin_ia32_vplzcntq_512_mask ((__v8di) __A, + (__v8di) _mm512_setzero_si512 (), + (__mmask8) -1); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_mask_lzcnt_epi64 (__m512i __W, __mmask8 __U, __m512i __A) +{ + return (__m512i) __builtin_ia32_vplzcntq_512_mask ((__v8di) __A, + (__v8di) __W, + (__mmask8) __U); +} + +static __inline__ __m512i __DEFAULT_FN_ATTRS +_mm512_maskz_lzcnt_epi64 (__mmask8 __U, __m512i __A) +{ + return (__m512i) __builtin_ia32_vplzcntq_512_mask ((__v8di) __A, + (__v8di) _mm512_setzero_si512 (), + (__mmask8) __U); +} +#undef __DEFAULT_FN_ATTRS + +#endif diff --git a/lib/Headers/avx512dqintrin.h b/lib/Headers/avx512dqintrin.h index cfcfc62b9455..8a69f7ffbf34 100644 --- a/lib/Headers/avx512dqintrin.h +++ b/lib/Headers/avx512dqintrin.h @@ -29,14 +29,14 @@ #define __AVX512DQINTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512dq"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512dq"))) -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_mullo_epi64 (__m512i __A, __m512i __B) { return (__m512i) ((__v8di) __A * (__v8di) __B); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -44,7 +44,7 @@ _mm512_mask_mullo_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { (__mmask8) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -53,12 +53,12 @@ _mm512_maskz_mullo_epi64 (__mmask8 __U, __m512i __A, __m512i __B) { (__mmask8) __U); } -static __inline__ __m512d DEFAULT_FN_ATTRS +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_xor_pd (__m512d __A, __m512d __B) { return (__m512d) ((__v8di) __A ^ (__v8di) __B); } -static __inline__ __m512d DEFAULT_FN_ATTRS +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, @@ -66,7 +66,7 @@ _mm512_mask_xor_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512d DEFAULT_FN_ATTRS +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, @@ -75,12 +75,12 @@ _mm512_maskz_xor_pd (__mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512 DEFAULT_FN_ATTRS +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_xor_ps (__m512 __A, __m512 __B) { return (__m512) ((__v16si) __A ^ (__v16si) __B); } -static __inline__ __m512 DEFAULT_FN_ATTRS +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, @@ -88,7 +88,7 @@ _mm512_mask_xor_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512 DEFAULT_FN_ATTRS +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, @@ -97,12 +97,12 @@ _mm512_maskz_xor_ps (__mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512d DEFAULT_FN_ATTRS +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_or_pd (__m512d __A, __m512d __B) { return (__m512d) ((__v8di) __A | (__v8di) __B); } -static __inline__ __m512d DEFAULT_FN_ATTRS +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, @@ -110,7 +110,7 @@ _mm512_mask_or_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512d DEFAULT_FN_ATTRS +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, @@ -119,12 +119,12 @@ _mm512_maskz_or_pd (__mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512 DEFAULT_FN_ATTRS +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_or_ps (__m512 __A, __m512 __B) { return (__m512) ((__v16si) __A | (__v16si) __B); } -static __inline__ __m512 DEFAULT_FN_ATTRS +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, @@ -132,7 +132,7 @@ _mm512_mask_or_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512 DEFAULT_FN_ATTRS +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, @@ -141,12 +141,12 @@ _mm512_maskz_or_ps (__mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512d DEFAULT_FN_ATTRS +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_and_pd (__m512d __A, __m512d __B) { return (__m512d) ((__v8di) __A & (__v8di) __B); } -static __inline__ __m512d DEFAULT_FN_ATTRS +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, @@ -154,7 +154,7 @@ _mm512_mask_and_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512d DEFAULT_FN_ATTRS +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, @@ -163,12 +163,12 @@ _mm512_maskz_and_pd (__mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512 DEFAULT_FN_ATTRS +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_and_ps (__m512 __A, __m512 __B) { return (__m512) ((__v16si) __A & (__v16si) __B); } -static __inline__ __m512 DEFAULT_FN_ATTRS +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, @@ -176,7 +176,7 @@ _mm512_mask_and_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512 DEFAULT_FN_ATTRS +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, @@ -185,7 +185,7 @@ _mm512_maskz_and_ps (__mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512d DEFAULT_FN_ATTRS +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_andnot_pd (__m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_andnpd512_mask ((__v8df) __A, (__v8df) __B, @@ -194,7 +194,7 @@ _mm512_andnot_pd (__m512d __A, __m512d __B) { (__mmask8) -1); } -static __inline__ __m512d DEFAULT_FN_ATTRS +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, @@ -202,7 +202,7 @@ _mm512_mask_andnot_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512d DEFAULT_FN_ATTRS +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, @@ -211,7 +211,7 @@ _mm512_maskz_andnot_pd (__mmask8 __U, __m512d __A, __m512d __B) { (__mmask8) __U); } -static __inline__ __m512 DEFAULT_FN_ATTRS +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_andnot_ps (__m512 __A, __m512 __B) { return (__m512) __builtin_ia32_andnps512_mask ((__v16sf) __A, (__v16sf) __B, @@ -220,7 +220,7 @@ _mm512_andnot_ps (__m512 __A, __m512 __B) { (__mmask16) -1); } -static __inline__ __m512 DEFAULT_FN_ATTRS +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, @@ -228,7 +228,7 @@ _mm512_mask_andnot_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -static __inline__ __m512 DEFAULT_FN_ATTRS +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, @@ -237,6 +237,6 @@ _mm512_maskz_andnot_ps (__mmask16 __U, __m512 __A, __m512 __B) { (__mmask16) __U); } -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif diff --git a/lib/Headers/avx512fintrin.h b/lib/Headers/avx512fintrin.h index 98eb73b3113f..099114453646 100644 --- a/lib/Headers/avx512fintrin.h +++ b/lib/Headers/avx512fintrin.h @@ -47,17 +47,17 @@ typedef unsigned short __mmask16; #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"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512f"))) /* Create vectors with repeated elements */ -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_setzero_si512(void) { return (__m512i)(__v8di){ 0, 0, 0, 0, 0, 0, 0, 0 }; } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_maskz_set1_epi32(__mmask16 __M, int __A) { return (__m512i) __builtin_ia32_pbroadcastd512_gpr_mask (__A, @@ -66,7 +66,7 @@ _mm512_maskz_set1_epi32(__mmask16 __M, int __A) __M); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_maskz_set1_epi64(__mmask8 __M, long long __A) { #ifdef __x86_64__ @@ -82,45 +82,45 @@ _mm512_maskz_set1_epi64(__mmask8 __M, long long __A) #endif } -static __inline __m512 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_set1_pd(double __w) { return (__m512d){ __w, __w, __w, __w, __w, __w, __w, __w }; } -static __inline __m512i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_broadcastss_ps(__m128 __X) { float __f = __X[0]; @@ -130,7 +130,7 @@ _mm512_broadcastss_ps(__m128 __X) __f, __f, __f, __f }; } -static __inline__ __m512d DEFAULT_FN_ATTRS +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_broadcastsd_pd(__m128d __X) { double __d = __X[0]; @@ -140,39 +140,39 @@ _mm512_broadcastsd_pd(__m128d __X) /* Cast between vector types */ -static __inline __m512d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m128d __DEFAULT_FN_ATTRS _mm512_castpd512_pd128(__m512d __a) { return __builtin_shufflevector(__a, __a, 0, 1); } -static __inline __m128 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_and_epi32(__m512i __a, __m512i __b) { return __a & __b; } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -180,7 +180,7 @@ _mm512_mask_and_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b) (__v16si) __src, (__mmask16) __k); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_maskz_and_epi32(__mmask16 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pandd512_mask((__v16si) __a, @@ -190,13 +190,13 @@ _mm512_maskz_and_epi32(__mmask16 __k, __m512i __a, __m512i __b) (__mmask16) __k); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_and_epi64(__m512i __a, __m512i __b) { return __a & __b; } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -204,7 +204,7 @@ _mm512_mask_and_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b) (__v8di) __src, (__mmask8) __k); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_maskz_and_epi64(__mmask8 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pandq512_mask ((__v8di) __a, @@ -214,7 +214,7 @@ _mm512_maskz_and_epi64(__mmask8 __k, __m512i __a, __m512i __b) (__mmask8) __k); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_andnot_epi32 (__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pandnd512_mask ((__v16si) __A, @@ -224,7 +224,7 @@ _mm512_andnot_epi32 (__m512i __A, __m512i __B) (__mmask16) -1); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -233,7 +233,7 @@ _mm512_mask_andnot_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) (__mmask16) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_maskz_andnot_epi32 (__mmask16 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pandnd512_mask ((__v16si) __A, @@ -243,7 +243,7 @@ _mm512_maskz_andnot_epi32 (__mmask16 __U, __m512i __A, __m512i __B) (__mmask16) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_andnot_epi64 (__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pandnq512_mask ((__v8di) __A, @@ -253,7 +253,7 @@ _mm512_andnot_epi64 (__m512i __A, __m512i __B) (__mmask8) -1); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -261,7 +261,7 @@ _mm512_mask_andnot_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) (__v8di) __W, __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_maskz_andnot_epi64 (__mmask8 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pandnq512_mask ((__v8di) __A, @@ -270,13 +270,13 @@ _mm512_maskz_andnot_epi64 (__mmask8 __U, __m512i __A, __m512i __B) _mm512_setzero_pd (), __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_or_epi32(__m512i __a, __m512i __b) { return __a | __b; } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -284,7 +284,7 @@ _mm512_mask_or_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b) (__v16si) __src, (__mmask16) __k); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_maskz_or_epi32(__mmask16 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pord512_mask((__v16si) __a, @@ -294,13 +294,13 @@ _mm512_maskz_or_epi32(__mmask16 __k, __m512i __a, __m512i __b) (__mmask16) __k); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_or_epi64(__m512i __a, __m512i __b) { return __a | __b; } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -308,7 +308,7 @@ _mm512_mask_or_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b) (__v8di) __src, (__mmask8) __k); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_maskz_or_epi64(__mmask8 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_porq512_mask ((__v8di) __a, @@ -318,13 +318,13 @@ _mm512_maskz_or_epi64(__mmask8 __k, __m512i __a, __m512i __b) (__mmask8) __k); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_xor_epi32(__m512i __a, __m512i __b) { return __a ^ __b; } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -332,7 +332,7 @@ _mm512_mask_xor_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b) (__v16si) __src, (__mmask16) __k); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_maskz_xor_epi32(__mmask16 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pxord512_mask((__v16si) __a, @@ -342,13 +342,13 @@ _mm512_maskz_xor_epi32(__mmask16 __k, __m512i __a, __m512i __b) (__mmask16) __k); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_xor_epi64(__m512i __a, __m512i __b) { return __a ^ __b; } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -356,7 +356,7 @@ _mm512_mask_xor_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b) (__v8di) __src, (__mmask8) __k); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_maskz_xor_epi64(__mmask8 __k, __m512i __a, __m512i __b) { return (__m512i) __builtin_ia32_pxorq512_mask ((__v8di) __a, @@ -366,68 +366,68 @@ _mm512_maskz_xor_epi64(__mmask8 __k, __m512i __a, __m512i __b) (__mmask8) __k); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_and_si512(__m512i __a, __m512i __b) { return __a & __b; } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_or_si512(__m512i __a, __m512i __b) { return __a | __b; } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_xor_si512(__m512i __a, __m512i __b) { return __a ^ __b; } /* Arithmetic */ -static __inline __m512d DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_add_pd(__m512d __a, __m512d __b) { return __a + __b; } -static __inline __m512 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_add_ps(__m512 __a, __m512 __b) { return __a + __b; } -static __inline __m512d DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_mul_pd(__m512d __a, __m512d __b) { return __a * __b; } -static __inline __m512 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_mul_ps(__m512 __a, __m512 __b) { return __a * __b; } -static __inline __m512d DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_sub_pd(__m512d __a, __m512d __b) { return __a - __b; } -static __inline __m512 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_sub_ps(__m512 __a, __m512 __b) { return __a - __b; } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_add_epi64 (__m512i __A, __m512i __B) { return (__m512i) ((__v8di) __A + (__v8di) __B); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -436,7 +436,7 @@ _mm512_mask_add_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) (__mmask8) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_maskz_add_epi64 (__mmask8 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_paddq512_mask ((__v8di) __A, @@ -446,13 +446,13 @@ _mm512_maskz_add_epi64 (__mmask8 __U, __m512i __A, __m512i __B) (__mmask8) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_sub_epi64 (__m512i __A, __m512i __B) { return (__m512i) ((__v8di) __A - (__v8di) __B); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -461,7 +461,7 @@ _mm512_mask_sub_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) (__mmask8) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_maskz_sub_epi64 (__mmask8 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_psubq512_mask ((__v8di) __A, @@ -471,13 +471,13 @@ _mm512_maskz_sub_epi64 (__mmask8 __U, __m512i __A, __m512i __B) (__mmask8) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_add_epi32 (__m512i __A, __m512i __B) { return (__m512i) ((__v16si) __A + (__v16si) __B); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -486,7 +486,7 @@ _mm512_mask_add_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) (__mmask16) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_maskz_add_epi32 (__mmask16 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_paddd512_mask ((__v16si) __A, @@ -496,13 +496,13 @@ _mm512_maskz_add_epi32 (__mmask16 __U, __m512i __A, __m512i __B) (__mmask16) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_sub_epi32 (__m512i __A, __m512i __B) { return (__m512i) ((__v16si) __A - (__v16si) __B); } -static __inline__ __m512i DEFAULT_FN_ATTRS +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, @@ -511,7 +511,7 @@ _mm512_mask_sub_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) (__mmask16) __U); } -static __inline__ __m512i DEFAULT_FN_ATTRS +static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_maskz_sub_epi32 (__mmask16 __U, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_psubd512_mask ((__v16si) __A, @@ -521,7 +521,7 @@ _mm512_maskz_sub_epi32 (__mmask16 __U, __m512i __A, __m512i __B) (__mmask16) __U); } -static __inline__ __m512d DEFAULT_FN_ATTRS +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_max_pd(__m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_maxpd512_mask ((__v8df) __A, @@ -532,7 +532,7 @@ _mm512_max_pd(__m512d __A, __m512d __B) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512 DEFAULT_FN_ATTRS +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_max_ps(__m512 __A, __m512 __B) { return (__m512) __builtin_ia32_maxps512_mask ((__v16sf) __A, @@ -544,7 +544,7 @@ _mm512_max_ps(__m512 __A, __m512 __B) } static __inline __m512i -DEFAULT_FN_ATTRS +__DEFAULT_FN_ATTRS _mm512_max_epi32(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmaxsd512_mask ((__v16si) __A, @@ -554,7 +554,7 @@ _mm512_max_epi32(__m512i __A, __m512i __B) (__mmask16) -1); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_max_epu32(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmaxud512_mask ((__v16si) __A, @@ -564,7 +564,7 @@ _mm512_max_epu32(__m512i __A, __m512i __B) (__mmask16) -1); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_max_epi64(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmaxsq512_mask ((__v8di) __A, @@ -574,7 +574,7 @@ _mm512_max_epi64(__m512i __A, __m512i __B) (__mmask8) -1); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_max_epu64(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmaxuq512_mask ((__v8di) __A, @@ -584,7 +584,7 @@ _mm512_max_epu64(__m512i __A, __m512i __B) (__mmask8) -1); } -static __inline__ __m512d DEFAULT_FN_ATTRS +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_min_pd(__m512d __A, __m512d __B) { return (__m512d) __builtin_ia32_minpd512_mask ((__v8df) __A, @@ -595,7 +595,7 @@ _mm512_min_pd(__m512d __A, __m512d __B) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512 DEFAULT_FN_ATTRS +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_min_ps(__m512 __A, __m512 __B) { return (__m512) __builtin_ia32_minps512_mask ((__v16sf) __A, @@ -607,7 +607,7 @@ _mm512_min_ps(__m512 __A, __m512 __B) } static __inline __m512i -DEFAULT_FN_ATTRS +__DEFAULT_FN_ATTRS _mm512_min_epi32(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pminsd512_mask ((__v16si) __A, @@ -617,7 +617,7 @@ _mm512_min_epi32(__m512i __A, __m512i __B) (__mmask16) -1); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_min_epu32(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pminud512_mask ((__v16si) __A, @@ -627,7 +627,7 @@ _mm512_min_epu32(__m512i __A, __m512i __B) (__mmask16) -1); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_min_epi64(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pminsq512_mask ((__v8di) __A, @@ -637,7 +637,7 @@ _mm512_min_epi64(__m512i __A, __m512i __B) (__mmask8) -1); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_min_epu64(__m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pminuq512_mask ((__v8di) __A, @@ -647,7 +647,7 @@ _mm512_min_epu64(__m512i __A, __m512i __B) (__mmask8) -1); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_mul_epi32(__m512i __X, __m512i __Y) { return (__m512i) __builtin_ia32_pmuldq512_mask ((__v16si) __X, @@ -657,7 +657,7 @@ _mm512_mul_epi32(__m512i __X, __m512i __Y) (__mmask8) -1); } -static __inline __m512i DEFAULT_FN_ATTRS +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, @@ -665,7 +665,7 @@ _mm512_mask_mul_epi32 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y) (__v8di) __W, __M); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_maskz_mul_epi32 (__mmask8 __M, __m512i __X, __m512i __Y) { return (__m512i) __builtin_ia32_pmuldq512_mask ((__v16si) __X, @@ -675,7 +675,7 @@ _mm512_maskz_mul_epi32 (__mmask8 __M, __m512i __X, __m512i __Y) __M); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_mul_epu32(__m512i __X, __m512i __Y) { return (__m512i) __builtin_ia32_pmuludq512_mask ((__v16si) __X, @@ -685,7 +685,7 @@ _mm512_mul_epu32(__m512i __X, __m512i __Y) (__mmask8) -1); } -static __inline __m512i DEFAULT_FN_ATTRS +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, @@ -693,7 +693,7 @@ _mm512_mask_mul_epu32 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y) (__v8di) __W, __M); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_maskz_mul_epu32 (__mmask8 __M, __m512i __X, __m512i __Y) { return (__m512i) __builtin_ia32_pmuludq512_mask ((__v16si) __X, @@ -703,13 +703,13 @@ _mm512_maskz_mul_epu32 (__mmask8 __M, __m512i __X, __m512i __Y) __M); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_mullo_epi32 (__m512i __A, __m512i __B) { return (__m512i) ((__v16si) __A * (__v16si) __B); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_maskz_mullo_epi32 (__mmask16 __M, __m512i __A, __m512i __B) { return (__m512i) __builtin_ia32_pmulld512_mask ((__v16si) __A, @@ -719,7 +719,7 @@ _mm512_maskz_mullo_epi32 (__mmask16 __M, __m512i __A, __m512i __B) __M); } -static __inline __m512i DEFAULT_FN_ATTRS +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, @@ -727,7 +727,7 @@ _mm512_mask_mullo_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B) (__v16si) __W, __M); } -static __inline__ __m512d DEFAULT_FN_ATTRS +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_sqrt_pd(__m512d a) { return (__m512d)__builtin_ia32_sqrtpd512_mask((__v8df)a, @@ -736,7 +736,7 @@ _mm512_sqrt_pd(__m512d a) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512 DEFAULT_FN_ATTRS +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_sqrt_ps(__m512 a) { return (__m512)__builtin_ia32_sqrtps512_mask((__v16sf)a, @@ -745,7 +745,7 @@ _mm512_sqrt_ps(__m512 a) _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512d DEFAULT_FN_ATTRS +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_rsqrt14_pd(__m512d __A) { return (__m512d) __builtin_ia32_rsqrt14pd512_mask ((__v8df) __A, @@ -753,7 +753,7 @@ _mm512_rsqrt14_pd(__m512d __A) _mm512_setzero_pd (), (__mmask8) -1);} -static __inline__ __m512 DEFAULT_FN_ATTRS +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_rsqrt14_ps(__m512 __A) { return (__m512) __builtin_ia32_rsqrt14ps512_mask ((__v16sf) __A, @@ -762,7 +762,7 @@ _mm512_rsqrt14_ps(__m512 __A) (__mmask16) -1); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_rsqrt14_ss(__m128 __A, __m128 __B) { return (__m128) __builtin_ia32_rsqrt14ss_mask ((__v4sf) __A, @@ -772,7 +772,7 @@ _mm_rsqrt14_ss(__m128 __A, __m128 __B) (__mmask8) -1); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_rsqrt14_sd(__m128d __A, __m128d __B) { return (__m128d) __builtin_ia32_rsqrt14sd_mask ((__v2df) __A, @@ -782,7 +782,7 @@ _mm_rsqrt14_sd(__m128d __A, __m128d __B) (__mmask8) -1); } -static __inline__ __m512d DEFAULT_FN_ATTRS +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_rcp14_pd(__m512d __A) { return (__m512d) __builtin_ia32_rcp14pd512_mask ((__v8df) __A, @@ -791,7 +791,7 @@ _mm512_rcp14_pd(__m512d __A) (__mmask8) -1); } -static __inline__ __m512 DEFAULT_FN_ATTRS +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_rcp14_ps(__m512 __A) { return (__m512) __builtin_ia32_rcp14ps512_mask ((__v16sf) __A, @@ -799,7 +799,7 @@ _mm512_rcp14_ps(__m512 __A) _mm512_setzero_ps (), (__mmask16) -1); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_rcp14_ss(__m128 __A, __m128 __B) { return (__m128) __builtin_ia32_rcp14ss_mask ((__v4sf) __A, @@ -809,7 +809,7 @@ _mm_rcp14_ss(__m128 __A, __m128 __B) (__mmask8) -1); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_rcp14_sd(__m128d __A, __m128d __B) { return (__m128d) __builtin_ia32_rcp14sd_mask ((__v2df) __A, @@ -819,7 +819,7 @@ _mm_rcp14_sd(__m128d __A, __m128d __B) (__mmask8) -1); } -static __inline __m512 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_floor_ps(__m512 __A) { return (__m512) __builtin_ia32_rndscaleps_mask ((__v16sf) __A, @@ -828,7 +828,7 @@ _mm512_floor_ps(__m512 __A) _MM_FROUND_CUR_DIRECTION); } -static __inline __m512d DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_floor_pd(__m512d __A) { return (__m512d) __builtin_ia32_rndscalepd_mask ((__v8df) __A, @@ -837,7 +837,7 @@ _mm512_floor_pd(__m512d __A) _MM_FROUND_CUR_DIRECTION); } -static __inline __m512 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_ceil_ps(__m512 __A) { return (__m512) __builtin_ia32_rndscaleps_mask ((__v16sf) __A, @@ -846,7 +846,7 @@ _mm512_ceil_ps(__m512 __A) _MM_FROUND_CUR_DIRECTION); } -static __inline __m512d DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_ceil_pd(__m512d __A) { return (__m512d) __builtin_ia32_rndscalepd_mask ((__v8df) __A, @@ -855,7 +855,7 @@ _mm512_ceil_pd(__m512d __A) _MM_FROUND_CUR_DIRECTION); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_abs_epi64(__m512i __A) { return (__m512i) __builtin_ia32_pabsq512_mask ((__v8di) __A, @@ -864,7 +864,7 @@ _mm512_abs_epi64(__m512i __A) (__mmask8) -1); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_abs_epi32(__m512i __A) { return (__m512i) __builtin_ia32_pabsd512_mask ((__v16si) __A, @@ -881,75 +881,779 @@ _mm512_abs_epi32(__m512i __A) (__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(A), (B), (__v8df)(A), \ -1, _MM_FROUND_CUR_DIRECTION); }) -static __inline__ __m512d DEFAULT_FN_ATTRS +#define _mm512_fmadd_round_pd(A, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) -1, (R)); }) + + +#define _mm512_mask_fmadd_round_pd(A, U, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +#define _mm512_mask3_fmadd_round_pd(A, B, C, U, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddpd512_mask3 ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +#define _mm512_maskz_fmadd_round_pd(U, A, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddpd512_maskz ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +#define _mm512_fmsub_round_pd(A, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) (A), \ + (__v8df) (B), -(__v8df) (C), \ + (__mmask8) -1, (R)); }) + + +#define _mm512_mask_fmsub_round_pd(A, U, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) (A), \ + (__v8df) (B), -(__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +#define _mm512_maskz_fmsub_round_pd(U, A, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddpd512_maskz ((__v8df) (A), \ + (__v8df) (B), -(__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +#define _mm512_fnmadd_round_pd(A, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddpd512_mask (-(__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) -1, (R)); }) + + +#define _mm512_mask3_fnmadd_round_pd(A, B, C, U, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddpd512_mask3 (-(__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +#define _mm512_maskz_fnmadd_round_pd(U, A, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddpd512_maskz (-(__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +#define _mm512_fnmsub_round_pd(A, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddpd512_mask (-(__v8df) (A), \ + (__v8df) (B), -(__v8df) (C), \ + (__mmask8) -1, (R)); }) + + +#define _mm512_maskz_fnmsub_round_pd(U, A, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddpd512_maskz (-(__v8df) (A), \ + (__v8df) (B), -(__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_fmadd_pd(__m512d __A, __m512d __B, __m512d __C) { - return (__m512d) - __builtin_ia32_vfmaddpd512_mask(__A, - __B, - __C, - (__mmask8) -1, - _MM_FROUND_CUR_DIRECTION); + return (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) -1, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_mask_fmadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_mask3_fmadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) +{ + return (__m512d) __builtin_ia32_vfmaddpd512_mask3 ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512d DEFAULT_FN_ATTRS +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_maskz_fmadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddpd512_maskz ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_fmsub_pd(__m512d __A, __m512d __B, __m512d __C) { - return (__m512d) - __builtin_ia32_vfmsubpd512_mask(__A, - __B, - __C, - (__mmask8) -1, - _MM_FROUND_CUR_DIRECTION); + return (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) __A, + (__v8df) __B, + -(__v8df) __C, + (__mmask8) -1, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_mask_fmsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) __A, + (__v8df) __B, + -(__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_maskz_fmsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddpd512_maskz ((__v8df) __A, + (__v8df) __B, + -(__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512d DEFAULT_FN_ATTRS +static __inline__ __m512d __DEFAULT_FN_ATTRS _mm512_fnmadd_pd(__m512d __A, __m512d __B, __m512d __C) { - return (__m512d) - __builtin_ia32_vfnmaddpd512_mask(__A, - __B, - __C, - (__mmask8) -1, - _MM_FROUND_CUR_DIRECTION); + return (__m512d) __builtin_ia32_vfmaddpd512_mask (-(__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) -1, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_mask3_fnmadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) +{ + return (__m512d) __builtin_ia32_vfmaddpd512_mask3 (-(__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_maskz_fnmadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddpd512_maskz (-(__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_fnmsub_pd(__m512d __A, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddpd512_mask (-(__v8df) __A, + (__v8df) __B, + -(__v8df) __C, + (__mmask8) -1, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_maskz_fnmsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddpd512_maskz (-(__v8df) __A, + (__v8df) __B, + -(__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512 DEFAULT_FN_ATTRS +#define _mm512_fmadd_round_ps(A, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) -1, (R)); }) + + +#define _mm512_mask_fmadd_round_ps(A, U, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +#define _mm512_mask3_fmadd_round_ps(A, B, C, U, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddps512_mask3 ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +#define _mm512_maskz_fmadd_round_ps(U, A, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddps512_maskz ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +#define _mm512_fmsub_round_ps(A, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) (A), \ + (__v16sf) (B), -(__v16sf) (C), \ + (__mmask16) -1, (R)); }) + + +#define _mm512_mask_fmsub_round_ps(A, U, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) (A), \ + (__v16sf) (B), -(__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +#define _mm512_maskz_fmsub_round_ps(U, A, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddps512_maskz ((__v16sf) (A), \ + (__v16sf) (B), -(__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +#define _mm512_fnmadd_round_ps(A, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddps512_mask (-(__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) -1, (R)); }) + + +#define _mm512_mask3_fnmadd_round_ps(A, B, C, U, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddps512_mask3 (-(__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +#define _mm512_maskz_fnmadd_round_ps(U, A, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddps512_maskz (-(__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +#define _mm512_fnmsub_round_ps(A, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddps512_mask (-(__v16sf) (A), \ + (__v16sf) (B), -(__v16sf) (C), \ + (__mmask16) -1, (R)); }) + + +#define _mm512_maskz_fnmsub_round_ps(U, A, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddps512_maskz (-(__v16sf) (A), \ + (__v16sf) (B), -(__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_fmadd_ps(__m512 __A, __m512 __B, __m512 __C) { - return (__m512) - __builtin_ia32_vfmaddps512_mask(__A, - __B, - __C, - (__mmask16) -1, - _MM_FROUND_CUR_DIRECTION); + return (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) -1, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_mask_fmadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_mask3_fmadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) +{ + return (__m512) __builtin_ia32_vfmaddps512_mask3 ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_maskz_fmadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddps512_maskz ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512 DEFAULT_FN_ATTRS +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_fmsub_ps(__m512 __A, __m512 __B, __m512 __C) { - return (__m512) - __builtin_ia32_vfmsubps512_mask(__A, - __B, - __C, - (__mmask16) -1, - _MM_FROUND_CUR_DIRECTION); + return (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) __A, + (__v16sf) __B, + -(__v16sf) __C, + (__mmask16) -1, + _MM_FROUND_CUR_DIRECTION); } -static __inline__ __m512 DEFAULT_FN_ATTRS +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_mask_fmsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) __A, + (__v16sf) __B, + -(__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_maskz_fmsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddps512_maskz ((__v16sf) __A, + (__v16sf) __B, + -(__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS _mm512_fnmadd_ps(__m512 __A, __m512 __B, __m512 __C) { - return (__m512) - __builtin_ia32_vfnmaddps512_mask(__A, - __B, - __C, - (__mmask16) -1, - _MM_FROUND_CUR_DIRECTION); + return (__m512) __builtin_ia32_vfmaddps512_mask (-(__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) -1, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_mask3_fnmadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) +{ + return (__m512) __builtin_ia32_vfmaddps512_mask3 (-(__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_maskz_fnmadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddps512_maskz (-(__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); } +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_fnmsub_ps(__m512 __A, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddps512_mask (-(__v16sf) __A, + (__v16sf) __B, + -(__v16sf) __C, + (__mmask16) -1, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_maskz_fnmsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddps512_maskz (-(__v16sf) __A, + (__v16sf) __B, + -(__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +#define _mm512_fmaddsub_round_pd(A, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) -1, (R)); }) + + +#define _mm512_mask_fmaddsub_round_pd(A, U, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +#define _mm512_mask3_fmaddsub_round_pd(A, B, C, U, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddsubpd512_mask3 ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +#define _mm512_maskz_fmaddsub_round_pd(U, A, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddsubpd512_maskz ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +#define _mm512_fmsubadd_round_pd(A, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) (A), \ + (__v8df) (B), -(__v8df) (C), \ + (__mmask8) -1, (R)); }) + + +#define _mm512_mask_fmsubadd_round_pd(A, U, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) (A), \ + (__v8df) (B), -(__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +#define _mm512_maskz_fmsubadd_round_pd(U, A, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmaddsubpd512_maskz ((__v8df) (A), \ + (__v8df) (B), -(__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_fmaddsub_pd(__m512d __A, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) -1, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_mask_fmaddsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_mask3_fmaddsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) +{ + return (__m512d) __builtin_ia32_vfmaddsubpd512_mask3 ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_maskz_fmaddsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddsubpd512_maskz ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_fmsubadd_pd(__m512d __A, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) __A, + (__v8df) __B, + -(__v8df) __C, + (__mmask8) -1, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_mask_fmsubadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) __A, + (__v8df) __B, + -(__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_maskz_fmsubadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfmaddsubpd512_maskz ((__v8df) __A, + (__v8df) __B, + -(__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +#define _mm512_fmaddsub_round_ps(A, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) -1, (R)); }) + + +#define _mm512_mask_fmaddsub_round_ps(A, U, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +#define _mm512_mask3_fmaddsub_round_ps(A, B, C, U, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddsubps512_mask3 ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +#define _mm512_maskz_fmaddsub_round_ps(U, A, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddsubps512_maskz ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +#define _mm512_fmsubadd_round_ps(A, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) (A), \ + (__v16sf) (B), -(__v16sf) (C), \ + (__mmask16) -1, (R)); }) + + +#define _mm512_mask_fmsubadd_round_ps(A, U, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) (A), \ + (__v16sf) (B), -(__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +#define _mm512_maskz_fmsubadd_round_ps(U, A, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmaddsubps512_maskz ((__v16sf) (A), \ + (__v16sf) (B), -(__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_fmaddsub_ps(__m512 __A, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) -1, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_mask_fmaddsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_mask3_fmaddsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) +{ + return (__m512) __builtin_ia32_vfmaddsubps512_mask3 ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_maskz_fmaddsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddsubps512_maskz ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_fmsubadd_ps(__m512 __A, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) __A, + (__v16sf) __B, + -(__v16sf) __C, + (__mmask16) -1, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_mask_fmsubadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) __A, + (__v16sf) __B, + -(__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_maskz_fmsubadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfmaddsubps512_maskz ((__v16sf) __A, + (__v16sf) __B, + -(__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +#define _mm512_mask3_fmsub_round_pd(A, B, C, U, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmsubpd512_mask3 ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_mask3_fmsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) +{ + return (__m512d) __builtin_ia32_vfmsubpd512_mask3 ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +#define _mm512_mask3_fmsub_round_ps(A, B, C, U, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmsubps512_mask3 ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_mask3_fmsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) +{ + return (__m512) __builtin_ia32_vfmsubps512_mask3 ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +#define _mm512_mask3_fmsubadd_round_pd(A, B, C, U, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfmsubaddpd512_mask3 ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_mask3_fmsubadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) +{ + return (__m512d) __builtin_ia32_vfmsubaddpd512_mask3 ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +#define _mm512_mask3_fmsubadd_round_ps(A, B, C, U, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfmsubaddps512_mask3 ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_mask3_fmsubadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) +{ + return (__m512) __builtin_ia32_vfmsubaddps512_mask3 ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +#define _mm512_mask_fnmadd_round_pd(A, U, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfnmaddpd512_mask ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_mask_fnmadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfnmaddpd512_mask ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +#define _mm512_mask_fnmadd_round_ps(A, U, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfnmaddps512_mask ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_mask_fnmadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfnmaddps512_mask ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +#define _mm512_mask_fnmsub_round_pd(A, U, B, C, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfnmsubpd512_mask ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +#define _mm512_mask3_fnmsub_round_pd(A, B, C, U, R) __extension__ ({ \ + (__m512d) __builtin_ia32_vfnmsubpd512_mask3 ((__v8df) (A), \ + (__v8df) (B), (__v8df) (C), \ + (__mmask8) (U), (R)); }) + + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_mask_fnmsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) +{ + return (__m512d) __builtin_ia32_vfnmsubpd512_mask ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512d __DEFAULT_FN_ATTRS +_mm512_mask3_fnmsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) +{ + return (__m512d) __builtin_ia32_vfnmsubpd512_mask3 ((__v8df) __A, + (__v8df) __B, + (__v8df) __C, + (__mmask8) __U, + _MM_FROUND_CUR_DIRECTION); +} + +#define _mm512_mask_fnmsub_round_ps(A, U, B, C, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfnmsubps512_mask ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +#define _mm512_mask3_fnmsub_round_ps(A, B, C, U, R) __extension__ ({ \ + (__m512) __builtin_ia32_vfnmsubps512_mask3 ((__v16sf) (A), \ + (__v16sf) (B), (__v16sf) (C), \ + (__mmask16) (U), (R)); }) + + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_mask_fnmsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) +{ + return (__m512) __builtin_ia32_vfnmsubps512_mask ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + +static __inline__ __m512 __DEFAULT_FN_ATTRS +_mm512_mask3_fnmsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) +{ + return (__m512) __builtin_ia32_vfnmsubps512_mask3 ((__v16sf) __A, + (__v16sf) __B, + (__v16sf) __C, + (__mmask16) __U, + _MM_FROUND_CUR_DIRECTION); +} + + + /* Vector permutations */ -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_permutex2var_epi32(__m512i __A, __m512i __I, __m512i __B) { return (__m512i) __builtin_ia32_vpermt2vard512_mask ((__v16si) __I @@ -958,7 +1662,7 @@ _mm512_permutex2var_epi32(__m512i __A, __m512i __I, __m512i __B) (__v16si) __B, (__mmask16) -1); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_permutex2var_epi64(__m512i __A, __m512i __I, __m512i __B) { return (__m512i) __builtin_ia32_vpermt2varq512_mask ((__v8di) __I @@ -968,7 +1672,7 @@ _mm512_permutex2var_epi64(__m512i __A, __m512i __I, __m512i __B) (__mmask8) -1); } -static __inline __m512d DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_permutex2var_pd(__m512d __A, __m512i __I, __m512d __B) { return (__m512d) __builtin_ia32_vpermt2varpd512_mask ((__v8di) __I @@ -977,7 +1681,7 @@ _mm512_permutex2var_pd(__m512d __A, __m512i __I, __m512d __B) (__v8df) __B, (__mmask8) -1); } -static __inline __m512 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_permutex2var_ps(__m512 __A, __m512i __I, __m512 __B) { return (__m512) __builtin_ia32_vpermt2varps512_mask ((__v16si) __I @@ -1019,7 +1723,7 @@ _mm512_permutex2var_ps(__m512 __A, __m512i __I, __m512 __B) /* Vector Blend */ -static __inline __m512d DEFAULT_FN_ATTRS +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, @@ -1027,7 +1731,7 @@ _mm512_mask_blend_pd(__mmask8 __U, __m512d __A, __m512d __W) (__mmask8) __U); } -static __inline __m512 DEFAULT_FN_ATTRS +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, @@ -1035,7 +1739,7 @@ _mm512_mask_blend_ps(__mmask16 __U, __m512 __A, __m512 __W) (__mmask16) __U); } -static __inline __m512i DEFAULT_FN_ATTRS +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, @@ -1043,7 +1747,7 @@ _mm512_mask_blend_epi64(__mmask8 __U, __m512i __A, __m512i __W) (__mmask8) __U); } -static __inline __m512i DEFAULT_FN_ATTRS +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, @@ -1087,7 +1791,7 @@ _mm512_mask_blend_epi32(__mmask16 __U, __m512i __A, __m512i __W) /* Conversion */ -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_cvttps_epu32(__m512 __A) { return (__m512i) __builtin_ia32_cvttps2udq512_mask ((__v16sf) __A, @@ -1107,7 +1811,7 @@ _mm512_cvttps_epu32(__m512 __A) (__v16sf)_mm512_setzero_ps(), \ (__mmask16)-1, (R)); }) -static __inline __m512d DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_cvtepi32_pd(__m256i __A) { return (__m512d) __builtin_ia32_cvtdq2pd512_mask ((__v8si) __A, @@ -1116,7 +1820,7 @@ _mm512_cvtepi32_pd(__m256i __A) (__mmask8) -1); } -static __inline __m512d DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_cvtepu32_pd(__m256i __A) { return (__m512d) __builtin_ia32_cvtudq2pd512_mask ((__v8si) __A, @@ -1135,7 +1839,7 @@ _mm512_cvtepu32_pd(__m256i __A) (__v16hi)_mm256_setzero_si256(), \ -1); }) -static __inline __m512 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_cvtph_ps(__m256i __A) { return (__m512) __builtin_ia32_vcvtph2ps512_mask ((__v16hi) __A, @@ -1145,7 +1849,7 @@ _mm512_cvtph_ps(__m256i __A) _MM_FROUND_CUR_DIRECTION); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_cvttps_epi32(__m512 a) { return (__m512i) @@ -1154,7 +1858,7 @@ _mm512_cvttps_epi32(__m512 a) (__mmask16) -1, _MM_FROUND_CUR_DIRECTION); } -static __inline __m256i DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm512_cvttpd_epi32(__m512d a) { return (__m256i)__builtin_ia32_cvttpd2dq512_mask((__v8df) a, @@ -1194,19 +1898,19 @@ _mm512_cvttpd_epi32(__m512d a) (__mmask8) -1, (R)); }) /* Unpack and Interleave */ -static __inline __m512d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_unpackhi_ps(__m512 __a, __m512 __b) { return __builtin_shufflevector(__a, __b, @@ -1216,7 +1920,7 @@ _mm512_unpackhi_ps(__m512 __a, __m512 __b) 2+12, 18+12, 3+12, 19+12); } -static __inline __m512 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_unpacklo_ps(__m512 __a, __m512 __b) { return __builtin_shufflevector(__a, __b, @@ -1228,7 +1932,7 @@ _mm512_unpacklo_ps(__m512 __a, __m512 __b) /* Bit Test */ -static __inline __mmask16 DEFAULT_FN_ATTRS +static __inline __mmask16 __DEFAULT_FN_ATTRS _mm512_test_epi32_mask(__m512i __A, __m512i __B) { return (__mmask16) __builtin_ia32_ptestmd512 ((__v16si) __A, @@ -1236,7 +1940,7 @@ _mm512_test_epi32_mask(__m512i __A, __m512i __B) (__mmask16) -1); } -static __inline __mmask8 DEFAULT_FN_ATTRS +static __inline __mmask8 __DEFAULT_FN_ATTRS _mm512_test_epi64_mask(__m512i __A, __m512i __B) { return (__mmask8) __builtin_ia32_ptestmq512 ((__v8di) __A, @@ -1246,7 +1950,7 @@ _mm512_test_epi64_mask(__m512i __A, __m512i __B) /* SIMD load ops */ -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_maskz_loadu_epi32(__mmask16 __U, void const *__P) { return (__m512i) __builtin_ia32_loaddqusi512_mask ((const __v16si *)__P, @@ -1255,7 +1959,7 @@ _mm512_maskz_loadu_epi32(__mmask16 __U, void const *__P) (__mmask16) __U); } -static __inline __m512i DEFAULT_FN_ATTRS +static __inline __m512i __DEFAULT_FN_ATTRS _mm512_maskz_loadu_epi64(__mmask8 __U, void const *__P) { return (__m512i) __builtin_ia32_loaddqudi512_mask ((const __v8di *)__P, @@ -1264,7 +1968,7 @@ _mm512_maskz_loadu_epi64(__mmask8 __U, void const *__P) (__mmask8) __U); } -static __inline __m512 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_maskz_loadu_ps(__mmask16 __U, void const *__P) { return (__m512) __builtin_ia32_loadups512_mask ((const __v16sf *)__P, @@ -1273,7 +1977,7 @@ _mm512_maskz_loadu_ps(__mmask16 __U, void const *__P) (__mmask16) __U); } -static __inline __m512d DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_maskz_loadu_pd(__mmask8 __U, void const *__P) { return (__m512d) __builtin_ia32_loadupd512_mask ((const __v8df *)__P, @@ -1282,7 +1986,7 @@ _mm512_maskz_loadu_pd(__mmask8 __U, void const *__P) (__mmask8) __U); } -static __inline __m512 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_maskz_load_ps(__mmask16 __U, void const *__P) { return (__m512) __builtin_ia32_loadaps512_mask ((const __v16sf *)__P, @@ -1291,7 +1995,7 @@ _mm512_maskz_load_ps(__mmask16 __U, void const *__P) (__mmask16) __U); } -static __inline __m512d DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_maskz_load_pd(__mmask8 __U, void const *__P) { return (__m512d) __builtin_ia32_loadapd512_mask ((const __v8df *)__P, @@ -1300,7 +2004,7 @@ _mm512_maskz_load_pd(__mmask8 __U, void const *__P) (__mmask8) __U); } -static __inline __m512d DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_loadu_pd(double const *__p) { struct __loadu_pd { @@ -1309,7 +2013,7 @@ _mm512_loadu_pd(double const *__p) return ((struct __loadu_pd*)__p)->__v; } -static __inline __m512 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_loadu_ps(float const *__p) { struct __loadu_ps { @@ -1318,7 +2022,7 @@ _mm512_loadu_ps(float const *__p) return ((struct __loadu_ps*)__p)->__v; } -static __inline __m512 DEFAULT_FN_ATTRS +static __inline __m512 __DEFAULT_FN_ATTRS _mm512_load_ps(double const *__p) { return (__m512) __builtin_ia32_loadaps512_mask ((const __v16sf *)__p, @@ -1327,7 +2031,7 @@ _mm512_load_ps(double const *__p) (__mmask16) -1); } -static __inline __m512d DEFAULT_FN_ATTRS +static __inline __m512d __DEFAULT_FN_ATTRS _mm512_load_pd(float const *__p) { return (__m512d) __builtin_ia32_loadapd512_mask ((const __v8df *)__p, @@ -1338,65 +2042,65 @@ _mm512_load_pd(float const *__p) /* SIMD store ops */ -static __inline void DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm512_store_pd(void *__P, __m512d __A) { *(__m512d*)__P = __A; } -static __inline void DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm512_store_ps(void *__P, __m512 __A) { *(__m512*)__P = __A; @@ -1404,7 +2108,7 @@ _mm512_store_ps(void *__P, __m512 __A) /* Mask ops */ -static __inline __mmask16 DEFAULT_FN_ATTRS +static __inline __mmask16 __DEFAULT_FN_ATTRS _mm512_knot(__mmask16 __M) { return __builtin_ia32_knothi(__M); @@ -1412,289 +2116,289 @@ _mm512_knot(__mmask16 __M) /* Integer compare */ -static __inline__ __mmask16 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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); @@ -1748,6 +2452,6 @@ _mm512_mask_cmpneq_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { (__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)__a, (__v8di)__b, (p), \ (__mmask8)(m)); }) -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif // __AVX512FINTRIN_H diff --git a/lib/Headers/avx512vlbwintrin.h b/lib/Headers/avx512vlbwintrin.h index 1fbffd42cf0c..59849e43fd32 100644 --- a/lib/Headers/avx512vlbwintrin.h +++ b/lib/Headers/avx512vlbwintrin.h @@ -29,587 +29,587 @@ #define __AVX512VLBWINTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512vl,avx512bw"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512vl,avx512bw"))) /* Integer compare */ -static __inline__ __mmask16 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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, @@ -617,7 +617,7 @@ _mm256_mask_add_epi8 (__m256i __W, __mmask32 __U, __m256i __A, __m256i __B){ (__mmask32) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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, @@ -626,7 +626,7 @@ _mm256_maskz_add_epi8 (__mmask32 __U, __m256i __A, __m256i __B) { (__mmask32) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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, @@ -634,7 +634,7 @@ _mm256_mask_add_epi16 (__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { (__mmask16) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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, @@ -643,7 +643,7 @@ _mm256_maskz_add_epi16 (__mmask16 __U, __m256i __A, __m256i __B) { (__mmask16) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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, @@ -651,7 +651,7 @@ _mm256_mask_sub_epi8 (__m256i __W, __mmask32 __U, __m256i __A, __m256i __B) { (__mmask32) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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, @@ -660,7 +660,7 @@ _mm256_maskz_sub_epi8 (__mmask32 __U, __m256i __A, __m256i __B) { (__mmask32) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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, @@ -668,7 +668,7 @@ _mm256_mask_sub_epi16 (__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { (__mmask16) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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, @@ -676,7 +676,7 @@ _mm256_maskz_sub_epi16 (__mmask16 __U, __m256i __A, __m256i __B) { _mm256_setzero_si256 (), (__mmask16) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -684,7 +684,7 @@ _mm_mask_add_epi8 (__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) { (__mmask16) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -693,7 +693,7 @@ _mm_maskz_add_epi8 (__mmask16 __U, __m128i __A, __m128i __B) { (__mmask16) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -701,7 +701,7 @@ _mm_mask_add_epi16 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -710,7 +710,7 @@ _mm_maskz_add_epi16 (__mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -718,7 +718,7 @@ _mm_mask_sub_epi8 (__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) { (__mmask16) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -727,7 +727,7 @@ _mm_maskz_sub_epi8 (__mmask16 __U, __m128i __A, __m128i __B) { (__mmask16) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -735,7 +735,7 @@ _mm_mask_sub_epi16 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -744,7 +744,7 @@ _mm_maskz_sub_epi16 (__mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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, @@ -752,7 +752,7 @@ _mm256_mask_mullo_epi16 (__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { (__mmask16) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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, @@ -761,7 +761,7 @@ _mm256_maskz_mullo_epi16 (__mmask16 __U, __m256i __A, __m256i __B) { (__mmask16) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -769,7 +769,7 @@ _mm_mask_mullo_epi16 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -857,6 +857,6 @@ _mm_maskz_mullo_epi16 (__mmask8 __U, __m128i __A, __m128i __B) { (__v16hi)(__m256i)(b), \ (p), (__mmask16)(m)); }) -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __AVX512VLBWINTRIN_H */ diff --git a/lib/Headers/avx512vldqintrin.h b/lib/Headers/avx512vldqintrin.h index 2a32edd1ad81..032070bfb902 100644 --- a/lib/Headers/avx512vldqintrin.h +++ b/lib/Headers/avx512vldqintrin.h @@ -29,14 +29,14 @@ #define __AVX512VLDQINTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512vl,avx512dq"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512vl,avx512dq"))) -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mullo_epi64 (__m256i __A, __m256i __B) { return (__m256i) ((__v4di) __A * (__v4di) __B); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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, @@ -44,7 +44,7 @@ _mm256_mask_mullo_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +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, @@ -53,12 +53,12 @@ _mm256_maskz_mullo_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mullo_epi64 (__m128i __A, __m128i __B) { return (__m128i) ((__v2di) __A * (__v2di) __B); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -66,7 +66,7 @@ _mm_mask_mullo_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -75,7 +75,7 @@ _mm_maskz_mullo_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { (__mmask8) __U); } -static __inline__ __m256d DEFAULT_FN_ATTRS +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, @@ -83,7 +83,7 @@ _mm256_mask_andnot_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m256d DEFAULT_FN_ATTRS +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, @@ -92,7 +92,7 @@ _mm256_maskz_andnot_pd (__mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m128d DEFAULT_FN_ATTRS +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, @@ -100,7 +100,7 @@ _mm_mask_andnot_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m128d DEFAULT_FN_ATTRS +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, @@ -109,7 +109,7 @@ _mm_maskz_andnot_pd (__mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m256 DEFAULT_FN_ATTRS +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, @@ -117,7 +117,7 @@ _mm256_mask_andnot_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m256 DEFAULT_FN_ATTRS +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, @@ -126,7 +126,7 @@ _mm256_maskz_andnot_ps (__mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m128 DEFAULT_FN_ATTRS +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, @@ -134,7 +134,7 @@ _mm_mask_andnot_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m128 DEFAULT_FN_ATTRS +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, @@ -143,7 +143,7 @@ _mm_maskz_andnot_ps (__mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m256d DEFAULT_FN_ATTRS +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, @@ -151,7 +151,7 @@ _mm256_mask_and_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m256d DEFAULT_FN_ATTRS +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, @@ -160,7 +160,7 @@ _mm256_maskz_and_pd (__mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m128d DEFAULT_FN_ATTRS +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, @@ -168,7 +168,7 @@ _mm_mask_and_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m128d DEFAULT_FN_ATTRS +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, @@ -177,7 +177,7 @@ _mm_maskz_and_pd (__mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m256 DEFAULT_FN_ATTRS +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, @@ -185,7 +185,7 @@ _mm256_mask_and_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m256 DEFAULT_FN_ATTRS +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, @@ -194,7 +194,7 @@ _mm256_maskz_and_ps (__mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m128 DEFAULT_FN_ATTRS +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, @@ -202,7 +202,7 @@ _mm_mask_and_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m128 DEFAULT_FN_ATTRS +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, @@ -211,7 +211,7 @@ _mm_maskz_and_ps (__mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m256d DEFAULT_FN_ATTRS +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, @@ -220,7 +220,7 @@ _mm256_mask_xor_pd (__m256d __W, __mmask8 __U, __m256d __A, (__mmask8) __U); } -static __inline__ __m256d DEFAULT_FN_ATTRS +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, @@ -229,7 +229,7 @@ _mm256_maskz_xor_pd (__mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m128d DEFAULT_FN_ATTRS +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, @@ -237,7 +237,7 @@ _mm_mask_xor_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m128d DEFAULT_FN_ATTRS +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, @@ -246,7 +246,7 @@ _mm_maskz_xor_pd (__mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m256 DEFAULT_FN_ATTRS +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, @@ -254,7 +254,7 @@ _mm256_mask_xor_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m256 DEFAULT_FN_ATTRS +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, @@ -263,7 +263,7 @@ _mm256_maskz_xor_ps (__mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m128 DEFAULT_FN_ATTRS +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, @@ -271,7 +271,7 @@ _mm_mask_xor_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m128 DEFAULT_FN_ATTRS +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, @@ -280,7 +280,7 @@ _mm_maskz_xor_ps (__mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m256d DEFAULT_FN_ATTRS +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, @@ -288,7 +288,7 @@ _mm256_mask_or_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m256d DEFAULT_FN_ATTRS +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, @@ -297,7 +297,7 @@ _mm256_maskz_or_pd (__mmask8 __U, __m256d __A, __m256d __B) { (__mmask8) __U); } -static __inline__ __m128d DEFAULT_FN_ATTRS +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, @@ -305,7 +305,7 @@ _mm_mask_or_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m128d DEFAULT_FN_ATTRS +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, @@ -314,7 +314,7 @@ _mm_maskz_or_pd (__mmask8 __U, __m128d __A, __m128d __B) { (__mmask8) __U); } -static __inline__ __m256 DEFAULT_FN_ATTRS +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, @@ -322,7 +322,7 @@ _mm256_mask_or_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m256 DEFAULT_FN_ATTRS +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, @@ -331,7 +331,7 @@ _mm256_maskz_or_ps (__mmask8 __U, __m256 __A, __m256 __B) { (__mmask8) __U); } -static __inline__ __m128 DEFAULT_FN_ATTRS +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, @@ -339,7 +339,7 @@ _mm_mask_or_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -static __inline__ __m128 DEFAULT_FN_ATTRS +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, @@ -348,6 +348,6 @@ _mm_maskz_or_ps (__mmask8 __U, __m128 __A, __m128 __B) { (__mmask8) __U); } -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif diff --git a/lib/Headers/avx512vlintrin.h b/lib/Headers/avx512vlintrin.h index 59ff5ebfd574..73f46d101a55 100644 --- a/lib/Headers/avx512vlintrin.h +++ b/lib/Headers/avx512vlintrin.h @@ -29,198 +29,198 @@ #define __AVX512VLINTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512vl"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512vl"))) /* Integer compare */ -static __inline__ __mmask8 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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); @@ -229,391 +229,391 @@ _mm256_mask_cmpge_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { -static __inline__ __mmask8 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_add_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -623,7 +623,7 @@ _mm256_mask_add_epi32 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_add_epi32 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_paddd256_mask ((__v8si) __A, @@ -633,7 +633,7 @@ _mm256_maskz_add_epi32 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_add_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -643,7 +643,7 @@ _mm256_mask_add_epi64 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_add_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_paddq256_mask ((__v4di) __A, @@ -653,7 +653,7 @@ _mm256_maskz_add_epi64 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_sub_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -663,7 +663,7 @@ _mm256_mask_sub_epi32 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_sub_epi32 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_psubd256_mask ((__v8si) __A, @@ -673,7 +673,7 @@ _mm256_maskz_sub_epi32 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_sub_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -683,7 +683,7 @@ _mm256_mask_sub_epi64 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_sub_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_psubq256_mask ((__v4di) __A, @@ -693,7 +693,7 @@ _mm256_maskz_sub_epi64 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mask_add_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -703,7 +703,7 @@ _mm_mask_add_epi32 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_add_epi32 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_paddd128_mask ((__v4si) __A, @@ -713,7 +713,7 @@ _mm_maskz_add_epi32 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mask_add_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -723,7 +723,7 @@ _mm_mask_add_epi64 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_add_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_paddq128_mask ((__v2di) __A, @@ -733,7 +733,7 @@ _mm_maskz_add_epi64 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mask_sub_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -743,7 +743,7 @@ _mm_mask_sub_epi32 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_sub_epi32 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_psubd128_mask ((__v4si) __A, @@ -753,7 +753,7 @@ _mm_maskz_sub_epi32 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mask_sub_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -763,7 +763,7 @@ _mm_mask_sub_epi64 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_sub_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_psubq128_mask ((__v2di) __A, @@ -773,7 +773,7 @@ _mm_maskz_sub_epi64 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_mul_epi32 (__m256i __W, __mmask8 __M, __m256i __X, __m256i __Y) { @@ -782,7 +782,7 @@ _mm256_mask_mul_epi32 (__m256i __W, __mmask8 __M, __m256i __X, (__v4di) __W, __M); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_mul_epi32 (__mmask8 __M, __m256i __X, __m256i __Y) { return (__m256i) __builtin_ia32_pmuldq256_mask ((__v8si) __X, @@ -792,7 +792,7 @@ _mm256_maskz_mul_epi32 (__mmask8 __M, __m256i __X, __m256i __Y) __M); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mask_mul_epi32 (__m128i __W, __mmask8 __M, __m128i __X, __m128i __Y) { @@ -801,7 +801,7 @@ _mm_mask_mul_epi32 (__m128i __W, __mmask8 __M, __m128i __X, (__v2di) __W, __M); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_mul_epi32 (__mmask8 __M, __m128i __X, __m128i __Y) { return (__m128i) __builtin_ia32_pmuldq128_mask ((__v4si) __X, @@ -811,7 +811,7 @@ _mm_maskz_mul_epi32 (__mmask8 __M, __m128i __X, __m128i __Y) __M); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_mul_epu32 (__m256i __W, __mmask8 __M, __m256i __X, __m256i __Y) { @@ -820,7 +820,7 @@ _mm256_mask_mul_epu32 (__m256i __W, __mmask8 __M, __m256i __X, (__v4di) __W, __M); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_mul_epu32 (__mmask8 __M, __m256i __X, __m256i __Y) { return (__m256i) __builtin_ia32_pmuludq256_mask ((__v8si) __X, @@ -830,7 +830,7 @@ _mm256_maskz_mul_epu32 (__mmask8 __M, __m256i __X, __m256i __Y) __M); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mask_mul_epu32 (__m128i __W, __mmask8 __M, __m128i __X, __m128i __Y) { @@ -839,7 +839,7 @@ _mm_mask_mul_epu32 (__m128i __W, __mmask8 __M, __m128i __X, (__v2di) __W, __M); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_mul_epu32 (__mmask8 __M, __m128i __X, __m128i __Y) { return (__m128i) __builtin_ia32_pmuludq128_mask ((__v4si) __X, @@ -849,7 +849,7 @@ _mm_maskz_mul_epu32 (__mmask8 __M, __m128i __X, __m128i __Y) __M); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_mullo_epi32 (__mmask8 __M, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pmulld256_mask ((__v8si) __A, @@ -859,7 +859,7 @@ _mm256_maskz_mullo_epi32 (__mmask8 __M, __m256i __A, __m256i __B) __M); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_mullo_epi32 (__m256i __W, __mmask8 __M, __m256i __A, __m256i __B) { @@ -868,7 +868,7 @@ _mm256_mask_mullo_epi32 (__m256i __W, __mmask8 __M, __m256i __A, (__v8si) __W, __M); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_mullo_epi32 (__mmask8 __M, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pmulld128_mask ((__v4si) __A, @@ -878,7 +878,7 @@ _mm_maskz_mullo_epi32 (__mmask8 __M, __m128i __A, __m128i __B) __M); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mask_mullo_epi32 (__m128i __W, __mmask16 __M, __m128i __A, __m128i __B) { @@ -887,7 +887,7 @@ _mm_mask_mullo_epi32 (__m128i __W, __mmask16 __M, __m128i __A, (__v4si) __W, __M); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_and_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -897,7 +897,7 @@ _mm256_mask_and_epi32 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_and_epi32 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pandd256_mask ((__v8si) __A, @@ -907,7 +907,7 @@ _mm256_maskz_and_epi32 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -916,7 +916,7 @@ _mm_mask_and_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_and_epi32 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pandd128_mask ((__v4si) __A, @@ -926,7 +926,7 @@ _mm_maskz_and_epi32 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_andnot_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -936,7 +936,7 @@ _mm256_mask_andnot_epi32 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_andnot_epi32 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pandnd256_mask ((__v8si) __A, @@ -946,7 +946,7 @@ _mm256_maskz_andnot_epi32 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mask_andnot_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -956,7 +956,7 @@ _mm_mask_andnot_epi32 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_andnot_epi32 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pandnd128_mask ((__v4si) __A, @@ -966,7 +966,7 @@ _mm_maskz_andnot_epi32 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_or_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -976,7 +976,7 @@ _mm256_mask_or_epi32 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_or_epi32 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pord256_mask ((__v8si) __A, @@ -986,7 +986,7 @@ _mm256_maskz_or_epi32 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -995,7 +995,7 @@ _mm_mask_or_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_or_epi32 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pord128_mask ((__v4si) __A, @@ -1005,7 +1005,7 @@ _mm_maskz_or_epi32 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_xor_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -1015,7 +1015,7 @@ _mm256_mask_xor_epi32 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_xor_epi32 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pxord256_mask ((__v8si) __A, @@ -1025,7 +1025,7 @@ _mm256_maskz_xor_epi32 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mask_xor_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -1035,7 +1035,7 @@ _mm_mask_xor_epi32 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_xor_epi32 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pxord128_mask ((__v4si) __A, @@ -1045,7 +1045,7 @@ _mm_maskz_xor_epi32 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_and_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -1054,7 +1054,7 @@ _mm256_mask_and_epi64 (__m256i __W, __mmask8 __U, __m256i __A, (__v4di) __W, __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_and_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pandq256_mask ((__v4di) __A, @@ -1064,7 +1064,7 @@ _mm256_maskz_and_epi64 (__mmask8 __U, __m256i __A, __m256i __B) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mask_and_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -1073,7 +1073,7 @@ _mm_mask_and_epi64 (__m128i __W, __mmask8 __U, __m128i __A, (__v2di) __W, __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_and_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pandq128_mask ((__v2di) __A, @@ -1083,7 +1083,7 @@ _mm_maskz_and_epi64 (__mmask8 __U, __m128i __A, __m128i __B) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_andnot_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -1092,7 +1092,7 @@ _mm256_mask_andnot_epi64 (__m256i __W, __mmask8 __U, __m256i __A, (__v4di) __W, __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_andnot_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pandnq256_mask ((__v4di) __A, @@ -1102,7 +1102,7 @@ _mm256_maskz_andnot_epi64 (__mmask8 __U, __m256i __A, __m256i __B) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mask_andnot_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -1111,7 +1111,7 @@ _mm_mask_andnot_epi64 (__m128i __W, __mmask8 __U, __m128i __A, (__v2di) __W, __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_andnot_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pandnq128_mask ((__v2di) __A, @@ -1121,7 +1121,7 @@ _mm_maskz_andnot_epi64 (__mmask8 __U, __m128i __A, __m128i __B) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_or_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -1131,7 +1131,7 @@ _mm256_mask_or_epi64 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_or_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_porq256_mask ((__v4di) __A, @@ -1141,7 +1141,7 @@ _mm256_maskz_or_epi64 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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, @@ -1150,7 +1150,7 @@ _mm_mask_or_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_or_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_porq128_mask ((__v2di) __A, @@ -1160,7 +1160,7 @@ _mm_maskz_or_epi64 (__mmask8 __U, __m128i __A, __m128i __B) (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_mask_xor_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { @@ -1170,7 +1170,7 @@ _mm256_mask_xor_epi64 (__m256i __W, __mmask8 __U, __m256i __A, (__mmask8) __U); } -static __inline__ __m256i DEFAULT_FN_ATTRS +static __inline__ __m256i __DEFAULT_FN_ATTRS _mm256_maskz_xor_epi64 (__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i) __builtin_ia32_pxorq256_mask ((__v4di) __A, @@ -1180,7 +1180,7 @@ _mm256_maskz_xor_epi64 (__mmask8 __U, __m256i __A, __m256i __B) (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mask_xor_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { @@ -1190,7 +1190,7 @@ _mm_mask_xor_epi64 (__m128i __W, __mmask8 __U, __m128i __A, (__mmask8) __U); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_maskz_xor_epi64 (__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i) __builtin_ia32_pxorq128_mask ((__v2di) __A, @@ -1320,6 +1320,663 @@ _mm_maskz_xor_epi64 (__mmask8 __U, __m128i __A, __m128i __B) (__v2df)(__m128)(b), \ (p), (__mmask8)(m)); }) -#undef DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_mask_fmadd_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) +{ + return (__m128d) __builtin_ia32_vfmaddpd128_mask ((__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_mask3_fmadd_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) +{ + return (__m128d) __builtin_ia32_vfmaddpd128_mask3 ((__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_maskz_fmadd_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) +{ + return (__m128d) __builtin_ia32_vfmaddpd128_maskz ((__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_mask_fmsub_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) +{ + return (__m128d) __builtin_ia32_vfmaddpd128_mask ((__v2df) __A, + (__v2df) __B, + -(__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_maskz_fmsub_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) +{ + return (__m128d) __builtin_ia32_vfmaddpd128_maskz ((__v2df) __A, + (__v2df) __B, + -(__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_mask3_fnmadd_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) +{ + return (__m128d) __builtin_ia32_vfmaddpd128_mask3 (-(__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_maskz_fnmadd_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) +{ + return (__m128d) __builtin_ia32_vfmaddpd128_maskz (-(__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_maskz_fnmsub_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) +{ + return (__m128d) __builtin_ia32_vfmaddpd128_maskz (-(__v2df) __A, + (__v2df) __B, + -(__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_mask_fmadd_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) +{ + return (__m256d) __builtin_ia32_vfmaddpd256_mask ((__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_mask3_fmadd_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) +{ + return (__m256d) __builtin_ia32_vfmaddpd256_mask3 ((__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_maskz_fmadd_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) +{ + return (__m256d) __builtin_ia32_vfmaddpd256_maskz ((__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_mask_fmsub_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) +{ + return (__m256d) __builtin_ia32_vfmaddpd256_mask ((__v4df) __A, + (__v4df) __B, + -(__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_maskz_fmsub_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) +{ + return (__m256d) __builtin_ia32_vfmaddpd256_maskz ((__v4df) __A, + (__v4df) __B, + -(__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_mask3_fnmadd_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) +{ + return (__m256d) __builtin_ia32_vfmaddpd256_mask3 (-(__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_maskz_fnmadd_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) +{ + return (__m256d) __builtin_ia32_vfmaddpd256_maskz (-(__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_maskz_fnmsub_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) +{ + return (__m256d) __builtin_ia32_vfmaddpd256_maskz (-(__v4df) __A, + (__v4df) __B, + -(__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_mask_fmadd_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) +{ + return (__m128) __builtin_ia32_vfmaddps128_mask ((__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_mask3_fmadd_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) +{ + return (__m128) __builtin_ia32_vfmaddps128_mask3 ((__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_maskz_fmadd_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) +{ + return (__m128) __builtin_ia32_vfmaddps128_maskz ((__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_mask_fmsub_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) +{ + return (__m128) __builtin_ia32_vfmaddps128_mask ((__v4sf) __A, + (__v4sf) __B, + -(__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_maskz_fmsub_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) +{ + return (__m128) __builtin_ia32_vfmaddps128_maskz ((__v4sf) __A, + (__v4sf) __B, + -(__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_mask3_fnmadd_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) +{ + return (__m128) __builtin_ia32_vfmaddps128_mask3 (-(__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_maskz_fnmadd_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) +{ + return (__m128) __builtin_ia32_vfmaddps128_maskz (-(__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_maskz_fnmsub_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) +{ + return (__m128) __builtin_ia32_vfmaddps128_maskz (-(__v4sf) __A, + (__v4sf) __B, + -(__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_mask_fmadd_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) +{ + return (__m256) __builtin_ia32_vfmaddps256_mask ((__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_mask3_fmadd_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) +{ + return (__m256) __builtin_ia32_vfmaddps256_mask3 ((__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_maskz_fmadd_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) +{ + return (__m256) __builtin_ia32_vfmaddps256_maskz ((__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_mask_fmsub_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) +{ + return (__m256) __builtin_ia32_vfmaddps256_mask ((__v8sf) __A, + (__v8sf) __B, + -(__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_maskz_fmsub_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) +{ + return (__m256) __builtin_ia32_vfmaddps256_maskz ((__v8sf) __A, + (__v8sf) __B, + -(__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_mask3_fnmadd_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) +{ + return (__m256) __builtin_ia32_vfmaddps256_mask3 (-(__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_maskz_fnmadd_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) +{ + return (__m256) __builtin_ia32_vfmaddps256_maskz (-(__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_maskz_fnmsub_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) +{ + return (__m256) __builtin_ia32_vfmaddps256_maskz (-(__v8sf) __A, + (__v8sf) __B, + -(__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_mask_fmaddsub_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) +{ + return (__m128d) __builtin_ia32_vfmaddsubpd128_mask ((__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_mask3_fmaddsub_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) +{ + return (__m128d) __builtin_ia32_vfmaddsubpd128_mask3 ((__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) + __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_maskz_fmaddsub_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) +{ + return (__m128d) __builtin_ia32_vfmaddsubpd128_maskz ((__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) + __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_mask_fmsubadd_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) +{ + return (__m128d) __builtin_ia32_vfmaddsubpd128_mask ((__v2df) __A, + (__v2df) __B, + -(__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_maskz_fmsubadd_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) +{ + return (__m128d) __builtin_ia32_vfmaddsubpd128_maskz ((__v2df) __A, + (__v2df) __B, + -(__v2df) __C, + (__mmask8) + __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_mask_fmaddsub_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) +{ + return (__m256d) __builtin_ia32_vfmaddsubpd256_mask ((__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_mask3_fmaddsub_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) +{ + return (__m256d) __builtin_ia32_vfmaddsubpd256_mask3 ((__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) + __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_maskz_fmaddsub_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) +{ + return (__m256d) __builtin_ia32_vfmaddsubpd256_maskz ((__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) + __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_mask_fmsubadd_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) +{ + return (__m256d) __builtin_ia32_vfmaddsubpd256_mask ((__v4df) __A, + (__v4df) __B, + -(__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_maskz_fmsubadd_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) +{ + return (__m256d) __builtin_ia32_vfmaddsubpd256_maskz ((__v4df) __A, + (__v4df) __B, + -(__v4df) __C, + (__mmask8) + __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_mask_fmaddsub_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) +{ + return (__m128) __builtin_ia32_vfmaddsubps128_mask ((__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_mask3_fmaddsub_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) +{ + return (__m128) __builtin_ia32_vfmaddsubps128_mask3 ((__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_maskz_fmaddsub_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) +{ + return (__m128) __builtin_ia32_vfmaddsubps128_maskz ((__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_mask_fmsubadd_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) +{ + return (__m128) __builtin_ia32_vfmaddsubps128_mask ((__v4sf) __A, + (__v4sf) __B, + -(__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_maskz_fmsubadd_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) +{ + return (__m128) __builtin_ia32_vfmaddsubps128_maskz ((__v4sf) __A, + (__v4sf) __B, + -(__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_mask_fmaddsub_ps(__m256 __A, __mmask8 __U, __m256 __B, + __m256 __C) +{ + return (__m256) __builtin_ia32_vfmaddsubps256_mask ((__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_mask3_fmaddsub_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) +{ + return (__m256) __builtin_ia32_vfmaddsubps256_mask3 ((__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_maskz_fmaddsub_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) +{ + return (__m256) __builtin_ia32_vfmaddsubps256_maskz ((__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_mask_fmsubadd_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) +{ + return (__m256) __builtin_ia32_vfmaddsubps256_mask ((__v8sf) __A, + (__v8sf) __B, + -(__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_maskz_fmsubadd_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) +{ + return (__m256) __builtin_ia32_vfmaddsubps256_maskz ((__v8sf) __A, + (__v8sf) __B, + -(__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_mask3_fmsub_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) +{ + return (__m128d) __builtin_ia32_vfmsubpd128_mask3 ((__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_mask3_fmsub_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) +{ + return (__m256d) __builtin_ia32_vfmsubpd256_mask3 ((__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_mask3_fmsub_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) +{ + return (__m128) __builtin_ia32_vfmsubps128_mask3 ((__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_mask3_fmsub_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) +{ + return (__m256) __builtin_ia32_vfmsubps256_mask3 ((__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_mask3_fmsubadd_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) +{ + return (__m128d) __builtin_ia32_vfmsubaddpd128_mask3 ((__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) + __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_mask3_fmsubadd_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) +{ + return (__m256d) __builtin_ia32_vfmsubaddpd256_mask3 ((__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) + __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_mask3_fmsubadd_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) +{ + return (__m128) __builtin_ia32_vfmsubaddps128_mask3 ((__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_mask3_fmsubadd_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) +{ + return (__m256) __builtin_ia32_vfmsubaddps256_mask3 ((__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_mask_fnmadd_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) +{ + return (__m128d) __builtin_ia32_vfnmaddpd128_mask ((__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_mask_fnmadd_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) +{ + return (__m256d) __builtin_ia32_vfnmaddpd256_mask ((__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_mask_fnmadd_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) +{ + return (__m128) __builtin_ia32_vfnmaddps128_mask ((__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_mask_fnmadd_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) +{ + return (__m256) __builtin_ia32_vfnmaddps256_mask ((__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_mask_fnmsub_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) +{ + return (__m128d) __builtin_ia32_vfnmsubpd128_mask ((__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m128d __DEFAULT_FN_ATTRS +_mm_mask3_fnmsub_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) +{ + return (__m128d) __builtin_ia32_vfnmsubpd128_mask3 ((__v2df) __A, + (__v2df) __B, + (__v2df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_mask_fnmsub_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) +{ + return (__m256d) __builtin_ia32_vfnmsubpd256_mask ((__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m256d __DEFAULT_FN_ATTRS +_mm256_mask3_fnmsub_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) +{ + return (__m256d) __builtin_ia32_vfnmsubpd256_mask3 ((__v4df) __A, + (__v4df) __B, + (__v4df) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_mask_fnmsub_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) +{ + return (__m128) __builtin_ia32_vfnmsubps128_mask ((__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m128 __DEFAULT_FN_ATTRS +_mm_mask3_fnmsub_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) +{ + return (__m128) __builtin_ia32_vfnmsubps128_mask3 ((__v4sf) __A, + (__v4sf) __B, + (__v4sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_mask_fnmsub_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) +{ + return (__m256) __builtin_ia32_vfnmsubps256_mask ((__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +static __inline__ __m256 __DEFAULT_FN_ATTRS +_mm256_mask3_fnmsub_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) +{ + return (__m256) __builtin_ia32_vfnmsubps256_mask3 ((__v8sf) __A, + (__v8sf) __B, + (__v8sf) __C, + (__mmask8) __U); +} + +#undef __DEFAULT_FN_ATTRS #endif /* __AVX512VLINTRIN_H */ diff --git a/lib/Headers/avxintrin.h b/lib/Headers/avxintrin.h index d28a9155266a..6a9972b65bb0 100644 --- a/lib/Headers/avxintrin.h +++ b/lib/Headers/avxintrin.h @@ -40,112 +40,112 @@ 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"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx"))) /* Arithmetic */ -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_add_pd(__m256d __a, __m256d __b) { return __a+__b; } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_add_ps(__m256 __a, __m256 __b) { return __a+__b; } -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_sub_pd(__m256d __a, __m256d __b) { return __a-__b; } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_sub_ps(__m256 __a, __m256 __b) { return __a-__b; } -static __inline __m256d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_div_pd(__m256d __a, __m256d __b) { return __a / __b; } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_div_ps(__m256 __a, __m256 __b) { return __a / __b; } -static __inline __m256d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_mul_pd(__m256d __a, __m256d __b) { return __a * __b; } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_mul_ps(__m256 __a, __m256 __b) { return __a * __b; } -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_sqrt_pd(__m256d __a) { return (__m256d)__builtin_ia32_sqrtpd256((__v4df)__a); } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_sqrt_ps(__m256 __a) { return (__m256)__builtin_ia32_sqrtps256((__v8sf)__a); } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_rsqrt_ps(__m256 __a) { return (__m256)__builtin_ia32_rsqrtps256((__v8sf)__a); } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_rcp_ps(__m256 __a) { return (__m256)__builtin_ia32_rcpps256((__v8sf)__a); @@ -165,99 +165,99 @@ _mm256_rcp_ps(__m256 __a) #define _mm256_floor_ps(V) _mm256_round_ps((V), _MM_FROUND_FLOOR) /* Logical */ -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_and_pd(__m256d __a, __m256d __b) { return (__m256d)((__v4di)__a & (__v4di)__b); } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_and_ps(__m256 __a, __m256 __b) { return (__m256)((__v8si)__a & (__v8si)__b); } -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_andnot_pd(__m256d __a, __m256d __b) { return (__m256d)(~(__v4di)__a & (__v4di)__b); } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_andnot_ps(__m256 __a, __m256 __b) { return (__m256)(~(__v8si)__a & (__v8si)__b); } -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_or_pd(__m256d __a, __m256d __b) { return (__m256d)((__v4di)__a | (__v4di)__b); } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_or_ps(__m256 __a, __m256 __b) { return (__m256)((__v8si)__a | (__v8si)__b); } -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_xor_pd(__m256d __a, __m256d __b) { return (__m256d)((__v4di)__a ^ (__v4di)__b); } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_xor_ps(__m256 __a, __m256 __b) { return (__m256)((__v8si)__a ^ (__v8si)__b); } /* Horizontal arithmetic */ -static __inline __m256d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_permutevar_ps(__m256 __a, __m256i __c) { return (__m256)__builtin_ia32_vpermilvarps256((__v8sf)__a, (__v8si)__c); @@ -329,14 +329,14 @@ _mm256_permutevar_ps(__m256 __a, __m256i __c) (((M) & 0x40) ? 14 : 6), \ (((M) & 0x80) ? 15 : 7)); }) -static __inline __m256d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c) { return (__m256)__builtin_ia32_blendvps256( @@ -432,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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm256_extract_epi8(__m256i __a, const int __imm) { __v32qi __b = (__v32qi)__a; @@ -454,7 +454,7 @@ _mm256_extract_epi8(__m256i __a, const int __imm) } #ifdef __x86_64__ -static __inline long long DEFAULT_FN_ATTRS +static __inline long long __DEFAULT_FN_ATTRS _mm256_extract_epi64(__m256i __a, const int __imm) { __v4di __b = (__v4di)__a; @@ -462,7 +462,7 @@ _mm256_extract_epi64(__m256i __a, const int __imm) } #endif -static __inline __m256i DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_insert_epi32(__m256i __a, int __b, int const __imm) { __v8si __c = (__v8si)__a; @@ -470,7 +470,7 @@ _mm256_insert_epi32(__m256i __a, int __b, int const __imm) return (__m256i)__c; } -static __inline __m256i DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_insert_epi16(__m256i __a, int __b, int const __imm) { __v16hi __c = (__v16hi)__a; @@ -478,7 +478,7 @@ _mm256_insert_epi16(__m256i __a, int __b, int const __imm) return (__m256i)__c; } -static __inline __m256i DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_insert_epi8(__m256i __a, int __b, int const __imm) { __v32qi __c = (__v32qi)__a; @@ -487,7 +487,7 @@ _mm256_insert_epi8(__m256i __a, int __b, int const __imm) } #ifdef __x86_64__ -static __inline __m256i DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_insert_epi64(__m256i __a, long long __b, int const __imm) { __v4di __c = (__v4di)__a; @@ -497,263 +497,263 @@ _mm256_insert_epi64(__m256i __a, long long __b, int const __imm) #endif /* Conversion */ -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_cvtepi32_pd(__m128i __a) { return (__m256d)__builtin_ia32_cvtdq2pd256((__v4si) __a); } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_cvtepi32_ps(__m256i __a) { return (__m256)__builtin_ia32_cvtdq2ps256((__v8si) __a); } -static __inline __m128 DEFAULT_FN_ATTRS +static __inline __m128 __DEFAULT_FN_ATTRS _mm256_cvtpd_ps(__m256d __a) { return (__m128)__builtin_ia32_cvtpd2ps256((__v4df) __a); } -static __inline __m256i DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_cvtps_epi32(__m256 __a) { return (__m256i)__builtin_ia32_cvtps2dq256((__v8sf) __a); } -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_cvtps_pd(__m128 __a) { return (__m256d)__builtin_ia32_cvtps2pd256((__v4sf) __a); } -static __inline __m128i DEFAULT_FN_ATTRS +static __inline __m128i __DEFAULT_FN_ATTRS _mm256_cvttpd_epi32(__m256d __a) { return (__m128i)__builtin_ia32_cvttpd2dq256((__v4df) __a); } -static __inline __m128i DEFAULT_FN_ATTRS +static __inline __m128i __DEFAULT_FN_ATTRS _mm256_cvtpd_epi32(__m256d __a) { return (__m128i)__builtin_ia32_cvtpd2dq256((__v4df) __a); } -static __inline __m256i DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_cvttps_epi32(__m256 __a) { return (__m256i)__builtin_ia32_cvttps2dq256((__v8sf) __a); } /* Vector replicate */ -static __inline __m256 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm_testz_pd(__m128d __a, __m128d __b) { return __builtin_ia32_vtestzpd((__v2df)__a, (__v2df)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm_testc_pd(__m128d __a, __m128d __b) { return __builtin_ia32_vtestcpd((__v2df)__a, (__v2df)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm_testnzc_pd(__m128d __a, __m128d __b) { return __builtin_ia32_vtestnzcpd((__v2df)__a, (__v2df)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm_testz_ps(__m128 __a, __m128 __b) { return __builtin_ia32_vtestzps((__v4sf)__a, (__v4sf)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm_testc_ps(__m128 __a, __m128 __b) { return __builtin_ia32_vtestcps((__v4sf)__a, (__v4sf)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm_testnzc_ps(__m128 __a, __m128 __b) { return __builtin_ia32_vtestnzcps((__v4sf)__a, (__v4sf)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm256_testz_pd(__m256d __a, __m256d __b) { return __builtin_ia32_vtestzpd256((__v4df)__a, (__v4df)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm256_testc_pd(__m256d __a, __m256d __b) { return __builtin_ia32_vtestcpd256((__v4df)__a, (__v4df)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm256_testnzc_pd(__m256d __a, __m256d __b) { return __builtin_ia32_vtestnzcpd256((__v4df)__a, (__v4df)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm256_testz_ps(__m256 __a, __m256 __b) { return __builtin_ia32_vtestzps256((__v8sf)__a, (__v8sf)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm256_testc_ps(__m256 __a, __m256 __b) { return __builtin_ia32_vtestcps256((__v8sf)__a, (__v8sf)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm256_testnzc_ps(__m256 __a, __m256 __b) { return __builtin_ia32_vtestnzcps256((__v8sf)__a, (__v8sf)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm256_testz_si256(__m256i __a, __m256i __b) { return __builtin_ia32_ptestz256((__v4di)__a, (__v4di)__b); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm256_testc_si256(__m256i __a, __m256i __b) { return __builtin_ia32_ptestc256((__v4di)__a, (__v4di)__b); } -static __inline int DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm256_movemask_pd(__m256d __a) { return __builtin_ia32_movmskpd256((__v4df)__a); } -static __inline int DEFAULT_FN_ATTRS +static __inline int __DEFAULT_FN_ATTRS _mm256_movemask_ps(__m256 __a) { return __builtin_ia32_movmskps256((__v8sf)__a); } /* Vector __zero */ -static __inline void DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_zeroall(void) { __builtin_ia32_vzeroall(); } -static __inline void DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_zeroupper(void) { __builtin_ia32_vzeroupper(); } /* Vector load with broadcast */ -static __inline __m128 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_broadcast_pd(__m128d const *__a) { return (__m256d)__builtin_ia32_vbroadcastf128_pd256(__a); } -static __inline __m256 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_load_pd(double const *__p) { return *(__m256d *)__p; } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_load_ps(float const *__p) { return *(__m256 *)__p; } -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_loadu_pd(double const *__p) { struct __loadu_pd { @@ -762,7 +762,7 @@ _mm256_loadu_pd(double const *__p) return ((struct __loadu_pd*)__p)->__v; } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_loadu_ps(float const *__p) { struct __loadu_ps { @@ -771,13 +771,13 @@ _mm256_loadu_ps(float const *__p) return ((struct __loadu_ps*)__p)->__v; } -static __inline __m256i DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_load_si256(__m256i const *__p) { return *__p; } -static __inline __m256i DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_loadu_si256(__m256i const *__p) { struct __loadu_si256 { @@ -786,141 +786,141 @@ _mm256_loadu_si256(__m256i const *__p) return ((struct __loadu_si256*)__p)->__v; } -static __inline __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_store_pd(double *__p, __m256d __a) { *(__m256d *)__p = __a; } -static __inline void DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_store_ps(float *__p, __m256 __a) { *(__m256 *)__p = __a; } -static __inline void DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_storeu_pd(double *__p, __m256d __a) { __builtin_ia32_storeupd256(__p, (__v4df)__a); } -static __inline void DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_storeu_ps(float *__p, __m256 __a) { __builtin_ia32_storeups256(__p, (__v8sf)__a); } -static __inline void DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_store_si256(__m256i *__p, __m256i __a) { *__p = __a; } -static __inline void DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_stream_si256(__m256i *__a, __m256i __b) { __builtin_ia32_movntdq256((__v4di *)__a, (__v4di)__b); } -static __inline void DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_stream_pd(double *__a, __m256d __b) { __builtin_ia32_movntpd256(__a, (__v4df)__b); } -static __inline void DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_stream_ps(float *__p, __m256 __a) { __builtin_ia32_movntps256(__p, (__v8sf)__a); } /* Create vectors */ -static __inline __m256d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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, @@ -930,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 DEFAULT_FN_ATTRS +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, @@ -948,34 +948,34 @@ _mm256_set_epi8(char __b31, char __b30, char __b29, char __b28, }; } -static __inline __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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, @@ -985,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 DEFAULT_FN_ATTRS +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, @@ -1002,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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_set1_pd(double __w) { return (__m256d){ __w, __w, __w, __w }; } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_set1_ps(float __w) { return (__m256){ __w, __w, __w, __w, __w, __w, __w, __w }; } -static __inline __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_set1_epi8(char __b) { return (__m256i)(__v32qi){ __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, @@ -1042,99 +1042,99 @@ _mm256_set1_epi8(char __b) __b, __b, __b, __b, __b, __b, __b }; } -static __inline __m256i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_setzero_pd(void) { return (__m256d){ 0, 0, 0, 0 }; } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_setzero_ps(void) { return (__m256){ 0, 0, 0, 0, 0, 0, 0, 0 }; } -static __inline __m256i DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_setzero_si256(void) { return (__m256i){ 0LL, 0LL, 0LL, 0LL }; } /* Cast between vector types */ -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_castpd_ps(__m256d __a) { return (__m256)__a; } -static __inline __m256i DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_castpd_si256(__m256d __a) { return (__m256i)__a; } -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_castps_pd(__m256 __a) { return (__m256d)__a; } -static __inline __m256i DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_castps_si256(__m256 __a) { return (__m256i)__a; } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_castsi256_ps(__m256i __a) { return (__m256)__a; } -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_castsi256_pd(__m256i __a) { return (__m256d)__a; } -static __inline __m128d DEFAULT_FN_ATTRS +static __inline __m128d __DEFAULT_FN_ATTRS _mm256_castpd256_pd128(__m256d __a) { return __builtin_shufflevector(__a, __a, 0, 1); } -static __inline __m128 DEFAULT_FN_ATTRS +static __inline __m128 __DEFAULT_FN_ATTRS _mm256_castps256_ps128(__m256 __a) { return __builtin_shufflevector(__a, __a, 0, 1, 2, 3); } -static __inline __m128i DEFAULT_FN_ATTRS +static __inline __m128i __DEFAULT_FN_ATTRS _mm256_castsi256_si128(__m256i __a) { return __builtin_shufflevector(__a, __a, 0, 1); } -static __inline __m256d DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_castpd128_pd256(__m128d __a) { return __builtin_shufflevector(__a, __a, 0, 1, -1, -1); } -static __inline __m256 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_castsi128_si256(__m128i __a) { return __builtin_shufflevector(__a, __a, 0, 1, -1, -1); @@ -1205,7 +1205,7 @@ _mm256_castsi128_si256(__m128i __a) (((M) & 1) ? 3 : 1) );}) /* SIMD load ops (unaligned) */ -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_loadu2_m128(float const *__addr_hi, float const *__addr_lo) { struct __loadu_ps { @@ -1216,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 DEFAULT_FN_ATTRS +static __inline __m256d __DEFAULT_FN_ATTRS _mm256_loadu2_m128d(double const *__addr_hi, double const *__addr_lo) { struct __loadu_pd { @@ -1227,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 DEFAULT_FN_ATTRS +static __inline __m256i __DEFAULT_FN_ATTRS _mm256_loadu2_m128i(__m128i const *__addr_hi, __m128i const *__addr_lo) { struct __loadu_si128 { @@ -1240,7 +1240,7 @@ _mm256_loadu2_m128i(__m128i const *__addr_hi, __m128i const *__addr_lo) } /* SIMD store ops (unaligned) */ -static __inline void DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_storeu2_m128(float *__addr_hi, float *__addr_lo, __m256 __a) { __m128 __v128; @@ -1251,7 +1251,7 @@ _mm256_storeu2_m128(float *__addr_hi, float *__addr_lo, __m256 __a) __builtin_ia32_storeups(__addr_hi, __v128); } -static __inline void DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_storeu2_m128d(double *__addr_hi, double *__addr_lo, __m256d __a) { __m128d __v128; @@ -1262,7 +1262,7 @@ _mm256_storeu2_m128d(double *__addr_hi, double *__addr_lo, __m256d __a) __builtin_ia32_storeupd(__addr_hi, __v128); } -static __inline void DEFAULT_FN_ATTRS +static __inline void __DEFAULT_FN_ATTRS _mm256_storeu2_m128i(__m128i *__addr_hi, __m128i *__addr_lo, __m256i __a) { __m128i __v128; @@ -1273,36 +1273,36 @@ _mm256_storeu2_m128i(__m128i *__addr_hi, __m128i *__addr_lo, __m256i __a) __builtin_ia32_storedqu((char *)__addr_hi, (__v16qi)__v128); } -static __inline __m256 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_setr_m128 (__m128 __lo, __m128 __hi) { return _mm256_set_m128(__hi, __lo); } -static __inline __m256d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 +#undef __DEFAULT_FN_ATTRS #endif /* __AVXINTRIN_H */ diff --git a/lib/Headers/bmi2intrin.h b/lib/Headers/bmi2intrin.h index 7818934e17c2..fdae82cf2ba7 100644 --- a/lib/Headers/bmi2intrin.h +++ b/lib/Headers/bmi2intrin.h @@ -29,21 +29,21 @@ #define __BMI2INTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi2"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi2"))) -static __inline__ unsigned int DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS _pext_u32(unsigned int __X, unsigned int __Y) { return __builtin_ia32_pext_si(__X, __Y); @@ -51,25 +51,25 @@ _pext_u32(unsigned int __X, unsigned int __Y) #ifdef __x86_64__ -static __inline__ unsigned long long DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS _mulx_u64 (unsigned long long __X, unsigned long long __Y, unsigned long long *__P) { @@ -80,7 +80,7 @@ _mulx_u64 (unsigned long long __X, unsigned long long __Y, #else /* !__x86_64__ */ -static __inline__ unsigned int DEFAULT_FN_ATTRS +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; @@ -90,6 +90,6 @@ _mulx_u32 (unsigned int __X, unsigned int __Y, unsigned int *__P) #endif /* !__x86_64__ */ -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __BMI2INTRIN_H */ diff --git a/lib/Headers/bmiintrin.h b/lib/Headers/bmiintrin.h index 0aad8f24ea00..dc2f83f3e2d1 100644 --- a/lib/Headers/bmiintrin.h +++ b/lib/Headers/bmiintrin.h @@ -37,53 +37,53 @@ #define _tzcnt_u32(a) (__tzcnt_u32((a))) /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi"))) -static __inline__ unsigned short DEFAULT_FN_ATTRS +static __inline__ unsigned short __DEFAULT_FN_ATTRS __tzcnt_u16(unsigned short __X) { return __X ? __builtin_ctzs(__X) : 16; } -static __inline__ unsigned int DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __blsi_u32(unsigned int __X) { return __X & -__X; } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __blsmsk_u32(unsigned int __X) { return __X ^ (__X - 1); } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __blsr_u32(unsigned int __X) { return __X & (__X - 1); } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __tzcnt_u32(unsigned int __X) { return __X ? __builtin_ctz(__X) : 32; @@ -98,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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blsi_u64(unsigned long long __X) { return __X & -__X; } -static __inline__ unsigned long long DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blsmsk_u64(unsigned long long __X) { return __X ^ (__X - 1); } -static __inline__ unsigned long long DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blsr_u64(unsigned long long __X) { return __X & (__X - 1); } -static __inline__ unsigned long long DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __tzcnt_u64(unsigned long long __X) { return __X ? __builtin_ctzll(__X) : 64; @@ -144,6 +144,6 @@ __tzcnt_u64(unsigned long long __X) #endif /* __x86_64__ */ -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __BMIINTRIN_H */ diff --git a/lib/Headers/emmintrin.h b/lib/Headers/emmintrin.h index eee2428d41a0..e22ffaf19240 100644 --- a/lib/Headers/emmintrin.h +++ b/lib/Headers/emmintrin.h @@ -36,435 +36,435 @@ typedef short __v8hi __attribute__((__vector_size__(16))); typedef char __v16qi __attribute__((__vector_size__(16))); /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse2"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse2"))) -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_add_sd(__m128d __a, __m128d __b) { __a[0] += __b[0]; return __a; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_add_pd(__m128d __a, __m128d __b) { return __a + __b; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_sub_sd(__m128d __a, __m128d __b) { __a[0] -= __b[0]; return __a; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_sub_pd(__m128d __a, __m128d __b) { return __a - __b; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_mul_sd(__m128d __a, __m128d __b) { __a[0] *= __b[0]; return __a; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_mul_pd(__m128d __a, __m128d __b) { return __a * __b; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_div_sd(__m128d __a, __m128d __b) { __a[0] /= __b[0]; return __a; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_div_pd(__m128d __a, __m128d __b) { return __a / __b; } -static __inline__ __m128d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_sqrt_pd(__m128d __a) { return __builtin_ia32_sqrtpd(__a); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_min_sd(__m128d __a, __m128d __b) { return __builtin_ia32_minsd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_min_pd(__m128d __a, __m128d __b) { return __builtin_ia32_minpd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_max_sd(__m128d __a, __m128d __b) { return __builtin_ia32_maxsd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_max_pd(__m128d __a, __m128d __b) { return __builtin_ia32_maxpd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_and_pd(__m128d __a, __m128d __b) { return (__m128d)((__v4si)__a & (__v4si)__b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_andnot_pd(__m128d __a, __m128d __b) { return (__m128d)(~(__v4si)__a & (__v4si)__b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_or_pd(__m128d __a, __m128d __b) { return (__m128d)((__v4si)__a | (__v4si)__b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_xor_pd(__m128d __a, __m128d __b) { return (__m128d)((__v4si)__a ^ (__v4si)__b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpeq_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpeqpd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmplt_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpltpd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmple_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmplepd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpgt_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpltpd(__b, __a); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpge_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmplepd(__b, __a); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpord_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpordpd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpunord_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpunordpd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpneq_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpneqpd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnlt_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpnltpd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnle_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpnlepd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpngt_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpnltpd(__b, __a); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnge_pd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpnlepd(__b, __a); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpeq_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpeqsd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmplt_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpltsd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmple_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmplesd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpord_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpordsd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpunord_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpunordsd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpneq_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpneqsd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnlt_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpnltsd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnle_sd(__m128d __a, __m128d __b) { return (__m128d)__builtin_ia32_cmpnlesd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_comieq_sd(__m128d __a, __m128d __b) { return __builtin_ia32_comisdeq(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_comilt_sd(__m128d __a, __m128d __b) { return __builtin_ia32_comisdlt(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_comile_sd(__m128d __a, __m128d __b) { return __builtin_ia32_comisdle(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_comigt_sd(__m128d __a, __m128d __b) { return __builtin_ia32_comisdgt(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_comige_sd(__m128d __a, __m128d __b) { return __builtin_ia32_comisdge(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_comineq_sd(__m128d __a, __m128d __b) { return __builtin_ia32_comisdneq(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomieq_sd(__m128d __a, __m128d __b) { return __builtin_ia32_ucomisdeq(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomilt_sd(__m128d __a, __m128d __b) { return __builtin_ia32_ucomisdlt(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomile_sd(__m128d __a, __m128d __b) { return __builtin_ia32_ucomisdle(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomigt_sd(__m128d __a, __m128d __b) { return __builtin_ia32_ucomisdgt(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomige_sd(__m128d __a, __m128d __b) { return __builtin_ia32_ucomisdge(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomineq_sd(__m128d __a, __m128d __b) { return __builtin_ia32_ucomisdneq(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtpd_ps(__m128d __a) { return __builtin_ia32_cvtpd2ps(__a); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtps_pd(__m128 __a) { return __builtin_ia32_cvtps2pd(__a); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtepi32_pd(__m128i __a) { return __builtin_ia32_cvtdq2pd((__v4si)__a); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtpd_epi32(__m128d __a) { return __builtin_ia32_cvtpd2dq(__a); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_cvtsd_si32(__m128d __a) { return __builtin_ia32_cvtsd2si(__a); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtsd_ss(__m128 __a, __m128d __b) { __a[0] = __b[0]; return __a; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtsi32_sd(__m128d __a, int __b) { __a[0] = __b; return __a; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtss_sd(__m128d __a, __m128 __b) { __a[0] = __b[0]; return __a; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvttpd_epi32(__m128d __a) { return (__m128i)__builtin_ia32_cvttpd2dq(__a); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_cvttsd_si32(__m128d __a) { return __a[0]; } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_cvtpd_pi32(__m128d __a) { return (__m64)__builtin_ia32_cvtpd2pi(__a); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_cvttpd_pi32(__m128d __a) { return (__m64)__builtin_ia32_cvttpd2pi(__a); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtpi32_pd(__m64 __a) { return __builtin_ia32_cvtpi2pd((__v2si)__a); } -static __inline__ double DEFAULT_FN_ATTRS +static __inline__ double __DEFAULT_FN_ATTRS _mm_cvtsd_f64(__m128d __a) { return __a[0]; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_load_pd(double const *__dp) { return *(__m128d*)__dp; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_load1_pd(double const *__dp) { struct __mm_load1_pd_struct { @@ -476,14 +476,14 @@ _mm_load1_pd(double const *__dp) #define _mm_load_pd1(dp) _mm_load1_pd(dp) -static __inline__ __m128d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_loadu_pd(double const *__dp) { struct __loadu_pd { @@ -492,7 +492,7 @@ _mm_loadu_pd(double const *__dp) return ((struct __loadu_pd*)__dp)->__v; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_load_sd(double const *__dp) { struct __mm_load_sd_struct { @@ -502,7 +502,7 @@ _mm_load_sd(double const *__dp) return (__m128d){ __u, 0 }; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_loadh_pd(__m128d __a, double const *__dp) { struct __mm_loadh_pd_struct { @@ -512,7 +512,7 @@ _mm_loadh_pd(__m128d __a, double const *__dp) return (__m128d){ __a[0], __u }; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_loadl_pd(__m128d __a, double const *__dp) { struct __mm_loadl_pd_struct { @@ -522,43 +522,43 @@ _mm_loadl_pd(__m128d __a, double const *__dp) return (__m128d){ __u, __a[1] }; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_set_sd(double __w) { return (__m128d){ __w, 0 }; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_set1_pd(double __w) { return (__m128d){ __w, __w }; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_set_pd(double __w, double __x) { return (__m128d){ __x, __w }; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_setr_pd(double __w, double __x) { return (__m128d){ __w, __x }; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_setzero_pd(void) { return (__m128d){ 0, 0 }; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_move_sd(__m128d __a, __m128d __b) { return (__m128d){ __b[0], __a[1] }; } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_store_sd(double *__dp, __m128d __a) { struct __mm_store_sd_struct { @@ -567,7 +567,7 @@ _mm_store_sd(double *__dp, __m128d __a) ((struct __mm_store_sd_struct*)__dp)->__u = __a[0]; } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_store1_pd(double *__dp, __m128d __a) { struct __mm_store1_pd_struct { @@ -577,26 +577,26 @@ _mm_store1_pd(double *__dp, __m128d __a) ((struct __mm_store1_pd_struct*)__dp)->__u[1] = __a[0]; } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_store_pd(double *__dp, __m128d __a) { *(__m128d *)__dp = __a; } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_storeu_pd(double *__dp, __m128d __a) { __builtin_ia32_storeupd(__dp, __a); } -static __inline__ void DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_storeh_pd(double *__dp, __m128d __a) { struct __mm_storeh_pd_struct { @@ -605,7 +605,7 @@ _mm_storeh_pd(double *__dp, __m128d __a) ((struct __mm_storeh_pd_struct*)__dp)->__u = __a[1]; } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_storel_pd(double *__dp, __m128d __a) { struct __mm_storeh_pd_struct { @@ -614,211 +614,211 @@ _mm_storel_pd(double *__dp, __m128d __a) ((struct __mm_storeh_pd_struct*)__dp)->__u = __a[0]; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_add_epi8(__m128i __a, __m128i __b) { return (__m128i)((__v16qi)__a + (__v16qi)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_add_epi16(__m128i __a, __m128i __b) { return (__m128i)((__v8hi)__a + (__v8hi)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_add_epi32(__m128i __a, __m128i __b) { return (__m128i)((__v4si)__a + (__v4si)__b); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_add_si64(__m64 __a, __m64 __b) { return __a + __b; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_add_epi64(__m128i __a, __m128i __b) { return __a + __b; } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mullo_epi16(__m128i __a, __m128i __b) { return (__m128i)((__v8hi)__a * (__v8hi)__b); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_mul_su32(__m64 __a, __m64 __b) { return __builtin_ia32_pmuludq((__v2si)__a, (__v2si)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mul_epu32(__m128i __a, __m128i __b) { return __builtin_ia32_pmuludq128((__v4si)__a, (__v4si)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sad_epu8(__m128i __a, __m128i __b) { return __builtin_ia32_psadbw128((__v16qi)__a, (__v16qi)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sub_epi8(__m128i __a, __m128i __b) { return (__m128i)((__v16qi)__a - (__v16qi)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sub_epi16(__m128i __a, __m128i __b) { return (__m128i)((__v8hi)__a - (__v8hi)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sub_epi32(__m128i __a, __m128i __b) { return (__m128i)((__v4si)__a - (__v4si)__b); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_sub_si64(__m64 __a, __m64 __b) { return __a - __b; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sub_epi64(__m128i __a, __m128i __b) { return __a - __b; } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_and_si128(__m128i __a, __m128i __b) { return __a & __b; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_andnot_si128(__m128i __a, __m128i __b) { return ~__a & __b; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_or_si128(__m128i __a, __m128i __b) { return __a | __b; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_xor_si128(__m128i __a, __m128i __b) { return __a ^ __b; @@ -847,61 +847,61 @@ _mm_xor_si128(__m128i __a, __m128i __b) #define _mm_bslli_si128(a, imm) \ _mm_slli_si128((a), (imm)) -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_slli_epi16(__m128i __a, int __count) { return (__m128i)__builtin_ia32_psllwi128((__v8hi)__a, __count); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_slli_epi32(__m128i __a, int __count) { return (__m128i)__builtin_ia32_pslldi128((__v4si)__a, __count); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_slli_epi64(__m128i __a, int __count) { return __builtin_ia32_psllqi128(__a, __count); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sll_epi64(__m128i __a, __m128i __count) { return __builtin_ia32_psllq128(__a, __count); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srai_epi16(__m128i __a, int __count) { return (__m128i)__builtin_ia32_psrawi128((__v8hi)__a, __count); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srai_epi32(__m128i __a, int __count) { return (__m128i)__builtin_ia32_psradi128((__v4si)__a, __count); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sra_epi32(__m128i __a, __m128i __count) { return (__m128i)__builtin_ia32_psrad128((__v4si)__a, (__v4si)__count); @@ -930,61 +930,61 @@ _mm_sra_epi32(__m128i __a, __m128i __count) #define _mm_bsrli_si128(a, imm) \ _mm_srli_si128((a), (imm)) -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srli_epi16(__m128i __a, int __count) { return (__m128i)__builtin_ia32_psrlwi128((__v8hi)__a, __count); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srli_epi32(__m128i __a, int __count) { return (__m128i)__builtin_ia32_psrldi128((__v4si)__a, __count); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srli_epi64(__m128i __a, int __count) { return __builtin_ia32_psrlqi128(__a, __count); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srl_epi64(__m128i __a, __m128i __count) { return __builtin_ia32_psrlq128(__a, __count); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi8(__m128i __a, __m128i __b) { return (__m128i)((__v16qi)__a == (__v16qi)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi16(__m128i __a, __m128i __b) { return (__m128i)((__v8hi)__a == (__v8hi)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi32(__m128i __a, __m128i __b) { return (__m128i)((__v4si)__a == (__v4si)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 @@ -993,90 +993,90 @@ _mm_cmpgt_epi8(__m128i __a, __m128i __b) return (__m128i)((__v16qs)__a > (__v16qs)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpgt_epi16(__m128i __a, __m128i __b) { return (__m128i)((__v8hi)__a > (__v8hi)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpgt_epi32(__m128i __a, __m128i __b) { return (__m128i)((__v4si)__a > (__v4si)__b); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmplt_epi8(__m128i __a, __m128i __b) { return _mm_cmpgt_epi8(__b, __a); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmplt_epi16(__m128i __a, __m128i __b) { return _mm_cmpgt_epi16(__b, __a); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtsi64_sd(__m128d __a, long long __b) { __a[0] = __b; return __a; } -static __inline__ long long DEFAULT_FN_ATTRS +static __inline__ long long __DEFAULT_FN_ATTRS _mm_cvtsd_si64(__m128d __a) { return __builtin_ia32_cvtsd2si64(__a); } -static __inline__ long long DEFAULT_FN_ATTRS +static __inline__ long long __DEFAULT_FN_ATTRS _mm_cvttsd_si64(__m128d __a) { return __a[0]; } #endif -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtepi32_ps(__m128i __a) { return __builtin_ia32_cvtdq2ps((__v4si)__a); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtps_epi32(__m128 __a) { return (__m128i)__builtin_ia32_cvtps2dq(__a); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvttps_epi32(__m128 __a) { return (__m128i)__builtin_ia32_cvttps2dq(__a); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtsi32_si128(int __a) { return (__m128i)(__v4si){ __a, 0, 0, 0 }; } #ifdef __x86_64__ -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtsi64_si128(long long __a) { return (__m128i){ __a, 0 }; } #endif -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_cvtsi128_si32(__m128i __a) { __v4si __b = (__v4si)__a; @@ -1084,20 +1084,20 @@ _mm_cvtsi128_si32(__m128i __a) } #ifdef __x86_64__ -static __inline__ long long DEFAULT_FN_ATTRS +static __inline__ long long __DEFAULT_FN_ATTRS _mm_cvtsi128_si64(__m128i __a) { return __a[0]; } #endif -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_load_si128(__m128i const *__p) { return *__p; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_loadu_si128(__m128i const *__p) { struct __loadu_si128 { @@ -1106,7 +1106,7 @@ _mm_loadu_si128(__m128i const *__p) return ((struct __loadu_si128*)__p)->__v; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_loadl_epi64(__m128i const *__p) { struct __mm_loadl_epi64_struct { @@ -1115,115 +1115,115 @@ _mm_loadl_epi64(__m128i const *__p) return (__m128i) { ((struct __mm_loadl_epi64_struct*)__p)->__u, 0}; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set_epi64x(long long q1, long long q0) { return (__m128i){ q0, q1 }; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set_epi64(__m64 q1, __m64 q0) { return (__m128i){ (long long)q0, (long long)q1 }; } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set1_epi64x(long long __q) { return (__m128i){ __q, __q }; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set1_epi64(__m64 __q) { return (__m128i){ (long long)__q, (long long)__q }; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set1_epi32(int __i) { return (__m128i)(__v4si){ __i, __i, __i, __i }; } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_setr_epi64(__m64 q0, __m64 q1) { return (__m128i){ (long long)q0, (long long)q1 }; } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_setzero_si128(void) { return (__m128i){ 0LL, 0LL }; } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_store_si128(__m128i *__p, __m128i __b) { *__p = __b; } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_storeu_si128(__m128i *__p, __m128i __b) { __builtin_ia32_storedqu((char *)__p, (__v16qi)__b); } -static __inline__ void DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_storel_epi64(__m128i *__p, __m128i __a) { struct __mm_storel_epi64_struct { @@ -1232,76 +1232,76 @@ _mm_storel_epi64(__m128i *__p, __m128i __a) ((struct __mm_storel_epi64_struct*)__p)->__u = __a[0]; } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_stream_pd(double *__p, __m128d __a) { __builtin_ia32_movntpd(__p, __a); } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_stream_si128(__m128i *__p, __m128i __a) { __builtin_ia32_movntdq(__p, __a); } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_stream_si32(int *__p, int __a) { __builtin_ia32_movnti(__p, __a); } #ifdef __x86_64__ -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_stream_si64(long long *__p, long long __a) { __builtin_ia32_movnti64(__p, __a); } #endif -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_clflush(void const *__p) { __builtin_ia32_clflush(__p); } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_lfence(void) { __builtin_ia32_lfence(); } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_mfence(void) { __builtin_ia32_mfence(); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_insert_epi16(__m128i __a, int __b, int __imm) { __v8hi __c = (__v8hi)__a; @@ -1309,7 +1309,7 @@ _mm_insert_epi16(__m128i __a, int __b, int __imm) return (__m128i)__c; } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_movemask_epi8(__m128i __a) { return __builtin_ia32_pmovmskb128((__v16qi)__a); @@ -1337,85 +1337,85 @@ _mm_movemask_epi8(__m128i __a) 4 + (((imm) & 0x30) >> 4), \ 4 + (((imm) & 0xc0) >> 6)); }) -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_movepi64_pi64(__m128i __a) { return (__m64)__a[0]; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_movpi64_epi64(__m64 __a) { return (__m128i){ (long long)__a, 0 }; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_move_epi64(__m128i __a) { return __builtin_shufflevector(__a, (__m128i){ 0 }, 0, 2); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_unpackhi_pd(__m128d __a, __m128d __b) { return __builtin_shufflevector(__a, __b, 1, 2+1); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_unpacklo_pd(__m128d __a, __m128d __b) { return __builtin_shufflevector(__a, __b, 0, 2+0); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_movemask_pd(__m128d __a) { return __builtin_ia32_movmskpd(__a); @@ -1425,49 +1425,49 @@ _mm_movemask_pd(__m128d __a) __builtin_shufflevector((__m128d)(a), (__m128d)(b), \ (i) & 1, (((i) & 2) >> 1) + 2); }) -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_castpd_ps(__m128d __a) { return (__m128)__a; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_castpd_si128(__m128d __a) { return (__m128i)__a; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_castps_pd(__m128 __a) { return (__m128d)__a; } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_castps_si128(__m128 __a) { return (__m128i)__a; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_castsi128_ps(__m128i __a) { return (__m128)__a; } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_castsi128_pd(__m128i __a) { return (__m128d)__a; } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_pause(void) { __asm__ volatile ("pause"); } -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #define _MM_SHUFFLE2(x, y) (((x) << 1) | (y)) diff --git a/lib/Headers/f16cintrin.h b/lib/Headers/f16cintrin.h index c56960cf7b08..9349b78fe84c 100644 --- a/lib/Headers/f16cintrin.h +++ b/lib/Headers/f16cintrin.h @@ -32,7 +32,7 @@ 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 __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("f16c"))) #define _mm_cvtps_ph(a, imm) __extension__ ({ \ __m128 __a = (a); \ @@ -42,18 +42,18 @@ typedef float __m256 __attribute__ ((__vector_size__ (32))); __m256 __a = (a); \ (__m128i)__builtin_ia32_vcvtps2ph256((__v8sf)__a, (imm)); }) -static __inline __m128 DEFAULT_FN_ATTRS +static __inline __m128 __DEFAULT_FN_ATTRS _mm_cvtph_ps(__m128i __a) { return (__m128)__builtin_ia32_vcvtph2ps((__v8hi)__a); } -static __inline __m256 DEFAULT_FN_ATTRS +static __inline __m256 __DEFAULT_FN_ATTRS _mm256_cvtph_ps(__m128i __a) { return (__m256)__builtin_ia32_vcvtph2ps256((__v8hi)__a); } -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __F16CINTRIN_H */ diff --git a/lib/Headers/fma4intrin.h b/lib/Headers/fma4intrin.h index 5268805605cc..f1178877b252 100644 --- a/lib/Headers/fma4intrin.h +++ b/lib/Headers/fma4intrin.h @@ -31,200 +31,200 @@ #include <pmmintrin.h> /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("fma4"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("fma4"))) -static __inline__ __m128 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256d __DEFAULT_FN_ATTRS _mm256_msubadd_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfmsubaddpd256(__A, __B, __C); } -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __FMA4INTRIN_H */ diff --git a/lib/Headers/fmaintrin.h b/lib/Headers/fmaintrin.h index 6f5d1b907a38..114a14380ea0 100644 --- a/lib/Headers/fmaintrin.h +++ b/lib/Headers/fmaintrin.h @@ -29,200 +29,200 @@ #define __FMAINTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("fma"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("fma"))) -static __inline__ __m128 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m256d __DEFAULT_FN_ATTRS _mm256_fmsubadd_pd(__m256d __A, __m256d __B, __m256d __C) { return (__m256d)__builtin_ia32_vfmsubaddpd256(__A, __B, __C); } -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __FMAINTRIN_H */ diff --git a/lib/Headers/fxsrintrin.h b/lib/Headers/fxsrintrin.h new file mode 100644 index 000000000000..2b3549c057a1 --- /dev/null +++ b/lib/Headers/fxsrintrin.h @@ -0,0 +1,55 @@ +/*===---- fxsrintrin.h - FXSR 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 <fxsrintrin.h> directly; include <immintrin.h> instead." +#endif + +#ifndef __FXSRINTRIN_H +#define __FXSRINTRIN_H + +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__)) + +static __inline__ void __DEFAULT_FN_ATTRS +_fxsave(void *__p) { + return __builtin_ia32_fxsave(__p); +} + +static __inline__ void __DEFAULT_FN_ATTRS +_fxsave64(void *__p) { + return __builtin_ia32_fxsave64(__p); +} + +static __inline__ void __DEFAULT_FN_ATTRS +_fxrstor(void *__p) { + return __builtin_ia32_fxrstor(__p); +} + +static __inline__ void __DEFAULT_FN_ATTRS +_fxrstor64(void *__p) { + return __builtin_ia32_fxrstor64(__p); +} + +#undef __DEFAULT_FN_ATTRS + +#endif diff --git a/lib/Headers/immintrin.h b/lib/Headers/immintrin.h index 4af407dfc7e8..604bc8ca5b39 100644 --- a/lib/Headers/immintrin.h +++ b/lib/Headers/immintrin.h @@ -56,6 +56,8 @@ #include <avx512bwintrin.h> +#include <avx512cdintrin.h> + #include <avx512dqintrin.h> #include <avx512vlbwintrin.h> @@ -140,6 +142,8 @@ _writegsbase_u64(unsigned long long __V) #include <shaintrin.h> +#include <fxsrintrin.h> + /* Some intrinsics inside adxintrin.h are available only on processors with ADX, * whereas others are also available at all times. */ #include <adxintrin.h> diff --git a/lib/Headers/inttypes.h b/lib/Headers/inttypes.h new file mode 100644 index 000000000000..3d59d141deb2 --- /dev/null +++ b/lib/Headers/inttypes.h @@ -0,0 +1,102 @@ +/*===---- inttypes.h - Standard header for integer printf macros ----------===*\ + * + * 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 __CLANG_INTTYPES_H +#define __CLANG_INTTYPES_H + +#include_next <inttypes.h> + +#if defined(_MSC_VER) && _MSC_VER < 1900 +/* MSVC headers define int32_t as int, but PRIx32 as "lx" instead of "x". + * This triggers format warnings, so fix it up here. */ +#undef PRId32 +#undef PRIdLEAST32 +#undef PRIdFAST32 +#undef PRIi32 +#undef PRIiLEAST32 +#undef PRIiFAST32 +#undef PRIo32 +#undef PRIoLEAST32 +#undef PRIoFAST32 +#undef PRIu32 +#undef PRIuLEAST32 +#undef PRIuFAST32 +#undef PRIx32 +#undef PRIxLEAST32 +#undef PRIxFAST32 +#undef PRIX32 +#undef PRIXLEAST32 +#undef PRIXFAST32 + +#undef SCNd32 +#undef SCNdLEAST32 +#undef SCNdFAST32 +#undef SCNi32 +#undef SCNiLEAST32 +#undef SCNiFAST32 +#undef SCNo32 +#undef SCNoLEAST32 +#undef SCNoFAST32 +#undef SCNu32 +#undef SCNuLEAST32 +#undef SCNuFAST32 +#undef SCNx32 +#undef SCNxLEAST32 +#undef SCNxFAST32 + +#define PRId32 "d" +#define PRIdLEAST32 "d" +#define PRIdFAST32 "d" +#define PRIi32 "i" +#define PRIiLEAST32 "i" +#define PRIiFAST32 "i" +#define PRIo32 "o" +#define PRIoLEAST32 "o" +#define PRIoFAST32 "o" +#define PRIu32 "u" +#define PRIuLEAST32 "u" +#define PRIuFAST32 "u" +#define PRIx32 "x" +#define PRIxLEAST32 "x" +#define PRIxFAST32 "x" +#define PRIX32 "X" +#define PRIXLEAST32 "X" +#define PRIXFAST32 "X" + +#define SCNd32 "d" +#define SCNdLEAST32 "d" +#define SCNdFAST32 "d" +#define SCNi32 "i" +#define SCNiLEAST32 "i" +#define SCNiFAST32 "i" +#define SCNo32 "o" +#define SCNoLEAST32 "o" +#define SCNoFAST32 "o" +#define SCNu32 "u" +#define SCNuLEAST32 "u" +#define SCNuFAST32 "u" +#define SCNx32 "x" +#define SCNxLEAST32 "x" +#define SCNxFAST32 "x" +#endif + +#endif /* __CLANG_INTTYPES_H */ diff --git a/lib/Headers/lzcntintrin.h b/lib/Headers/lzcntintrin.h index 41e61e9fdefa..4c00e42ac3a9 100644 --- a/lib/Headers/lzcntintrin.h +++ b/lib/Headers/lzcntintrin.h @@ -29,40 +29,40 @@ #define __LZCNTINTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("lzcnt"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("lzcnt"))) -static __inline__ unsigned short DEFAULT_FN_ATTRS +static __inline__ unsigned short __DEFAULT_FN_ATTRS __lzcnt16(unsigned short __X) { return __X ? __builtin_clzs(__X) : 16; } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __lzcnt32(unsigned int __X) { return __X ? __builtin_clz(__X) : 32; } -static __inline__ unsigned int DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __lzcnt64(unsigned long long __X) { return __X ? __builtin_clzll(__X) : 64; } -static __inline__ unsigned long long DEFAULT_FN_ATTRS +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 +#undef __DEFAULT_FN_ATTRS #endif /* __LZCNTINTRIN_H */ diff --git a/lib/Headers/mm3dnow.h b/lib/Headers/mm3dnow.h index 70734e49682e..3218df827177 100644 --- a/lib/Headers/mm3dnow.h +++ b/lib/Headers/mm3dnow.h @@ -30,138 +30,138 @@ typedef float __v2sf __attribute__((__vector_size__(8))); /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("3dnow"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("3dnow"))) -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _m_femms() { __builtin_ia32_femms(); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pavgusb(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pavgusb((__v8qi)__m1, (__v8qi)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pf2id(__m64 __m) { return (__m64)__builtin_ia32_pf2id((__v2sf)__m); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfacc(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfacc((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfadd(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfadd((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfcmpeq(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfcmpeq((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfcmpge(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfcmpge((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfcmpgt(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfcmpgt((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfmax(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfmax((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfmin(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfmin((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfmul(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfmul((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfrcp(__m64 __m) { return (__m64)__builtin_ia32_pfrcp((__v2sf)__m); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfrcpit1(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfrcpit1((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfrcpit2(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfrcpit2((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfrsqrt(__m64 __m) { return (__m64)__builtin_ia32_pfrsqrt((__v2sf)__m); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfrsqrtit1(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfrsqit1((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfsub(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfsub((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfsubr(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfsubr((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pi2fd(__m64 __m) { return (__m64)__builtin_ia32_pi2fd((__v2si)__m); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pmulhrw(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pmulhrw((__v4hi)__m1, (__v4hi)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pf2iw(__m64 __m) { return (__m64)__builtin_ia32_pf2iw((__v2sf)__m); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfnacc(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfnacc((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pfpnacc(__m64 __m1, __m64 __m2) { return (__m64)__builtin_ia32_pfpnacc((__v2sf)__m1, (__v2sf)__m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pi2fw(__m64 __m) { return (__m64)__builtin_ia32_pi2fw((__v2si)__m); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pswapdsf(__m64 __m) { return (__m64)__builtin_ia32_pswapdsf((__v2sf)__m); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _m_pswapdsi(__m64 __m) { return (__m64)__builtin_ia32_pswapdsi((__v2si)__m); } -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif diff --git a/lib/Headers/mmintrin.h b/lib/Headers/mmintrin.h index d1d729f26a38..484b499dd7fc 100644 --- a/lib/Headers/mmintrin.h +++ b/lib/Headers/mmintrin.h @@ -31,369 +31,369 @@ typedef short __v4hi __attribute__((__vector_size__(8))); typedef char __v8qi __attribute__((__vector_size__(8))); /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("mmx"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("mmx"))) -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_empty(void) { __builtin_ia32_emms(); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_cvtsi32_si64(int __i) { return (__m64)__builtin_ia32_vec_init_v2si(__i, 0); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_cvtsi64_si32(__m64 __m) { return __builtin_ia32_vec_ext_v2si((__v2si)__m, 0); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_cvtsi64_m64(long long __i) { return (__m64)__i; } -static __inline__ long long DEFAULT_FN_ATTRS +static __inline__ long long __DEFAULT_FN_ATTRS _mm_cvtm64_si64(__m64 __m) { return (long long)__m; } -static __inline__ __m64 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_sll_pi16(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psllw((__v4hi)__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_slli_pi16(__m64 __m, int __count) { return (__m64)__builtin_ia32_psllwi((__v4hi)__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_sll_pi32(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_pslld((__v2si)__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_slli_pi32(__m64 __m, int __count) { return (__m64)__builtin_ia32_pslldi((__v2si)__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_sll_si64(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psllq(__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_slli_si64(__m64 __m, int __count) { return (__m64)__builtin_ia32_psllqi(__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_sra_pi16(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psraw((__v4hi)__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_srai_pi16(__m64 __m, int __count) { return (__m64)__builtin_ia32_psrawi((__v4hi)__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_sra_pi32(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psrad((__v2si)__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_srai_pi32(__m64 __m, int __count) { return (__m64)__builtin_ia32_psradi((__v2si)__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_srl_pi16(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psrlw((__v4hi)__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_srli_pi16(__m64 __m, int __count) { return (__m64)__builtin_ia32_psrlwi((__v4hi)__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_srl_pi32(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psrld((__v2si)__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_srli_pi32(__m64 __m, int __count) { return (__m64)__builtin_ia32_psrldi((__v2si)__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_srl_si64(__m64 __m, __m64 __count) { return (__m64)__builtin_ia32_psrlq(__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_srli_si64(__m64 __m, int __count) { return (__m64)__builtin_ia32_psrlqi(__m, __count); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_and_si64(__m64 __m1, __m64 __m2) { return __builtin_ia32_pand(__m1, __m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_andnot_si64(__m64 __m1, __m64 __m2) { return __builtin_ia32_pandn(__m1, __m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_or_si64(__m64 __m1, __m64 __m2) { return __builtin_ia32_por(__m1, __m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_xor_si64(__m64 __m1, __m64 __m2) { return __builtin_ia32_pxor(__m1, __m2); } -static __inline__ __m64 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_setzero_si64(void) { return (__m64){ 0LL }; } -static __inline__ __m64 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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) { @@ -401,44 +401,44 @@ _mm_set_pi8(char __b7, char __b6, char __b5, char __b4, char __b3, char __b2, __b4, __b5, __b6, __b7); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_set1_pi32(int __i) { return _mm_set_pi32(__i, __i); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_set1_pi16(short __w) { return _mm_set_pi16(__w, __w, __w, __w); } -static __inline__ __m64 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_setr_pi32(int __i0, int __i1) { return _mm_set_pi32(__i1, __i0); } -static __inline__ __m64 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 +#undef __DEFAULT_FN_ATTRS /* Aliases for compatibility. */ #define _m_empty _mm_empty diff --git a/lib/Headers/module.modulemap b/lib/Headers/module.modulemap index 8fcb5bc1b3d2..0fc70a8c9b06 100644 --- a/lib/Headers/module.modulemap +++ b/lib/Headers/module.modulemap @@ -32,142 +32,117 @@ module _Builtin_intrinsics [system] [extern_c] { } explicit module cpuid { - requires x86 header "cpuid.h" } explicit module mmx { - requires mmx header "mmintrin.h" } explicit module f16c { - requires f16c header "f16cintrin.h" } explicit module sse { - requires sse export mmx export sse2 // note: for hackish <emmintrin.h> dependency header "xmmintrin.h" } explicit module sse2 { - requires sse2 export sse header "emmintrin.h" } explicit module sse3 { - requires sse3 export sse2 header "pmmintrin.h" } explicit module ssse3 { - requires ssse3 export sse3 header "tmmintrin.h" } explicit module sse4_1 { - requires sse41 export ssse3 header "smmintrin.h" } explicit module sse4_2 { - requires sse42 export sse4_1 header "nmmintrin.h" } explicit module sse4a { - requires sse4a export sse3 header "ammintrin.h" } explicit module avx { - requires avx export sse4_2 header "avxintrin.h" } explicit module avx2 { - requires avx2 export avx header "avx2intrin.h" } explicit module avx512f { - requires avx512f export avx2 header "avx512fintrin.h" } explicit module avx512er { - requires avx512er header "avx512erintrin.h" } explicit module bmi { - requires bmi header "bmiintrin.h" } explicit module bmi2 { - requires bmi2 header "bmi2intrin.h" } explicit module fma { - requires fma header "fmaintrin.h" } explicit module fma4 { - requires fma4 export sse3 header "fma4intrin.h" } explicit module lzcnt { - requires lzcnt header "lzcntintrin.h" } explicit module popcnt { - requires popcnt header "popcntintrin.h" } explicit module mm3dnow { - requires mm3dnow header "mm3dnow.h" } explicit module xop { - requires xop export fma4 header "xopintrin.h" } explicit module aes_pclmul { - requires aes, pclmul header "wmmintrin.h" export aes export pclmul } explicit module aes { - requires aes header "__wmmintrin_aes.h" } explicit module pclmul { - requires pclmul header "__wmmintrin_pclmul.h" } } diff --git a/lib/Headers/pmmintrin.h b/lib/Headers/pmmintrin.h index 6e61539fb2ca..e888b6fb7067 100644 --- a/lib/Headers/pmmintrin.h +++ b/lib/Headers/pmmintrin.h @@ -27,57 +27,57 @@ #include <emmintrin.h> /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse3"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse3"))) -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_lddqu_si128(__m128i const *__p) { return (__m128i)__builtin_ia32_lddqu((char const *)__p); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_addsub_ps(__m128 __a, __m128 __b) { return __builtin_ia32_addsubps(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_hadd_ps(__m128 __a, __m128 __b) { return __builtin_ia32_haddps(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_hsub_ps(__m128 __a, __m128 __b) { return __builtin_ia32_hsubps(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_movehdup_ps(__m128 __a) { return __builtin_shufflevector(__a, __a, 1, 1, 3, 3); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_moveldup_ps(__m128 __a) { return __builtin_shufflevector(__a, __a, 0, 0, 2, 2); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_addsub_pd(__m128d __a, __m128d __b) { return __builtin_ia32_addsubpd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_hadd_pd(__m128d __a, __m128d __b) { return __builtin_ia32_haddpd(__a, __b); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_hsub_pd(__m128d __a, __m128d __b) { return __builtin_ia32_hsubpd(__a, __b); @@ -85,7 +85,7 @@ _mm_hsub_pd(__m128d __a, __m128d __b) #define _mm_loaddup_pd(dp) _mm_load1_pd(dp) -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_movedup_pd(__m128d __a) { return __builtin_shufflevector(__a, __a, 0, 0); @@ -99,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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_mwait(unsigned __extensions, unsigned __hints) { __builtin_ia32_mwait(__extensions, __hints); } -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __PMMINTRIN_H */ diff --git a/lib/Headers/popcntintrin.h b/lib/Headers/popcntintrin.h index fede8da2bdf5..29c074b61d1c 100644 --- a/lib/Headers/popcntintrin.h +++ b/lib/Headers/popcntintrin.h @@ -25,22 +25,22 @@ #define _POPCNTINTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("popcnt"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("popcnt"))) -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_popcnt_u32(unsigned int __A) { return __builtin_popcount(__A); } #ifdef __x86_64__ -static __inline__ long long DEFAULT_FN_ATTRS +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 +#undef __DEFAULT_FN_ATTRS #endif /* _POPCNTINTRIN_H */ diff --git a/lib/Headers/rdseedintrin.h b/lib/Headers/rdseedintrin.h index ac9ec4f9ba92..421f4ea48702 100644 --- a/lib/Headers/rdseedintrin.h +++ b/lib/Headers/rdseedintrin.h @@ -29,28 +29,28 @@ #define __RDSEEDINTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("rdseed"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("rdseed"))) -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _rdseed16_step(unsigned short *__p) { return __builtin_ia32_rdseed16_step(__p); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _rdseed32_step(unsigned int *__p) { return __builtin_ia32_rdseed32_step(__p); } #ifdef __x86_64__ -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _rdseed64_step(unsigned long long *__p) { return __builtin_ia32_rdseed64_step(__p); } #endif -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __RDSEEDINTRIN_H */ diff --git a/lib/Headers/rtmintrin.h b/lib/Headers/rtmintrin.h index 8709a125a7be..e6a58d743bc9 100644 --- a/lib/Headers/rtmintrin.h +++ b/lib/Headers/rtmintrin.h @@ -38,15 +38,15 @@ #define _XABORT_CODE(x) (((x) >> 24) & 0xFF) /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("rtm"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("rtm"))) -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS _xbegin(void) { return __builtin_ia32_xbegin(); } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _xend(void) { __builtin_ia32_xend(); @@ -54,6 +54,6 @@ _xend(void) #define _xabort(imm) __builtin_ia32_xabort((imm)) -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __RTMINTRIN_H */ diff --git a/lib/Headers/shaintrin.h b/lib/Headers/shaintrin.h index 4b7429162783..8602d0249d48 100644 --- a/lib/Headers/shaintrin.h +++ b/lib/Headers/shaintrin.h @@ -29,47 +29,47 @@ #define __SHAINTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sha"))) +#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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 +#undef __DEFAULT_FN_ATTRS #endif /* __SHAINTRIN_H */ diff --git a/lib/Headers/smmintrin.h b/lib/Headers/smmintrin.h index f2cc909fe773..e197590a38e2 100644 --- a/lib/Headers/smmintrin.h +++ b/lib/Headers/smmintrin.h @@ -27,7 +27,7 @@ #include <tmmintrin.h> /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse4.1"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse4.1"))) /* SSE4 Rounding macros. */ #define _MM_FROUND_TO_NEAREST_INT 0x00 @@ -91,21 +91,21 @@ (((M) & 0x04) ? 6 : 2), \ (((M) & 0x08) ? 7 : 3)); }) -static __inline__ __m128d DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_blendv_epi8 (__m128i __V1, __m128i __V2, __m128i __M) { return (__m128i) __builtin_ia32_pblendvb128 ((__v16qi)__V1, (__v16qi)__V2, @@ -126,13 +126,13 @@ _mm_blendv_epi8 (__m128i __V1, __m128i __V2, __m128i __M) (((M) & 0x80) ? 15 : 7)); }) /* SSE4 Dword Multiply Instructions. */ -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mullo_epi32 (__m128i __V1, __m128i __V2) { return (__m128i) ((__v4si)__V1 * (__v4si)__V2); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mul_epi32 (__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_pmuldq128 ((__v4si)__V1, (__v4si)__V2); @@ -150,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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epu32 (__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_pmaxud128((__v4si) __V1, (__v4si) __V2); @@ -253,19 +253,19 @@ _mm_max_epu32 (__m128i __V1, __m128i __V2) #endif /* __x86_64 */ /* SSE4 128-bit Packed Integer Comparisons. */ -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_testz_si128(__m128i __M, __m128i __V) { return __builtin_ia32_ptestz128((__v2di)__M, (__v2di)__V); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_testc_si128(__m128i __M, __m128i __V) { return __builtin_ia32_ptestc128((__v2di)__M, (__v2di)__V); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_testnzc_si128(__m128i __M, __m128i __V) { return __builtin_ia32_ptestnzc128((__v2di)__M, (__v2di)__V); @@ -276,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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi16(__m128i __V) { return (__m128i) __builtin_ia32_pmovsxbw128((__v16qi) __V); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi32(__m128i __V) { return (__m128i) __builtin_ia32_pmovsxbd128((__v16qi) __V); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi64(__m128i __V) { return (__m128i) __builtin_ia32_pmovsxbq128((__v16qi) __V); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi16_epi32(__m128i __V) { return (__m128i) __builtin_ia32_pmovsxwd128((__v8hi) __V); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi16_epi64(__m128i __V) { return (__m128i) __builtin_ia32_pmovsxwq128((__v8hi)__V); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi16(__m128i __V) { return (__m128i) __builtin_ia32_pmovzxbw128((__v16qi) __V); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi32(__m128i __V) { return (__m128i) __builtin_ia32_pmovzxbd128((__v16qi)__V); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi64(__m128i __V) { return (__m128i) __builtin_ia32_pmovzxbq128((__v16qi)__V); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu16_epi32(__m128i __V) { return (__m128i) __builtin_ia32_pmovzxwd128((__v8hi)__V); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu16_epi64(__m128i __V) { return (__m128i) __builtin_ia32_pmovzxwq128((__v8hi)__V); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packus_epi32(__m128i __V1, __m128i __V2) { return (__m128i) __builtin_ia32_packusdw128((__v4si)__V1, (__v4si)__V2); @@ -369,7 +369,7 @@ _mm_packus_epi32(__m128i __V1, __m128i __V2) __m128i __Y = (Y); \ (__m128i) __builtin_ia32_mpsadbw128((__v16qi)__X, (__v16qi)__Y, (M)); }) -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_minpos_epu16(__m128i __V) { return (__m128i) __builtin_ia32_phminposuw128((__v8hi)__V); @@ -380,8 +380,8 @@ _mm_minpos_epu16(__m128i __V) /* These definitions are normally in nmmintrin.h, but gcc puts them in here so we'll do the same. */ -#undef DEFAULT_FN_ATTRS -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("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 @@ -442,40 +442,40 @@ _mm_minpos_epu16(__m128i __V) __builtin_ia32_pcmpestriz128((A), (LA), (B), (LB), (M)) /* SSE4.2 Compare Packed Data -- Greater Than. */ -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 +#undef __DEFAULT_FN_ATTRS #ifdef __POPCNT__ #include <popcntintrin.h> diff --git a/lib/Headers/tbmintrin.h b/lib/Headers/tbmintrin.h index 1926df9f033c..62f613f9ee5c 100644 --- a/lib/Headers/tbmintrin.h +++ b/lib/Headers/tbmintrin.h @@ -29,59 +29,59 @@ #define __TBMINTRIN_H /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("tbm"))) +#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 DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __blcfill_u32(unsigned int a) { return a & (a + 1); } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __blci_u32(unsigned int a) { return a | ~(a + 1); } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __blcic_u32(unsigned int a) { return ~a & (a + 1); } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __blcmsk_u32(unsigned int a) { return a ^ (a + 1); } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __blcs_u32(unsigned int a) { return a | (a + 1); } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __blsfill_u32(unsigned int a) { return a | (a - 1); } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __blsic_u32(unsigned int a) { return ~a | (a - 1); } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __t1mskc_u32(unsigned int a) { return ~a | (a + 1); } -static __inline__ unsigned int DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS __tzmsk_u32(unsigned int a) { return ~a & (a - 1); @@ -90,61 +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 DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blcfill_u64(unsigned long long a) { return a & (a + 1); } -static __inline__ unsigned long long DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blci_u64(unsigned long long a) { return a | ~(a + 1); } -static __inline__ unsigned long long DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blcic_u64(unsigned long long a) { return ~a & (a + 1); } -static __inline__ unsigned long long DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blcmsk_u64(unsigned long long a) { return a ^ (a + 1); } -static __inline__ unsigned long long DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blcs_u64(unsigned long long a) { return a | (a + 1); } -static __inline__ unsigned long long DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blsfill_u64(unsigned long long a) { return a | (a - 1); } -static __inline__ unsigned long long DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __blsic_u64(unsigned long long a) { return ~a | (a - 1); } -static __inline__ unsigned long long DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __t1mskc_u64(unsigned long long a) { return ~a | (a + 1); } -static __inline__ unsigned long long DEFAULT_FN_ATTRS +static __inline__ unsigned long long __DEFAULT_FN_ATTRS __tzmsk_u64(unsigned long long a) { return ~a & (a - 1); } #endif -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __TBMINTRIN_H */ diff --git a/lib/Headers/tmmintrin.h b/lib/Headers/tmmintrin.h index 2474c9414fd3..120d73c34f57 100644 --- a/lib/Headers/tmmintrin.h +++ b/lib/Headers/tmmintrin.h @@ -27,39 +27,39 @@ #include <pmmintrin.h> /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("ssse3"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("ssse3"))) -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_abs_pi8(__m64 __a) { return (__m64)__builtin_ia32_pabsb((__v8qi)__a); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_abs_epi8(__m128i __a) { return (__m128i)__builtin_ia32_pabsb128((__v16qi)__a); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_abs_pi16(__m64 __a) { return (__m64)__builtin_ia32_pabsw((__v4hi)__a); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_abs_epi16(__m128i __a) { return (__m128i)__builtin_ia32_pabsw128((__v8hi)__a); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_abs_pi32(__m64 __a) { return (__m64)__builtin_ia32_pabsd((__v2si)__a); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_abs_epi32(__m128i __a) { return (__m128i)__builtin_ia32_pabsd128((__v4si)__a); @@ -75,150 +75,150 @@ _mm_abs_epi32(__m128i __a) __m64 __b = (b); \ (__m64)__builtin_ia32_palignr((__v8qi)__a, (__v8qi)__b, (n)); }) -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_sign_pi32(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_psignd((__v2si)__a, (__v2si)__b); } -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __TMMINTRIN_H */ diff --git a/lib/Headers/xmmintrin.h b/lib/Headers/xmmintrin.h index 0085eb4237c1..18aa8c1426a3 100644 --- a/lib/Headers/xmmintrin.h +++ b/lib/Headers/xmmintrin.h @@ -37,184 +37,184 @@ typedef float __m128 __attribute__((__vector_size__(16))); #endif /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse"))) -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_add_ss(__m128 __a, __m128 __b) { __a[0] += __b[0]; return __a; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_add_ps(__m128 __a, __m128 __b) { return __a + __b; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_sub_ss(__m128 __a, __m128 __b) { __a[0] -= __b[0]; return __a; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_sub_ps(__m128 __a, __m128 __b) { return __a - __b; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_mul_ss(__m128 __a, __m128 __b) { __a[0] *= __b[0]; return __a; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_mul_ps(__m128 __a, __m128 __b) { return __a * __b; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_div_ss(__m128 __a, __m128 __b) { __a[0] /= __b[0]; return __a; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_div_ps(__m128 __a, __m128 __b) { return __a / __b; } -static __inline__ __m128 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_sqrt_ps(__m128 __a) { return __builtin_ia32_sqrtps(__a); } -static __inline__ __m128 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_rcp_ps(__m128 __a) { return __builtin_ia32_rcpps(__a); } -static __inline__ __m128 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_rsqrt_ps(__m128 __a) { return __builtin_ia32_rsqrtps(__a); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_min_ss(__m128 __a, __m128 __b) { return __builtin_ia32_minss(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_min_ps(__m128 __a, __m128 __b) { return __builtin_ia32_minps(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_max_ss(__m128 __a, __m128 __b) { return __builtin_ia32_maxss(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_max_ps(__m128 __a, __m128 __b) { return __builtin_ia32_maxps(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_and_ps(__m128 __a, __m128 __b) { return (__m128)((__v4si)__a & (__v4si)__b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_andnot_ps(__m128 __a, __m128 __b) { return (__m128)(~(__v4si)__a & (__v4si)__b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_or_ps(__m128 __a, __m128 __b) { return (__m128)((__v4si)__a | (__v4si)__b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_xor_ps(__m128 __a, __m128 __b) { return (__m128)((__v4si)__a ^ (__v4si)__b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpeq_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpeqss(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpeq_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpeqps(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmplt_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpltss(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmplt_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpltps(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmple_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpless(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmple_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpleps(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpgt_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_shufflevector(__a, @@ -222,13 +222,13 @@ _mm_cmpgt_ss(__m128 __a, __m128 __b) 4, 1, 2, 3); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpgt_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpltps(__b, __a); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpge_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_shufflevector(__a, @@ -236,49 +236,49 @@ _mm_cmpge_ss(__m128 __a, __m128 __b) 4, 1, 2, 3); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpge_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpleps(__b, __a); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpneq_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpneqss(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpneq_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpneqps(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpnlt_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpnltss(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpnlt_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpnltps(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpnle_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpnless(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpnle_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpnleps(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpngt_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_shufflevector(__a, @@ -286,13 +286,13 @@ _mm_cmpngt_ss(__m128 __a, __m128 __b) 4, 1, 2, 3); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpngt_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpnltps(__b, __a); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpnge_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_shufflevector(__a, @@ -300,115 +300,115 @@ _mm_cmpnge_ss(__m128 __a, __m128 __b) 4, 1, 2, 3); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpnge_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpnleps(__b, __a); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpord_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpordss(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpord_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpordps(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpunord_ss(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpunordss(__a, __b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpunord_ps(__m128 __a, __m128 __b) { return (__m128)__builtin_ia32_cmpunordps(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_comieq_ss(__m128 __a, __m128 __b) { return __builtin_ia32_comieq(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_comilt_ss(__m128 __a, __m128 __b) { return __builtin_ia32_comilt(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_comile_ss(__m128 __a, __m128 __b) { return __builtin_ia32_comile(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_comigt_ss(__m128 __a, __m128 __b) { return __builtin_ia32_comigt(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_comige_ss(__m128 __a, __m128 __b) { return __builtin_ia32_comige(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_comineq_ss(__m128 __a, __m128 __b) { return __builtin_ia32_comineq(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomieq_ss(__m128 __a, __m128 __b) { return __builtin_ia32_ucomieq(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomilt_ss(__m128 __a, __m128 __b) { return __builtin_ia32_ucomilt(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomile_ss(__m128 __a, __m128 __b) { return __builtin_ia32_ucomile(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomigt_ss(__m128 __a, __m128 __b) { return __builtin_ia32_ucomigt(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomige_ss(__m128 __a, __m128 __b) { return __builtin_ia32_ucomige(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomineq_ss(__m128 __a, __m128 __b) { return __builtin_ia32_ucomineq(__a, __b); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_cvtss_si32(__m128 __a) { return __builtin_ia32_cvtss2si(__a); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_cvt_ss2si(__m128 __a) { return _mm_cvtss_si32(__a); @@ -416,7 +416,7 @@ _mm_cvt_ss2si(__m128 __a) #ifdef __x86_64__ -static __inline__ long long DEFAULT_FN_ATTRS +static __inline__ long long __DEFAULT_FN_ATTRS _mm_cvtss_si64(__m128 __a) { return __builtin_ia32_cvtss2si64(__a); @@ -424,56 +424,56 @@ _mm_cvtss_si64(__m128 __a) #endif -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_cvtps_pi32(__m128 __a) { return (__m64)__builtin_ia32_cvtps2pi(__a); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_cvt_ps2pi(__m128 __a) { return _mm_cvtps_pi32(__a); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_cvttss_si32(__m128 __a) { return __a[0]; } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_cvtt_ss2si(__m128 __a) { return _mm_cvttss_si32(__a); } -static __inline__ long long DEFAULT_FN_ATTRS +static __inline__ long long __DEFAULT_FN_ATTRS _mm_cvttss_si64(__m128 __a) { return __a[0]; } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_cvttps_pi32(__m128 __a) { return (__m64)__builtin_ia32_cvttps2pi(__a); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_cvtt_ps2pi(__m128 __a) { return _mm_cvttps_pi32(__a); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtsi32_ss(__m128 __a, int __b) { __a[0] = __b; return __a; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvt_si2ss(__m128 __a, int __b) { return _mm_cvtsi32_ss(__a, __b); @@ -481,7 +481,7 @@ _mm_cvt_si2ss(__m128 __a, int __b) #ifdef __x86_64__ -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtsi64_ss(__m128 __a, long long __b) { __a[0] = __b; @@ -490,25 +490,25 @@ _mm_cvtsi64_ss(__m128 __a, long long __b) #endif -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtpi32_ps(__m128 __a, __m64 __b) { return __builtin_ia32_cvtpi2ps(__a, (__v2si)__b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvt_pi2ps(__m128 __a, __m64 __b) { return _mm_cvtpi32_ps(__a, __b); } -static __inline__ float DEFAULT_FN_ATTRS +static __inline__ float __DEFAULT_FN_ATTRS _mm_cvtss_f32(__m128 __a) { return __a[0]; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_loadh_pi(__m128 __a, const __m64 *__p) { typedef float __mm_loadh_pi_v2f32 __attribute__((__vector_size__(8))); @@ -520,7 +520,7 @@ _mm_loadh_pi(__m128 __a, const __m64 *__p) return __builtin_shufflevector(__a, __bb, 0, 1, 4, 5); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_loadl_pi(__m128 __a, const __m64 *__p) { typedef float __mm_loadl_pi_v2f32 __attribute__((__vector_size__(8))); @@ -532,7 +532,7 @@ _mm_loadl_pi(__m128 __a, const __m64 *__p) return __builtin_shufflevector(__a, __bb, 4, 5, 2, 3); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_load_ss(const float *__p) { struct __mm_load_ss_struct { @@ -542,7 +542,7 @@ _mm_load_ss(const float *__p) return (__m128){ __u, 0, 0, 0 }; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_load1_ps(const float *__p) { struct __mm_load1_ps_struct { @@ -554,13 +554,13 @@ _mm_load1_ps(const float *__p) #define _mm_load_ps1(p) _mm_load1_ps(p) -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_load_ps(const float *__p) { return *(__m128*)__p; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_loadu_ps(const float *__p) { struct __loadu_ps { @@ -569,63 +569,63 @@ _mm_loadu_ps(const float *__p) return ((struct __loadu_ps*)__p)->__v; } -static __inline__ __m128 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_set_ss(float __w) { return (__m128){ __w, 0, 0, 0 }; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_set1_ps(float __w) { return (__m128){ __w, __w, __w, __w }; } /* Microsoft specific. */ -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_set_ps1(float __w) { return _mm_set1_ps(__w); } -static __inline__ __m128 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_setzero_ps(void) { return (__m128){ 0, 0, 0, 0 }; } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_storeh_pi(__m64 *__p, __m128 __a) { __builtin_ia32_storehps((__v2si *)__p, __a); } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_storel_pi(__m64 *__p, __m128 __a) { __builtin_ia32_storelps((__v2si *)__p, __a); } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_store_ss(float *__p, __m128 __a) { struct __mm_store_ss_struct { @@ -634,32 +634,32 @@ _mm_store_ss(float *__p, __m128 __a) ((struct __mm_store_ss_struct*)__p)->__u = __a[0]; } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_storeu_ps(float *__p, __m128 __a) { __builtin_ia32_storeups(__p, __a); } -static __inline__ void DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_store_ps1(float *__p, __m128 __a) { return _mm_store1_ps(__p, __a); } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_store_ps(float *__p, __m128 __a) { *(__m128 *)__p = __a; } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_storer_ps(float *__p, __m128 __a) { __a = __builtin_shufflevector(__a, __a, 3, 2, 1, 0); @@ -678,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 DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_stream_pi(__m64 *__p, __m64 __a) { __builtin_ia32_movntq(__p, __a); } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_stream_ps(float *__p, __m128 __a) { __builtin_ia32_movntps(__p, __a); } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_sfence(void) { __builtin_ia32_sfence(); } -static __inline__ int DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_insert_pi16(__m64 __a, int __d, int __n) { __v4hi __b = (__v4hi)__a; @@ -711,37 +711,37 @@ _mm_insert_pi16(__m64 __a, int __d, int __n) return (__m64)__b; } -static __inline__ __m64 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_movemask_pi8(__m64 __a) { return __builtin_ia32_pmovmskb((__v8qi)__a); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_mulhi_pu16(__m64 __a, __m64 __b) { return (__m64)__builtin_ia32_pmulhuw((__v4hi)__a, (__v4hi)__b); @@ -751,37 +751,37 @@ _mm_mulhi_pu16(__m64 __a, __m64 __b) __m64 __a = (a); \ (__m64)__builtin_ia32_pshufw((__v4hi)__a, (n)); }) -static __inline__ void DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ unsigned int __DEFAULT_FN_ATTRS _mm_getcsr(void) { return __builtin_ia32_stmxcsr(); } -static __inline__ void DEFAULT_FN_ATTRS +static __inline__ void __DEFAULT_FN_ATTRS _mm_setcsr(unsigned int __i) { __builtin_ia32_ldmxcsr(__i); @@ -795,37 +795,37 @@ _mm_setcsr(unsigned int __i) (((mask) & 0x30) >> 4) + 4, \ (((mask) & 0xc0) >> 6) + 4); }) -static __inline__ __m128 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtpi16_ps(__m64 __a) { __m64 __b, __c; @@ -843,7 +843,7 @@ _mm_cvtpi16_ps(__m64 __a) return __r; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtpu16_ps(__m64 __a) { __m64 __b, __c; @@ -860,7 +860,7 @@ _mm_cvtpu16_ps(__m64 __a) return __r; } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtpi8_ps(__m64 __a) { __m64 __b; @@ -872,7 +872,7 @@ _mm_cvtpi8_ps(__m64 __a) return _mm_cvtpi16_ps(__b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtpu8_ps(__m64 __a) { __m64 __b; @@ -883,7 +883,7 @@ _mm_cvtpu8_ps(__m64 __a) return _mm_cvtpi16_ps(__b); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtpi32x2_ps(__m64 __a, __m64 __b) { __m128 __c; @@ -895,7 +895,7 @@ _mm_cvtpi32x2_ps(__m64 __a, __m64 __b) return _mm_cvtpi32_ps(__c, __a); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_cvtps_pi16(__m128 __a) { __m64 __b, __c; @@ -907,7 +907,7 @@ _mm_cvtps_pi16(__m128 __a) return _mm_packs_pi32(__b, __c); } -static __inline__ __m64 DEFAULT_FN_ATTRS +static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_cvtps_pi8(__m128 __a) { __m64 __b, __c; @@ -918,7 +918,7 @@ _mm_cvtps_pi8(__m128 __a) return _mm_packs_pi16(__b, __c); } -static __inline__ int DEFAULT_FN_ATTRS +static __inline__ int __DEFAULT_FN_ATTRS _mm_movemask_ps(__m128 __a) { return __builtin_ia32_movmskps(__a); @@ -992,7 +992,7 @@ do { \ #define _m_ _mm_ #define _m_ _mm_ -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS /* Ugly hack for backwards-compatibility (compatible with gcc) */ #if defined(__SSE2__) && !__has_feature(modules) diff --git a/lib/Headers/xopintrin.h b/lib/Headers/xopintrin.h index 8417d7826962..86188bb29fd7 100644 --- a/lib/Headers/xopintrin.h +++ b/lib/Headers/xopintrin.h @@ -31,207 +31,207 @@ #include <fma4intrin.h> /* Define the default attributes for the functions in this file. */ -#define DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("xop"))) +#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("xop"))) -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_haddw_epi8(__m128i __A) { return (__m128i)__builtin_ia32_vphaddbw((__v16qi)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_haddd_epi8(__m128i __A) { return (__m128i)__builtin_ia32_vphaddbd((__v16qi)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_haddq_epi8(__m128i __A) { return (__m128i)__builtin_ia32_vphaddbq((__v16qi)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_haddd_epi16(__m128i __A) { return (__m128i)__builtin_ia32_vphaddwd((__v8hi)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_haddq_epi16(__m128i __A) { return (__m128i)__builtin_ia32_vphaddwq((__v8hi)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_haddq_epi32(__m128i __A) { return (__m128i)__builtin_ia32_vphadddq((__v4si)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_haddw_epu8(__m128i __A) { return (__m128i)__builtin_ia32_vphaddubw((__v16qi)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_haddd_epu8(__m128i __A) { return (__m128i)__builtin_ia32_vphaddubd((__v16qi)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_haddq_epu8(__m128i __A) { return (__m128i)__builtin_ia32_vphaddubq((__v16qi)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_haddd_epu16(__m128i __A) { return (__m128i)__builtin_ia32_vphadduwd((__v8hi)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_haddq_epu16(__m128i __A) { return (__m128i)__builtin_ia32_vphadduwq((__v8hi)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_haddq_epu32(__m128i __A) { return (__m128i)__builtin_ia32_vphaddudq((__v4si)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_hsubw_epi8(__m128i __A) { return (__m128i)__builtin_ia32_vphsubbw((__v16qi)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_hsubd_epi16(__m128i __A) { return (__m128i)__builtin_ia32_vphsubwd((__v8hi)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_hsubq_epi32(__m128i __A) { return (__m128i)__builtin_ia32_vphsubdq((__v4si)__A); } -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_rot_epi64(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vprotq((__v2di)__A, (__v2di)__B); @@ -253,49 +253,49 @@ _mm_rot_epi64(__m128i __A, __m128i __B) __m128i __A = (A); \ (__m128i)__builtin_ia32_vprotqi((__v2di)__A, (N)); }) -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sha_epi64(__m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_vpshaq((__v2di)__A, (__v2di)__B); @@ -350,385 +350,385 @@ _mm_sha_epi64(__m128i __A, __m128i __B) #define _MM_PCOMCTRL_FALSE 6 #define _MM_PCOMCTRL_TRUE 7 -static __inline__ __m128i DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +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 DEFAULT_FN_ATTRS +static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_comtrue_epi64(__m128i __A, __m128i __B) { return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_TRUE); @@ -762,42 +762,42 @@ _mm_comtrue_epi64(__m128i __A, __m128i __B) (__m256)__builtin_ia32_vpermil2ps256((__v8sf)__X, (__v8sf)__Y, \ (__v8si)__C, (I)); }) -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_frcz_ss(__m128 __A) { return (__m128)__builtin_ia32_vfrczss((__v4sf)__A); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_frcz_sd(__m128d __A) { return (__m128d)__builtin_ia32_vfrczsd((__v2df)__A); } -static __inline__ __m128 DEFAULT_FN_ATTRS +static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_frcz_ps(__m128 __A) { return (__m128)__builtin_ia32_vfrczps((__v4sf)__A); } -static __inline__ __m128d DEFAULT_FN_ATTRS +static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_frcz_pd(__m128d __A) { return (__m128d)__builtin_ia32_vfrczpd((__v2df)__A); } -static __inline__ __m256 DEFAULT_FN_ATTRS +static __inline__ __m256 __DEFAULT_FN_ATTRS _mm256_frcz_ps(__m256 __A) { return (__m256)__builtin_ia32_vfrczps256((__v8sf)__A); } -static __inline__ __m256d DEFAULT_FN_ATTRS +static __inline__ __m256d __DEFAULT_FN_ATTRS _mm256_frcz_pd(__m256d __A) { return (__m256d)__builtin_ia32_vfrczpd256((__v4df)__A); } -#undef DEFAULT_FN_ATTRS +#undef __DEFAULT_FN_ATTRS #endif /* __XOPINTRIN_H */ diff --git a/lib/Lex/HeaderSearch.cpp b/lib/Lex/HeaderSearch.cpp index 7a98f5418334..6c5c64bd266b 100644 --- a/lib/Lex/HeaderSearch.cpp +++ b/lib/Lex/HeaderSearch.cpp @@ -14,6 +14,7 @@ #include "clang/Lex/HeaderSearch.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/IdentifierTable.h" +#include "clang/Lex/ExternalPreprocessorSource.h" #include "clang/Lex/HeaderMap.h" #include "clang/Lex/HeaderSearchOptions.h" #include "clang/Lex/LexDiagnostic.h" @@ -33,9 +34,13 @@ using namespace clang; const IdentifierInfo * -HeaderFileInfo::getControllingMacro(ExternalIdentifierLookup *External) { - if (ControllingMacro) +HeaderFileInfo::getControllingMacro(ExternalPreprocessorSource *External) { + if (ControllingMacro) { + if (ControllingMacro->isOutOfDate()) + External->updateOutOfDateIdentifier( + *const_cast<IdentifierInfo *>(ControllingMacro)); return ControllingMacro; + } if (!ControllingMacroID || !External) return nullptr; @@ -527,9 +532,13 @@ const FileEntry *DirectoryLookup::DoFrameworkLookup( // Load this framework module. If that succeeds, find the suggested module // for this header, if any. bool IsSystem = getDirCharacteristic() != SrcMgr::C_User; - if (HS.loadFrameworkModule(ModuleName, TopFrameworkDir, IsSystem)) { - *SuggestedModule = HS.findModuleForHeader(FE); - } + HS.loadFrameworkModule(ModuleName, TopFrameworkDir, IsSystem); + + // FIXME: This can find a module not part of ModuleName, which is + // important so that we're consistent about whether this header + // corresponds to a module. Possibly we should lock down framework modules + // so that this is not possible. + *SuggestedModule = HS.findModuleForHeader(FE); } else { *SuggestedModule = HS.findModuleForHeader(FE); } @@ -1025,7 +1034,7 @@ void HeaderSearch::MarkFileModuleHeader(const FileEntry *FE, bool HeaderSearch::ShouldEnterIncludeFile(Preprocessor &PP, const FileEntry *File, - bool isImport) { + bool isImport, Module *M) { ++NumIncluded; // Count # of attempted #includes. // Get information about this file. @@ -1050,7 +1059,11 @@ bool HeaderSearch::ShouldEnterIncludeFile(Preprocessor &PP, // if the macro that guards it is defined, we know the #include has no effect. if (const IdentifierInfo *ControllingMacro = FileInfo.getControllingMacro(ExternalLookup)) - if (PP.isMacroDefined(ControllingMacro)) { + // If the include file is part of a module, and we already know what its + // controlling macro is, then we've already parsed it and can safely just + // make it visible. This saves us needing to switch into the visibility + // state of the module just to check whether the macro is defined within it. + if (M || PP.isMacroDefined(ControllingMacro)) { ++NumMultiIncludeFileOptzn; return false; } @@ -1229,6 +1242,9 @@ Module *HeaderSearch::loadFrameworkModule(StringRef Name, // Try to load a module map file. switch (loadModuleMapFile(Dir, IsSystem, /*IsFramework*/true)) { case LMM_InvalidModuleMap: + // Try to infer a module map from the framework directory. + if (HSOpts->ImplicitModuleMaps) + ModMap.inferFrameworkModule(Dir, IsSystem, /*Parent=*/nullptr); break; case LMM_AlreadyLoaded: @@ -1236,15 +1252,10 @@ Module *HeaderSearch::loadFrameworkModule(StringRef Name, return nullptr; case LMM_NewlyLoaded: - return ModMap.findModule(Name); + break; } - - // Try to infer a module map from the framework directory. - if (HSOpts->ImplicitModuleMaps) - return ModMap.inferFrameworkModule(Name, Dir, IsSystem, /*Parent=*/nullptr); - - return nullptr; + return ModMap.findModule(Name); } diff --git a/lib/Lex/ModuleMap.cpp b/lib/Lex/ModuleMap.cpp index 6c98d01c170b..e6fe38927e26 100644 --- a/lib/Lex/ModuleMap.cpp +++ b/lib/Lex/ModuleMap.cpp @@ -346,6 +346,9 @@ ModuleMap::KnownHeader ModuleMap::findModuleForHeader(const FileEntry *File) { ModuleMap::KnownHeader Result; // Iterate over all modules that 'File' is part of to find the best fit. for (KnownHeader &H : Known->second) { + // Prefer a header from the current module over all others. + if (H.getModule() == CompilingModule) + return MakeResult(H); // Cannot use a module if it is unavailable. if (!H.getModule()->isAvailable()) continue; @@ -580,19 +583,28 @@ static void inferFrameworkLink(Module *Mod, const DirectoryEntry *FrameworkDir, } } -Module * -ModuleMap::inferFrameworkModule(StringRef ModuleName, - const DirectoryEntry *FrameworkDir, - bool IsSystem, - Module *Parent) { +Module *ModuleMap::inferFrameworkModule(const DirectoryEntry *FrameworkDir, + bool IsSystem, Module *Parent) { Attributes Attrs; Attrs.IsSystem = IsSystem; - return inferFrameworkModule(ModuleName, FrameworkDir, Attrs, Parent); + return inferFrameworkModule(FrameworkDir, Attrs, Parent); } -Module *ModuleMap::inferFrameworkModule(StringRef ModuleName, - const DirectoryEntry *FrameworkDir, +Module *ModuleMap::inferFrameworkModule(const DirectoryEntry *FrameworkDir, Attributes Attrs, Module *Parent) { + // Note: as an egregious but useful hack we use the real path here, because + // we might be looking at an embedded framework that symlinks out to a + // top-level framework, and we need to infer as if we were naming the + // top-level framework. + StringRef FrameworkDirName = + SourceMgr.getFileManager().getCanonicalName(FrameworkDir); + + // In case this is a case-insensitive filesystem, use the canonical + // directory name as the ModuleName, since modules are case-sensitive. + // FIXME: we should be able to give a fix-it hint for the correct spelling. + SmallString<32> ModuleNameStorage; + StringRef ModuleName = sanitizeFilenameAsIdentifier( + llvm::sys::path::stem(FrameworkDirName), ModuleNameStorage); // Check whether we've already found this module. if (Module *Mod = lookupModuleQualified(ModuleName, Parent)) @@ -605,20 +617,6 @@ Module *ModuleMap::inferFrameworkModule(StringRef ModuleName, const FileEntry *ModuleMapFile = nullptr; if (!Parent) { // Determine whether we're allowed to infer a module map. - - // Note: as an egregious but useful hack we use the real path here, because - // we might be looking at an embedded framework that symlinks out to a - // top-level framework, and we need to infer as if we were naming the - // top-level framework. - StringRef FrameworkDirName - = SourceMgr.getFileManager().getCanonicalName(FrameworkDir); - - // In case this is a case-insensitive filesystem, make sure the canonical - // directory name matches ModuleName exactly. Modules are case-sensitive. - // FIXME: we should be able to give a fix-it hint for the correct spelling. - if (llvm::sys::path::stem(FrameworkDirName) != ModuleName) - return nullptr; - bool canInfer = false; if (llvm::sys::path::has_parent_path(FrameworkDirName)) { // Figure out the parent path. @@ -744,10 +742,7 @@ Module *ModuleMap::inferFrameworkModule(StringRef ModuleName, continue; // FIXME: Do we want to warn about subframeworks without umbrella headers? - SmallString<32> NameBuf; - inferFrameworkModule(sanitizeFilenameAsIdentifier( - llvm::sys::path::stem(Dir->path()), NameBuf), - SubframeworkDir, Attrs, Result); + inferFrameworkModule(SubframeworkDir, Attrs, Result); } } diff --git a/lib/Lex/PPDirectives.cpp b/lib/Lex/PPDirectives.cpp index 33ce79922819..ce64538de41b 100644 --- a/lib/Lex/PPDirectives.cpp +++ b/lib/Lex/PPDirectives.cpp @@ -1749,7 +1749,8 @@ void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc, // Ask HeaderInfo if we should enter this #include file. If not, #including // this file will have no effect. if (ShouldEnter && - !HeaderInfo.ShouldEnterIncludeFile(*this, File, isImport)) { + !HeaderInfo.ShouldEnterIncludeFile(*this, File, isImport, + SuggestedModule.getModule())) { ShouldEnter = false; if (Callbacks) Callbacks->FileSkipped(*File, FilenameTok, FileCharacter); diff --git a/lib/Lex/PPLexerChange.cpp b/lib/Lex/PPLexerChange.cpp index 1a35d32dedb5..c231e18eecc3 100644 --- a/lib/Lex/PPLexerChange.cpp +++ b/lib/Lex/PPLexerChange.cpp @@ -644,11 +644,20 @@ void Preprocessor::EnterSubmodule(Module *M, SourceLocation ImportLoc) { if (FirstTime) { // Determine the set of starting macros for this submodule; take these // from the "null" module (the predefines buffer). + // + // FIXME: If we have local visibility but not modules enabled, the + // NullSubmoduleState is polluted by #defines in the top-level source + // file. auto &StartingMacros = NullSubmoduleState.Macros; // Restore to the starting state. // FIXME: Do this lazily, when each macro name is first referenced. for (auto &Macro : StartingMacros) { + // Skip uninteresting macros. + if (!Macro.second.getLatest() && + Macro.second.getOverriddenMacros().empty()) + continue; + MacroState MS(Macro.second.getLatest()); MS.setOverriddenMacros(*this, Macro.second.getOverriddenMacros()); State.Macros.insert(std::make_pair(Macro.first, std::move(MS))); @@ -732,6 +741,11 @@ void Preprocessor::LeaveSubmodule() { } } + // FIXME: Before we leave this submodule, we should parse all the other + // headers within it. Otherwise, we're left with an inconsistent state + // where we've made the module visible but don't yet have its complete + // contents. + // Put back the outer module's state, if we're tracking it. if (getLangOpts().ModulesLocalVisibility) CurSubmoduleState = Info.OuterSubmoduleState; @@ -739,6 +753,5 @@ void Preprocessor::LeaveSubmodule() { BuildingSubmoduleStack.pop_back(); // A nested #include makes the included submodule visible. - if (!BuildingSubmoduleStack.empty() || !getLangOpts().ModulesLocalVisibility) - makeModuleVisible(LeavingMod, ImportLoc); + makeModuleVisible(LeavingMod, ImportLoc); } diff --git a/lib/Lex/PPMacroExpansion.cpp b/lib/Lex/PPMacroExpansion.cpp index 5e0b283bd77d..d52519e3313b 100644 --- a/lib/Lex/PPMacroExpansion.cpp +++ b/lib/Lex/PPMacroExpansion.cpp @@ -1052,7 +1052,7 @@ static bool HasFeature(const Preprocessor &PP, const IdentifierInfo *II) { .Case("address_sanitizer", LangOpts.Sanitize.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress)) - .Case("assume_nonnull", LangOpts.ObjC1 || LangOpts.GNUMode) + .Case("assume_nonnull", true) .Case("attribute_analyzer_noreturn", true) .Case("attribute_availability", true) .Case("attribute_availability_with_message", true) @@ -1077,7 +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("nullability", true) .Case("memory_sanitizer", LangOpts.Sanitize.has(SanitizerKind::Memory)) .Case("thread_sanitizer", LangOpts.Sanitize.has(SanitizerKind::Thread)) .Case("dataflow_sanitizer", LangOpts.Sanitize.has(SanitizerKind::DataFlow)) @@ -1102,6 +1102,7 @@ static bool HasFeature(const Preprocessor &PP, const IdentifierInfo *II) { .Case("objc_array_literals", LangOpts.ObjC2) .Case("objc_dictionary_literals", LangOpts.ObjC2) .Case("objc_boxed_expressions", LangOpts.ObjC2) + .Case("objc_boxed_nsvalue_expressions", LangOpts.ObjC2) .Case("arc_cf_code_audited", true) .Case("objc_bridge_id", true) .Case("objc_bridge_id_on_typedefs", true) @@ -1225,7 +1226,6 @@ 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) diff --git a/lib/Lex/Preprocessor.cpp b/lib/Lex/Preprocessor.cpp index 7e33f1ccb487..e2db638a33d0 100644 --- a/lib/Lex/Preprocessor.cpp +++ b/lib/Lex/Preprocessor.cpp @@ -286,6 +286,10 @@ Preprocessor::macro_begin(bool IncludeExternalMacros) const { ExternalSource->ReadDefinedMacros(); } + // Make sure we cover all macros in visible modules. + for (const ModuleMacro &Macro : ModuleMacros) + CurSubmoduleState->Macros.insert(std::make_pair(Macro.II, MacroState())); + return CurSubmoduleState->Macros.begin(); } diff --git a/lib/Parse/ParseCXXInlineMethods.cpp b/lib/Parse/ParseCXXInlineMethods.cpp index ea67a52f1fc1..ab1f97d31a69 100644 --- a/lib/Parse/ParseCXXInlineMethods.cpp +++ b/lib/Parse/ParseCXXInlineMethods.cpp @@ -27,7 +27,7 @@ NamedDecl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, ParsingDeclarator &D, const ParsedTemplateInfo &TemplateInfo, const VirtSpecifiers& VS, - ExprResult& Init) { + SourceLocation PureSpecLoc) { assert(D.isFunctionDeclarator() && "This isn't a function declarator!"); assert(Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try, tok::equal) && "Current token not a '{', ':', '=', or 'try'!"); @@ -47,12 +47,8 @@ NamedDecl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, VS, ICIS_NoInit); if (FnD) { Actions.ProcessDeclAttributeList(getCurScope(), FnD, AccessAttrs); - bool TypeSpecContainsAuto = D.getDeclSpec().containsPlaceholderType(); - if (Init.isUsable()) - Actions.AddInitializerToDecl(FnD, Init.get(), false, - TypeSpecContainsAuto); - else - Actions.ActOnUninitializedDecl(FnD, TypeSpecContainsAuto); + if (PureSpecLoc.isValid()) + Actions.ActOnPureSpecifier(FnD, PureSpecLoc); } } diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp index 1c52552ea15d..d843e801b634 100644 --- a/lib/Parse/ParseDecl.cpp +++ b/lib/Parse/ParseDecl.cpp @@ -691,9 +691,9 @@ 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: { + case tok::kw__Nonnull: + case tok::kw__Nullable: + case tok::kw__Null_unspecified: { IdentifierInfo *AttrName = Tok.getIdentifierInfo(); SourceLocation AttrNameLoc = ConsumeToken(); if (!getLangOpts().ObjC1) @@ -2173,7 +2173,7 @@ void Parser::ParseSpecifierQualifierList(DeclSpec &DS, AccessSpecifier AS, } // Issue diagnostic and remove constexpr specfier if present. - if (DS.isConstexprSpecified()) { + if (DS.isConstexprSpecified() && DSC != DSC_condition) { Diag(DS.getConstexprSpecLoc(), diag::err_typename_invalid_constexpr); DS.ClearConstexprSpec(); } @@ -3076,9 +3076,9 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS, continue; // Nullability type specifiers. - case tok::kw___nonnull: - case tok::kw___nullable: - case tok::kw___null_unspecified: + case tok::kw__Nonnull: + case tok::kw__Nullable: + case tok::kw__Null_unspecified: ParseNullabilityTypeSpecifiers(DS.getAttributes()); continue; @@ -3192,6 +3192,11 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS, isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID); break; + // concept + case tok::kw_concept: + isInvalid = DS.SetConceptSpec(Loc, PrevSpec, DiagID); + break; + // type-specifier case tok::kw_short: isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, @@ -4326,9 +4331,9 @@ 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__Nonnull: + case tok::kw__Nullable: + case tok::kw__Null_unspecified: case tok::kw___private: case tok::kw___local: @@ -4475,6 +4480,9 @@ bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) { case tok::annot_decltype: case tok::kw_constexpr: + // C++ Concepts TS - concept + case tok::kw_concept: + // C11 _Atomic case tok::kw__Atomic: return true; @@ -4503,9 +4511,9 @@ 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__Nonnull: + case tok::kw__Nullable: + case tok::kw__Null_unspecified: case tok::kw___private: case tok::kw___local: @@ -4738,9 +4746,9 @@ void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, unsigned AttrReqs, goto DoneWithTypeQuals; // Nullability type specifiers. - case tok::kw___nonnull: - case tok::kw___nullable: - case tok::kw___null_unspecified: + case tok::kw__Nonnull: + case tok::kw__Nullable: + case tok::kw__Null_unspecified: ParseNullabilityTypeSpecifiers(DS.getAttributes()); continue; diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp index 47778b856dda..568896db42be 100644 --- a/lib/Parse/ParseDeclCXX.cpp +++ b/lib/Parse/ParseDeclCXX.cpp @@ -2372,8 +2372,28 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, LateParsedAttrList LateParsedAttrs; SourceLocation EqualLoc; - bool HasInitializer = false; - ExprResult Init; + SourceLocation PureSpecLoc; + + auto TryConsumePureSpecifier = [&] (bool AllowDefinition) { + if (Tok.isNot(tok::equal)) + return false; + + auto &Zero = NextToken(); + SmallString<8> Buffer; + if (Zero.isNot(tok::numeric_constant) || Zero.getLength() != 1 || + PP.getSpelling(Zero, Buffer) != "0") + return false; + + auto &After = GetLookAheadToken(2); + if (!After.isOneOf(tok::semi, tok::comma) && + !(AllowDefinition && + After.isOneOf(tok::l_brace, tok::colon, tok::kw_try))) + return false; + + EqualLoc = ConsumeToken(); + PureSpecLoc = ConsumeToken(); + return true; + }; SmallVector<Decl *, 8> DeclsInGroup; ExprResult BitfieldSize; @@ -2390,16 +2410,8 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, if (BitfieldSize.isUnset()) { // MSVC permits pure specifier on inline functions defined at class scope. // Hence check for =0 before checking for function definition. - if (getLangOpts().MicrosoftExt && Tok.is(tok::equal) && - DeclaratorInfo.isFunctionDeclarator() && - NextToken().is(tok::numeric_constant)) { - EqualLoc = ConsumeToken(); - Init = ParseInitializer(); - if (Init.isInvalid()) - SkipUntil(tok::comma, StopAtSemi | StopBeforeMatch); - else - HasInitializer = true; - } + if (getLangOpts().MicrosoftExt && DeclaratorInfo.isDeclarationOfFunction()) + TryConsumePureSpecifier(/*AllowDefinition*/ true); FunctionDefinitionKind DefinitionKind = FDK_Declaration; // function-definition: @@ -2453,7 +2465,7 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, Decl *FunDecl = ParseCXXInlineMethodDef(AS, AccessAttrs, DeclaratorInfo, TemplateInfo, - VS, Init); + VS, PureSpecLoc); if (FunDecl) { for (unsigned i = 0, ni = CommonLateParsedAttrs.size(); i < ni; ++i) { @@ -2479,16 +2491,25 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, while (1) { InClassInitStyle HasInClassInit = ICIS_NoInit; - if (Tok.isOneOf(tok::equal, tok::l_brace) && !HasInitializer) { + bool HasStaticInitializer = false; + if (Tok.isOneOf(tok::equal, tok::l_brace) && PureSpecLoc.isInvalid()) { if (BitfieldSize.get()) { Diag(Tok, diag::err_bitfield_member_init); SkipUntil(tok::comma, StopAtSemi | StopBeforeMatch); + } else if (DeclaratorInfo.isDeclarationOfFunction()) { + // It's a pure-specifier. + if (!TryConsumePureSpecifier(/*AllowFunctionDefinition*/ false)) + // Parse it as an expression so that Sema can diagnose it. + HasStaticInitializer = true; + } else if (DeclaratorInfo.getDeclSpec().getStorageClassSpec() != + DeclSpec::SCS_static && + DeclaratorInfo.getDeclSpec().getStorageClassSpec() != + DeclSpec::SCS_typedef && + !DS.isFriendSpecified()) { + // It's a default member initializer. + HasInClassInit = Tok.is(tok::equal) ? ICIS_CopyInit : ICIS_ListInit; } else { - HasInitializer = true; - if (!DeclaratorInfo.isDeclarationOfFunction() && - DeclaratorInfo.getDeclSpec().getStorageClassSpec() - != DeclSpec::SCS_typedef) - HasInClassInit = Tok.is(tok::equal) ? ICIS_CopyInit : ICIS_ListInit; + HasStaticInitializer = true; } } @@ -2528,10 +2549,20 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, Actions.ProcessDeclAttributeList(getCurScope(), ThisDecl, AccessAttrs); } - // Handle the initializer. + // Error recovery might have converted a non-static member into a static + // member. if (HasInClassInit != ICIS_NoInit && - DeclaratorInfo.getDeclSpec().getStorageClassSpec() != - DeclSpec::SCS_static) { + DeclaratorInfo.getDeclSpec().getStorageClassSpec() == + DeclSpec::SCS_static) { + HasInClassInit = ICIS_NoInit; + HasStaticInitializer = true; + } + + if (ThisDecl && PureSpecLoc.isValid()) + Actions.ActOnPureSpecifier(ThisDecl, PureSpecLoc); + + // Handle the initializer. + if (HasInClassInit != ICIS_NoInit) { // The initializer was deferred; parse it and cache the tokens. Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_nonstatic_member_init @@ -2551,11 +2582,10 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, ThisDecl->setInvalidDecl(); } else ParseCXXNonStaticMemberInitializer(ThisDecl); - } else if (HasInitializer) { + } else if (HasStaticInitializer) { // Normal initializer. - if (!Init.isUsable()) - Init = ParseCXXMemberInitializer( - ThisDecl, DeclaratorInfo.isDeclarationOfFunction(), EqualLoc); + ExprResult Init = ParseCXXMemberInitializer( + ThisDecl, DeclaratorInfo.isDeclarationOfFunction(), EqualLoc); if (Init.isInvalid()) SkipUntil(tok::comma, StopAtSemi | StopBeforeMatch); @@ -2608,8 +2638,7 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, DeclaratorInfo.clear(); VS.clear(); BitfieldSize = ExprResult(/*Invalid=*/false); - Init = ExprResult(/*Invalid=*/false); - HasInitializer = false; + EqualLoc = PureSpecLoc = SourceLocation(); DeclaratorInfo.setCommaLoc(CommaLoc); // GNU attributes are allowed before the second and subsequent declarator. @@ -2632,13 +2661,11 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, Actions.FinalizeDeclaratorGroup(getCurScope(), DS, DeclsInGroup); } -/// ParseCXXMemberInitializer - Parse the brace-or-equal-initializer or -/// pure-specifier. Also detect and reject any attempted defaulted/deleted -/// function definition. The location of the '=', if any, will be placed in -/// EqualLoc. +/// ParseCXXMemberInitializer - Parse the brace-or-equal-initializer. +/// Also detect and reject any attempted defaulted/deleted function definition. +/// The location of the '=', if any, will be placed in EqualLoc. /// -/// pure-specifier: -/// '= 0' +/// This does not check for a pure-specifier; that's handled elsewhere. /// /// brace-or-equal-initializer: /// '=' initializer-expression @@ -2742,6 +2769,11 @@ void Parser::SkipCXXMemberSpecification(SourceLocation RecordLoc, BalancedDelimiterTracker T(*this, tok::l_brace); T.consumeOpen(); T.skipToEnd(); + + // Parse and discard any trailing attributes. + ParsedAttributes Attrs(AttrFactory); + if (Tok.is(tok::kw___attribute)) + MaybeParseGNUAttributes(Attrs); } /// ParseCXXMemberSpecification - Parse the class definition. @@ -3317,13 +3349,16 @@ Parser::tryParseExceptionSpecification(bool Delayed, T.consumeOpen(); NoexceptType = EST_ComputedNoexcept; NoexceptExpr = ParseConstantExpression(); + T.consumeClose(); // The argument must be contextually convertible to bool. We use // ActOnBooleanCondition for this purpose. - if (!NoexceptExpr.isInvalid()) + if (!NoexceptExpr.isInvalid()) { NoexceptExpr = Actions.ActOnBooleanCondition(getCurScope(), KeywordLoc, NoexceptExpr.get()); - T.consumeClose(); - NoexceptRange = SourceRange(KeywordLoc, T.getCloseLocation()); + NoexceptRange = SourceRange(KeywordLoc, T.getCloseLocation()); + } else { + NoexceptType = EST_None; + } } else { // There is no argument. NoexceptType = EST_BasicNoexcept; diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp index da759c76522c..b866798a1c61 100644 --- a/lib/Parse/ParseExpr.cpp +++ b/lib/Parse/ParseExpr.cpp @@ -205,6 +205,24 @@ ExprResult Parser::ParseConstantExpression(TypeCastState isTypeCast) { return Actions.ActOnConstantExpression(Res); } +/// \brief Parse a constraint-expression. +/// +/// \verbatim +/// constraint-expression: [Concepts TS temp.constr.decl p1] +/// logical-or-expression +/// \endverbatim +ExprResult Parser::ParseConstraintExpression() { + // FIXME: this may erroneously consume a function-body as the braced + // initializer list of a compound literal + // + // FIXME: this may erroneously consume a parenthesized rvalue reference + // declarator as a parenthesized address-of-label expression + ExprResult LHS(ParseCastExpression(/*isUnaryExpression=*/false)); + ExprResult Res(ParseRHSOfBinaryExpression(LHS, prec::LogicalOr)); + + return Res; +} + bool Parser::isNotExpressionStart() { tok::TokenKind K = Tok.getKind(); if (K == tok::l_brace || K == tok::r_brace || @@ -1042,6 +1060,8 @@ ExprResult Parser::ParseCastExpression(bool isUnaryExpression, case tok::kw_sizeof: // unary-expression: 'sizeof' unary-expression // unary-expression: 'sizeof' '(' type-name ')' case tok::kw_vec_step: // unary-expression: OpenCL 'vec_step' expression + // unary-expression: '__builtin_omp_required_simd_align' '(' type-name ')' + case tok::kw___builtin_omp_required_simd_align: return ParseUnaryExprOrTypeTraitExpression(); case tok::ampamp: { // unary-expression: '&&' identifier SourceLocation AmpAmpLoc = ConsumeToken(); @@ -1636,8 +1656,9 @@ Parser::ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok, ParsedType &CastTy, SourceRange &CastRange) { - assert(OpTok.isOneOf(tok::kw_typeof, tok::kw_sizeof, tok::kw___alignof, - tok::kw_alignof, tok::kw__Alignof, tok::kw_vec_step) && + assert(OpTok.isOneOf(tok::kw_typeof, tok::kw_sizeof, tok::kw___alignof, + tok::kw_alignof, tok::kw__Alignof, tok::kw_vec_step, + tok::kw___builtin_omp_required_simd_align) && "Not a typeof/sizeof/alignof/vec_step expression!"); ExprResult Operand; @@ -1722,7 +1743,8 @@ Parser::ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok, /// \endverbatim ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() { assert(Tok.isOneOf(tok::kw_sizeof, tok::kw___alignof, tok::kw_alignof, - tok::kw__Alignof, tok::kw_vec_step) && + tok::kw__Alignof, tok::kw_vec_step, + tok::kw___builtin_omp_required_simd_align) && "Not a sizeof/alignof/vec_step expression!"); Token OpTok = Tok; ConsumeToken(); @@ -1792,6 +1814,8 @@ ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() { ExprKind = UETT_AlignOf; else if (OpTok.is(tok::kw_vec_step)) ExprKind = UETT_VecStep; + else if (OpTok.is(tok::kw___builtin_omp_required_simd_align)) + ExprKind = UETT_OpenMPRequiredSimdAlign; if (isCastExpr) return Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(), diff --git a/lib/Parse/ParseExprCXX.cpp b/lib/Parse/ParseExprCXX.cpp index 7fb4b5e5a07f..02176c410592 100644 --- a/lib/Parse/ParseExprCXX.cpp +++ b/lib/Parse/ParseExprCXX.cpp @@ -1686,7 +1686,7 @@ bool Parser::ParseCXXCondition(ExprResult &ExprOut, // type-specifier-seq DeclSpec DS(AttrFactory); DS.takeAttributesFrom(attrs); - ParseSpecifierQualifierList(DS); + ParseSpecifierQualifierList(DS, AS_none, DSC_condition); // declarator Declarator DeclaratorInfo(DS, Declarator::ConditionContext); diff --git a/lib/Parse/ParseObjc.cpp b/lib/Parse/ParseObjc.cpp index e4f7911138de..f975f8715ed9 100644 --- a/lib/Parse/ParseObjc.cpp +++ b/lib/Parse/ParseObjc.cpp @@ -557,14 +557,14 @@ static void diagnoseRedundantPropertyNullability(Parser &P, SourceLocation nullabilityLoc){ if (DS.getNullability() == nullability) { P.Diag(nullabilityLoc, diag::warn_nullability_duplicate) - << static_cast<unsigned>(nullability) << true + << DiagNullabilityKind(nullability, true) << SourceRange(DS.getNullabilityLoc()); return; } P.Diag(nullabilityLoc, diag::err_nullability_conflicting) - << static_cast<unsigned>(nullability) << true - << static_cast<unsigned>(DS.getNullability()) << true + << DiagNullabilityKind(nullability, true) + << DiagNullabilityKind(DS.getNullability(), true) << SourceRange(DS.getNullabilityLoc()); } diff --git a/lib/Parse/ParseOpenMP.cpp b/lib/Parse/ParseOpenMP.cpp index a3c3c5dc7d49..0113a3157c25 100644 --- a/lib/Parse/ParseOpenMP.cpp +++ b/lib/Parse/ParseOpenMP.cpp @@ -30,24 +30,39 @@ static OpenMPDirectiveKind ParseOpenMPDirectiveKind(Parser &P) { // E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd // TODO: add other combined directives in topological order. const OpenMPDirectiveKind F[][3] = { - { OMPD_for, OMPD_simd, OMPD_for_simd }, - { OMPD_parallel, OMPD_for, OMPD_parallel_for }, - { OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd }, - { OMPD_parallel, OMPD_sections, OMPD_parallel_sections } - }; + {OMPD_unknown /*cancellation*/, OMPD_unknown /*point*/, + OMPD_cancellation_point}, + {OMPD_for, OMPD_simd, OMPD_for_simd}, + {OMPD_parallel, OMPD_for, OMPD_parallel_for}, + {OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd}, + {OMPD_parallel, OMPD_sections, OMPD_parallel_sections}}; auto Tok = P.getCurToken(); auto DKind = Tok.isAnnotation() ? OMPD_unknown : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok)); + bool TokenMatched = false; for (unsigned i = 0; i < llvm::array_lengthof(F); ++i) { - if (DKind == F[i][0]) { + if (!Tok.isAnnotation() && DKind == OMPD_unknown) { + TokenMatched = + (i == 0) && + !P.getPreprocessor().getSpelling(Tok).compare("cancellation"); + } else { + TokenMatched = DKind == F[i][0] && DKind != OMPD_unknown; + } + if (TokenMatched) { Tok = P.getPreprocessor().LookAhead(0); auto SDKind = Tok.isAnnotation() ? OMPD_unknown : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok)); - if (SDKind == F[i][1]) { + if (!Tok.isAnnotation() && DKind == OMPD_unknown) { + TokenMatched = + (i == 0) && !P.getPreprocessor().getSpelling(Tok).compare("point"); + } else { + TokenMatched = SDKind == F[i][1] && SDKind != OMPD_unknown; + } + if (TokenMatched) { P.ConsumeToken(); DKind = F[i][2]; } @@ -110,6 +125,8 @@ Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() { case OMPD_atomic: case OMPD_target: case OMPD_teams: + case OMPD_cancellation_point: + case OMPD_cancel: Diag(Tok, diag::err_omp_unexpected_directive) << getOpenMPDirectiveName(DKind); break; @@ -145,6 +162,7 @@ Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) { Scope::FnScope | Scope::DeclScope | Scope::OpenMPDirectiveScope; SourceLocation Loc = ConsumeToken(), EndLoc; auto DKind = ParseOpenMPDirectiveKind(*this); + OpenMPDirectiveKind CancelRegion = OMPD_unknown; // Name of critical directive. DeclarationNameInfo DirName; StmtResult Directive = StmtError(); @@ -178,6 +196,8 @@ Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) { case OMPD_taskyield: case OMPD_barrier: case OMPD_taskwait: + case OMPD_cancellation_point: + case OMPD_cancel: if (!StandAloneAllowed) { Diag(Tok, diag::err_omp_immediate_directive) << getOpenMPDirectiveName(DKind); @@ -217,6 +237,10 @@ Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) { } T.consumeClose(); } + } else if (DKind == OMPD_cancellation_point || DKind == OMPD_cancel) { + CancelRegion = ParseOpenMPDirectiveKind(*this); + if (Tok.isNot(tok::annot_pragma_openmp_end)) + ConsumeToken(); } if (isOpenMPLoopDirective(DKind)) @@ -226,13 +250,13 @@ Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) { ParseScope OMPDirectiveScope(this, ScopeFlags); Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope(), Loc); - Actions.StartOpenMPClauses(); while (Tok.isNot(tok::annot_pragma_openmp_end)) { OpenMPClauseKind CKind = Tok.isAnnotation() ? OMPC_unknown : FlushHasClause ? OMPC_flush : getOpenMPClauseKind(PP.getSpelling(Tok)); + Actions.StartOpenMPClause(CKind); FlushHasClause = false; OMPClause *Clause = ParseOpenMPClause(DKind, CKind, !FirstClauses[CKind].getInt()); @@ -245,8 +269,8 @@ Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) { // Skip ',' if any. if (Tok.is(tok::comma)) ConsumeToken(); + Actions.EndOpenMPClause(); } - Actions.EndOpenMPClauses(); // End location of the directive. EndLoc = Tok.getLocation(); // Consume final annot_pragma_openmp_end. @@ -267,7 +291,8 @@ Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) { } if (CreateDirective) Directive = Actions.ActOnOpenMPExecutableDirective( - DKind, DirName, Clauses, AssociatedStmt.get(), Loc, EndLoc); + DKind, DirName, CancelRegion, Clauses, AssociatedStmt.get(), Loc, + EndLoc); // Exit scope. Actions.EndOpenMPDSABlock(Directive.get()); @@ -453,6 +478,7 @@ OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind, case OMPC_copyin: case OMPC_copyprivate: case OMPC_flush: + case OMPC_depend: Clause = ParseOpenMPVarListClause(CKind); break; case OMPC_unknown: @@ -674,6 +700,8 @@ static bool ParseReductionId(Parser &P, CXXScopeSpec &ReductionIdScopeSpec, /// 'copyprivate' '(' list ')' /// flush-clause: /// 'flush' '(' list ')' +/// depend-clause: +/// 'depend' '(' in | out | inout : list ')' /// OMPClause *Parser::ParseOpenMPVarListClause(OpenMPClauseKind Kind) { SourceLocation Loc = Tok.getLocation(); @@ -683,6 +711,9 @@ OMPClause *Parser::ParseOpenMPVarListClause(OpenMPClauseKind Kind) { CXXScopeSpec ReductionIdScopeSpec; UnqualifiedId ReductionId; bool InvalidReductionId = false; + OpenMPDependClauseKind DepKind = OMPC_DEPEND_unknown; + SourceLocation DepLoc; + // Parse '('. BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); if (T.expectAndConsume(diag::err_expected_lparen_after, @@ -706,10 +737,30 @@ OMPClause *Parser::ParseOpenMPVarListClause(OpenMPClauseKind Kind) { } else { Diag(Tok, diag::warn_pragma_expected_colon) << "reduction identifier"; } + } else if (Kind == OMPC_depend) { + // Handle dependency type for depend clause. + ColonProtectionRAIIObject ColonRAII(*this); + DepKind = static_cast<OpenMPDependClauseKind>(getOpenMPSimpleClauseType( + Kind, Tok.is(tok::identifier) ? PP.getSpelling(Tok) : "")); + DepLoc = Tok.getLocation(); + + if (DepKind == OMPC_DEPEND_unknown) { + SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end, + StopBeforeMatch); + } else { + ConsumeToken(); + } + if (Tok.is(tok::colon)) { + ColonLoc = ConsumeToken(); + } else { + Diag(Tok, diag::warn_pragma_expected_colon) << "dependency type"; + } } SmallVector<Expr *, 5> Vars; - bool IsComma = !InvalidReductionId; + bool IsComma = ((Kind != OMPC_reduction) && (Kind != OMPC_depend)) || + ((Kind == OMPC_reduction) && !InvalidReductionId) || + ((Kind == OMPC_depend) && DepKind != OMPC_DEPEND_unknown); const bool MayHaveTail = (Kind == OMPC_linear || Kind == OMPC_aligned); while (IsComma || (Tok.isNot(tok::r_paren) && Tok.isNot(tok::colon) && Tok.isNot(tok::annot_pragma_openmp_end))) { @@ -753,13 +804,16 @@ OMPClause *Parser::ParseOpenMPVarListClause(OpenMPClauseKind Kind) { // Parse ')'. T.consumeClose(); - if (Vars.empty() || (MustHaveTail && !TailExpr) || InvalidReductionId) + if ((Kind == OMPC_depend && DepKind != OMPC_DEPEND_unknown && Vars.empty()) || + (Kind != OMPC_depend && Vars.empty()) || (MustHaveTail && !TailExpr) || + InvalidReductionId) return nullptr; return Actions.ActOnOpenMPVarListClause( Kind, Vars, TailExpr, Loc, LOpen, ColonLoc, Tok.getLocation(), ReductionIdScopeSpec, ReductionId.isValid() ? Actions.GetNameFromUnqualifiedId(ReductionId) - : DeclarationNameInfo()); + : DeclarationNameInfo(), + DepKind, DepLoc); } diff --git a/lib/Parse/ParseTemplate.cpp b/lib/Parse/ParseTemplate.cpp index a8116785fdfd..2a9becbc8570 100644 --- a/lib/Parse/ParseTemplate.cpp +++ b/lib/Parse/ParseTemplate.cpp @@ -116,7 +116,7 @@ Parser::ParseTemplateDeclarationOrSpecialization(unsigned Context, SmallVector<Decl*, 4> TemplateParams; if (ParseTemplateParameters(CurTemplateDepthTracker.getDepth(), TemplateParams, LAngleLoc, RAngleLoc)) { - // Skip until the semi-colon or a }. + // Skip until the semi-colon or a '}'. SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch); TryConsumeToken(tok::semi); return nullptr; @@ -132,6 +132,17 @@ Parser::ParseTemplateDeclarationOrSpecialization(unsigned Context, if (!TemplateParams.empty()) { isSpecialization = false; ++CurTemplateDepthTracker; + + if (TryConsumeToken(tok::kw_requires)) { + ExprResult ER = + Actions.CorrectDelayedTyposInExpr(ParseConstraintExpression()); + if (!ER.isUsable()) { + // Skip until the semi-colon or a '}'. + SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch); + TryConsumeToken(tok::semi); + return nullptr; + } + } } else { LastParamListWasEmpty = true; } diff --git a/lib/Parse/ParseTentative.cpp b/lib/Parse/ParseTentative.cpp index d63cf24bcdb9..368cb934bbaf 100644 --- a/lib/Parse/ParseTentative.cpp +++ b/lib/Parse/ParseTentative.cpp @@ -632,8 +632,8 @@ Parser::TPResult Parser::TryParsePtrOperatorSeq() { // ptr-operator ConsumeToken(); while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict, - tok::kw___nonnull, tok::kw___nullable, - tok::kw___null_unspecified)) + tok::kw__Nonnull, tok::kw__Nullable, + tok::kw__Null_unspecified)) ConsumeToken(); } else { return TPResult::True; @@ -1213,9 +1213,11 @@ Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult, // 'friend' // 'typedef' // 'constexpr' + // 'concept' case tok::kw_friend: case tok::kw_typedef: case tok::kw_constexpr: + case tok::kw_concept: // storage-class-specifier case tok::kw_register: case tok::kw_static: @@ -1276,9 +1278,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: + case tok::kw__Nonnull: + case tok::kw__Nullable: + case tok::kw__Null_unspecified: return TPResult::True; // Borland diff --git a/lib/Sema/AnalysisBasedWarnings.cpp b/lib/Sema/AnalysisBasedWarnings.cpp index 36030b99a30b..f2ff48ad69f4 100644 --- a/lib/Sema/AnalysisBasedWarnings.cpp +++ b/lib/Sema/AnalysisBasedWarnings.cpp @@ -130,11 +130,10 @@ public: return true; // Recurse to children. - for (ConstStmtRange SubStmts = E->children(); SubStmts; ++SubStmts) - if (*SubStmts) - if (const Expr *SubExpr = dyn_cast<Expr>(*SubStmts)) - if (HasMacroID(SubExpr)) - return true; + for (const Stmt *SubStmt : E->children()) + if (const Expr *SubExpr = dyn_cast_or_null<Expr>(SubStmt)) + if (HasMacroID(SubExpr)) + return true; return false; } diff --git a/lib/Sema/DeclSpec.cpp b/lib/Sema/DeclSpec.cpp index 1e7fc750a9cf..d5c8871cac87 100644 --- a/lib/Sema/DeclSpec.cpp +++ b/lib/Sema/DeclSpec.cpp @@ -893,6 +893,18 @@ bool DeclSpec::SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec, return false; } +bool DeclSpec::SetConceptSpec(SourceLocation Loc, const char *&PrevSpec, + unsigned &DiagID) { + if (Concept_specified) { + DiagID = diag::ext_duplicate_declspec; + PrevSpec = "concept"; + return true; + } + Concept_specified = true; + ConceptLoc = Loc; + return false; +} + void DeclSpec::setProtocolQualifiers(Decl * const *Protos, unsigned NP, SourceLocation *ProtoLocs, diff --git a/lib/Sema/JumpDiagnostics.cpp b/lib/Sema/JumpDiagnostics.cpp index 6b9eb2a4edde..775fe85740d4 100644 --- a/lib/Sema/JumpDiagnostics.cpp +++ b/lib/Sema/JumpDiagnostics.cpp @@ -372,13 +372,12 @@ void JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) break; } - for (Stmt::child_range CI = S->children(); CI; ++CI) { + for (Stmt *SubStmt : S->children()) { if (SkipFirstSubStmt) { SkipFirstSubStmt = false; continue; } - Stmt *SubStmt = *CI; if (!SubStmt) continue; // Cases, labels, and defaults aren't "scope parents". It's also diff --git a/lib/Sema/Sema.cpp b/lib/Sema/Sema.cpp index db1251f097f5..18d7e9dcf548 100644 --- a/lib/Sema/Sema.cpp +++ b/lib/Sema/Sema.cpp @@ -91,8 +91,9 @@ Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp), StdInitializerList(nullptr), CXXTypeInfoDecl(nullptr), MSVCGuidDecl(nullptr), - NSNumberDecl(nullptr), + NSNumberDecl(nullptr), NSValueDecl(nullptr), NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr), + ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr), ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr), DictionaryWithObjectsMethod(nullptr), MSAsmLabelNameCounter(0), diff --git a/lib/Sema/SemaChecking.cpp b/lib/Sema/SemaChecking.cpp index f76727cad881..bdfff80c7f20 100644 --- a/lib/Sema/SemaChecking.cpp +++ b/lib/Sema/SemaChecking.cpp @@ -1031,6 +1031,8 @@ bool Sema::CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { unsigned i = 0, l = 0, u = 0; switch (BuiltinID) { default: return false; + case X86::BI__builtin_cpu_supports: + return SemaBuiltinCpuSupports(TheCall); case X86::BI_mm_prefetch: i = 1; l = 0; u = 3; break; case X86::BI__builtin_ia32_sha1rnds4: i = 2, l = 0; u = 3; break; case X86::BI__builtin_ia32_vpermil2pd: @@ -2782,6 +2784,26 @@ bool Sema::SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall, return false; } +/// SemaBuiltinCpuSupports - Handle __builtin_cpu_supports(char *). +/// This checks that the target supports __builtin_cpu_supports and +/// that the string argument is constant and valid. +bool Sema::SemaBuiltinCpuSupports(CallExpr *TheCall) { + Expr *Arg = TheCall->getArg(0); + + // 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 contents of the string. + StringRef Feature = + cast<StringLiteral>(Arg->IgnoreParenImpCasts())->getString(); + if (!Context.getTargetInfo().validateCpuSupports(Feature)) + return Diag(TheCall->getLocStart(), diag::err_invalid_cpu_supports) + << Arg->getSourceRange(); + 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. @@ -3550,8 +3572,18 @@ public: const char *startSpecifier, unsigned specifierLen); bool checkForCStrMembers(const analyze_printf::ArgType &AT, const Expr *E); + + void HandleEmptyObjCModifierFlag(const char *startFlag, + unsigned flagLen) override; -}; + void HandleInvalidObjCModifierFlag(const char *startFlag, + unsigned flagLen) override; + + void HandleObjCFlagsWithNonObjCConversion(const char *flagsStart, + const char *flagsEnd, + const char *conversionPosition) + override; +}; } bool CheckPrintfHandler::HandleInvalidPrintfConversionSpecifier( @@ -3671,6 +3703,41 @@ void CheckPrintfHandler::HandleIgnoredFlag( getSpecifierRange(ignoredFlag.getPosition(), 1))); } +// void EmitFormatDiagnostic(PartialDiagnostic PDiag, SourceLocation StringLoc, +// bool IsStringLocation, Range StringRange, +// ArrayRef<FixItHint> Fixit = None); + +void CheckPrintfHandler::HandleEmptyObjCModifierFlag(const char *startFlag, + unsigned flagLen) { + // Warn about an empty flag. + EmitFormatDiagnostic(S.PDiag(diag::warn_printf_empty_objc_flag), + getLocationOfByte(startFlag), + /*IsStringLocation*/true, + getSpecifierRange(startFlag, flagLen)); +} + +void CheckPrintfHandler::HandleInvalidObjCModifierFlag(const char *startFlag, + unsigned flagLen) { + // Warn about an invalid flag. + auto Range = getSpecifierRange(startFlag, flagLen); + StringRef flag(startFlag, flagLen); + EmitFormatDiagnostic(S.PDiag(diag::warn_printf_invalid_objc_flag) << flag, + getLocationOfByte(startFlag), + /*IsStringLocation*/true, + Range, FixItHint::CreateRemoval(Range)); +} + +void CheckPrintfHandler::HandleObjCFlagsWithNonObjCConversion( + const char *flagsStart, const char *flagsEnd, const char *conversionPosition) { + // Warn about using '[...]' without a '@' conversion. + auto Range = getSpecifierRange(flagsStart, flagsEnd - flagsStart + 1); + auto diag = diag::warn_printf_ObjCflags_without_ObjCConversion; + EmitFormatDiagnostic(S.PDiag(diag) << StringRef(conversionPosition, 1), + getLocationOfByte(conversionPosition), + /*IsStringLocation*/true, + Range, FixItHint::CreateRemoval(Range)); +} + // Determines if the specified is a C++ class or struct containing // a member with the specified name and kind (e.g. a CXXMethodDecl named // "c_str()"). @@ -7173,8 +7240,8 @@ void AnalyzeImplicitConversions(Sema &S, Expr *OrigE, SourceLocation CC) { CC = E->getExprLoc(); BinaryOperator *BO = dyn_cast<BinaryOperator>(E); bool IsLogicalAndOperator = BO && BO->getOpcode() == BO_LAnd; - for (Stmt::child_range I = E->children(); I; ++I) { - Expr *ChildExpr = dyn_cast_or_null<Expr>(*I); + for (Stmt *SubStmt : E->children()) { + Expr *ChildExpr = dyn_cast_or_null<Expr>(SubStmt); if (!ChildExpr) continue; diff --git a/lib/Sema/SemaCodeComplete.cpp b/lib/Sema/SemaCodeComplete.cpp index ebb6bbcd3454..ff6a3eed8c25 100644 --- a/lib/Sema/SemaCodeComplete.cpp +++ b/lib/Sema/SemaCodeComplete.cpp @@ -1343,9 +1343,9 @@ static void AddTypeSpecifierResults(const LangOptions &LangOpts, } // Nullability - Results.AddResult(Result("__nonnull", CCP_Type)); - Results.AddResult(Result("__null_unspecified", CCP_Type)); - Results.AddResult(Result("__nullable", CCP_Type)); + 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, diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp index aa006b31fc89..6508d6f04bb2 100644 --- a/lib/Sema/SemaDecl.cpp +++ b/lib/Sema/SemaDecl.cpp @@ -1804,7 +1804,8 @@ static void filterNonConflictingPreviousDecls(Sema &S, NamedDecl *decl, LookupResult &previous){ // This is only interesting when modules are enabled. - if (!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility) + if ((!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility) || + !S.getLangOpts().ModulesHideInternalLinkage) return; // Empty sets are uninteresting. @@ -2471,17 +2472,18 @@ static void mergeParamDeclTypes(ParmVarDecl *NewParam, 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); + << DiagNullabilityKind( + *Newnullability, + ((NewParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) + != 0)) + << DiagNullabilityKind( + *Oldnullability, + ((OldParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) + != 0)); S.Diag(OldParam->getLocation(), diag::note_previous_declaration); } - } - else { + } else { QualType NewT = NewParam->getType(); NewT = S.Context.getAttributedType( AttributedType::getNullabilityAttrKind(*Oldnullability), @@ -3454,8 +3456,9 @@ void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) { New->isThisDeclarationADefinition() == VarDecl::Definition && (Def = Old->getDefinition())) { NamedDecl *Hidden = nullptr; - if (!hasVisibleDefinition(Def, &Hidden) && - (New->getDescribedVarTemplate() || + if (!hasVisibleDefinition(Def, &Hidden) && + (New->getFormalLinkage() == InternalLinkage || + New->getDescribedVarTemplate() || New->getNumTemplateParameterLists() || New->getDeclContext()->isDependentContext())) { // The previous definition is hidden, and multiple definitions are @@ -3577,6 +3580,23 @@ void Sema::setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TagFromDeclSpec->setTypedefNameForAnonDecl(NewTD); } +static unsigned GetDiagnosticTypeSpecifierID(DeclSpec::TST T) { + switch (T) { + case DeclSpec::TST_class: + return 0; + case DeclSpec::TST_struct: + return 1; + case DeclSpec::TST_interface: + return 2; + case DeclSpec::TST_union: + return 3; + case DeclSpec::TST_enum: + return 4; + default: + llvm_unreachable("unexpected type specifier"); + } +} + /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with /// no declarator (e.g. "struct foo;") is parsed. It also accepts template /// parameters to cope with template friend declarations. @@ -3626,10 +3646,7 @@ Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, // and definitions of functions and variables. if (Tag) Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag) - << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 : - DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 : - DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 : - DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4); + << GetDiagnosticTypeSpecifierID(DS.getTypeSpecType()); else Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators); // Don't emit warnings after this error. @@ -3656,11 +3673,7 @@ Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, // or an explicit specialization. // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either. Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier) - << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 : - DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 : - DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 : - DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4) - << SS.getRange(); + << GetDiagnosticTypeSpecifierID(DS.getTypeSpecType()) << SS.getRange(); return nullptr; } @@ -3808,16 +3821,10 @@ Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, TypeSpecType == DeclSpec::TST_interface || TypeSpecType == DeclSpec::TST_union || TypeSpecType == DeclSpec::TST_enum) { - AttributeList* attrs = DS.getAttributes().getList(); - while (attrs) { + for (AttributeList* attrs = DS.getAttributes().getList(); attrs; + attrs = attrs->getNext()) Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored) - << attrs->getName() - << (TypeSpecType == DeclSpec::TST_class ? 0 : - TypeSpecType == DeclSpec::TST_struct ? 1 : - TypeSpecType == DeclSpec::TST_union ? 2 : - TypeSpecType == DeclSpec::TST_interface ? 3 : 4); - attrs = attrs->getNext(); - } + << attrs->getName() << GetDiagnosticTypeSpecifierID(TypeSpecType); } } @@ -5518,6 +5525,19 @@ bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) { return true; } +/// \brief Returns true if given declaration is TU-scoped and externally +/// visible. +static bool isDeclTUScopedExternallyVisible(const Decl *D) { + if (auto *FD = dyn_cast<FunctionDecl>(D)) + return (FD->getDeclContext()->isTranslationUnit() || FD->isExternC()) && + FD->hasExternalFormalLinkage(); + else if (auto *VD = dyn_cast<VarDecl>(D)) + return (VD->getDeclContext()->isTranslationUnit() || VD->isExternC()) && + VD->hasExternalFormalLinkage(); + + llvm_unreachable("Unknown type of decl!"); +} + NamedDecl * Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, @@ -5942,7 +5962,8 @@ Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context, Label, 0)); - } else if (!ExtnameUndeclaredIdentifiers.empty()) { + } else if (!ExtnameUndeclaredIdentifiers.empty() && + isDeclTUScopedExternallyVisible(NewVD)) { llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier()); if (I != ExtnameUndeclaredIdentifiers.end()) { @@ -7181,6 +7202,11 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) { if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided()) NewFD->setPure(true); + + // C++ [class.union]p2 + // A union can have member functions, but not virtual functions. + if (isVirtual && Parent->isUnion()) + Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_in_union); } SetNestedNameSpecifier(NewFD, D); @@ -7464,7 +7490,8 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, StringLiteral *SE = cast<StringLiteral>(E); NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context, SE->getString(), 0)); - } else if (!ExtnameUndeclaredIdentifiers.empty()) { + } else if (!ExtnameUndeclaredIdentifiers.empty() && + isDeclTUScopedExternallyVisible(NewFD)) { llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier()); if (I != ExtnameUndeclaredIdentifiers.end()) { @@ -8769,18 +8796,10 @@ void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, } if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) { - // With declarators parsed the way they are, the parser cannot - // distinguish between a normal initializer and a pure-specifier. - // Thus this grotesque test. - IntegerLiteral *IL; - if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 && - Context.getCanonicalType(IL->getType()) == Context.IntTy) - CheckPureMethod(Method, Init->getSourceRange()); - else { - Diag(Method->getLocation(), diag::err_member_function_initialization) - << Method->getDeclName() << Init->getSourceRange(); - Method->setInvalidDecl(); - } + // Pure-specifiers are handled in ActOnPureSpecifier. + Diag(Method->getLocation(), diag::err_member_function_initialization) + << Method->getDeclName() << Init->getSourceRange(); + Method->setInvalidDecl(); return; } @@ -8943,7 +8962,8 @@ void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, if ((Def = VDecl->getDefinition()) && Def != VDecl) { NamedDecl *Hidden = nullptr; if (!hasVisibleDefinition(Def, &Hidden) && - (VDecl->getDescribedVarTemplate() || + (VDecl->getFormalLinkage() == InternalLinkage || + VDecl->getDescribedVarTemplate() || VDecl->getNumTemplateParameterLists() || VDecl->getDeclContext()->isDependentContext())) { // The previous definition is hidden, and multiple definitions are @@ -10364,7 +10384,8 @@ Sema::CheckForFunctionRedefinition(FunctionDecl *FD, // in this case? That may be necessary for functions that return local types // through a deduced return type, or instantiate templates with local types. if (!hasVisibleDefinition(Definition) && - (Definition->isInlineSpecified() || + (Definition->getFormalLinkage() == InternalLinkage || + Definition->isInlined() || Definition->getDescribedFunctionTemplate() || Definition->getNumTemplateParameterLists())) return; diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp index 43790c2f37e0..b8d083068593 100644 --- a/lib/Sema/SemaDeclAttr.cpp +++ b/lib/Sema/SemaDeclAttr.cpp @@ -20,6 +20,7 @@ #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/Mangle.h" +#include "clang/AST/ASTMutationListener.h" #include "clang/Basic/CharInfo.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" @@ -3990,6 +3991,34 @@ static void handleObjCRuntimeName(Sema &S, Decl *D, Attr.getAttributeSpellingListIndex())); } +// when a user wants to use objc_boxable with a union or struct +// but she doesn't have access to the declaration (legacy/third-party code) +// then she can 'enable' this feature via trick with a typedef +// e.g.: +// typedef struct __attribute((objc_boxable)) legacy_struct legacy_struct; +static void handleObjCBoxable(Sema &S, Decl *D, const AttributeList &Attr) { + bool notify = false; + + RecordDecl *RD = dyn_cast<RecordDecl>(D); + if (RD && RD->getDefinition()) { + RD = RD->getDefinition(); + notify = true; + } + + if (RD) { + ObjCBoxableAttr *BoxableAttr = ::new (S.Context) + ObjCBoxableAttr(Attr.getRange(), S.Context, + Attr.getAttributeSpellingListIndex()); + RD->addAttr(BoxableAttr); + if (notify) { + // we need to notify ASTReader/ASTWriter about + // modification of existing declaration + if (ASTMutationListener *L = S.getASTMutationListener()) + L->AddedAttributeToRecord(BoxableAttr, RD); + } + } +} + static void handleObjCOwnershipAttr(Sema &S, Decl *D, const AttributeList &Attr) { if (hasDeclarator(D)) return; @@ -4758,6 +4787,10 @@ static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, case AttributeList::AT_ObjCRuntimeName: handleObjCRuntimeName(S, D, Attr); break; + + case AttributeList::AT_ObjCBoxable: + handleObjCBoxable(S, D, Attr); + break; case AttributeList::AT_CFAuditedTransfer: handleCFAuditedTransferAttr(S, D, Attr); diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp index 7ed9bfcb9796..0d7cbf45e525 100644 --- a/lib/Sema/SemaDeclCXX.cpp +++ b/lib/Sema/SemaDeclCXX.cpp @@ -73,8 +73,8 @@ namespace { /// VisitExpr - Visit all of the children of this expression. bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) { bool IsInvalid = false; - for (Stmt::child_range I = Node->children(); I; ++I) - IsInvalid |= Visit(*I); + for (Stmt *SubStmt : Node->children()) + IsInvalid |= Visit(SubStmt); return IsInvalid; } @@ -1091,9 +1091,9 @@ CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S, break; if (!Cxx1yLoc.isValid()) Cxx1yLoc = S->getLocStart(); - for (Stmt::child_range Children = S->children(); Children; ++Children) - if (*Children && - !CheckConstexprFunctionStmt(SemaRef, Dcl, *Children, ReturnStmts, + for (Stmt *SubStmt : S->children()) + if (SubStmt && + !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts, Cxx1yLoc)) return false; return true; @@ -1106,9 +1106,9 @@ CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S, // mutation, we can reasonably allow them in C++11 as an extension. if (!Cxx1yLoc.isValid()) Cxx1yLoc = S->getLocStart(); - for (Stmt::child_range Children = S->children(); Children; ++Children) - if (*Children && - !CheckConstexprFunctionStmt(SemaRef, Dcl, *Children, ReturnStmts, + for (Stmt *SubStmt : S->children()) + if (SubStmt && + !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts, Cxx1yLoc)) return false; return true; @@ -2186,9 +2186,6 @@ Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D, assert(Member && "HandleField never returns null"); } } else { - assert(InitStyle == ICIS_NoInit || - D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static); - Member = HandleDeclarator(S, D, TemplateParameterLists); if (!Member) return nullptr; @@ -12890,8 +12887,7 @@ void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) { } static void SearchForReturnInStmt(Sema &Self, Stmt *S) { - for (Stmt::child_range CI = S->children(); CI; ++CI) { - Stmt *SubStmt = *CI; + for (Stmt *SubStmt : S->children()) { if (!SubStmt) continue; if (isa<ReturnStmt>(SubStmt)) @@ -13060,6 +13056,15 @@ bool Sema::CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange) { return true; } +void Sema::ActOnPureSpecifier(Decl *D, SourceLocation ZeroLoc) { + if (D->getFriendObjectKind()) + Diag(D->getLocation(), diag::err_pure_friend); + else if (auto *M = dyn_cast<CXXMethodDecl>(D)) + CheckPureMethod(M, ZeroLoc); + else + Diag(D->getLocation(), diag::err_illegal_initializer); +} + /// \brief Determine whether the given declaration is a static data member. static bool isStaticDataMember(const Decl *D) { if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D)) diff --git a/lib/Sema/SemaDeclObjC.cpp b/lib/Sema/SemaDeclObjC.cpp index 543566fdb7cc..d0b299877e0f 100644 --- a/lib/Sema/SemaDeclObjC.cpp +++ b/lib/Sema/SemaDeclObjC.cpp @@ -1400,16 +1400,20 @@ static bool CheckMethodOverrideReturn(Sema &S, !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)); + auto nullabilityMethodImpl = + *MethodImpl->getReturnType()->getNullability(S.Context); + auto nullabilityMethodDecl = + *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); + << DiagNullabilityKind( + nullabilityMethodImpl, + ((MethodImpl->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) + != 0)) + << DiagNullabilityKind( + nullabilityMethodDecl, + ((MethodDecl->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) + != 0)); S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration); } @@ -1486,15 +1490,17 @@ static bool CheckMethodOverrideParam(Sema &S, 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); + << DiagNullabilityKind( + *ImplTy->getNullability(S.Context), + ((ImplVar->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) + != 0)) + << DiagNullabilityKind( + *IfaceTy->getNullability(S.Context), + ((IfaceVar->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) + != 0)); + S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration); } if (S.Context.hasSameUnqualifiedType(ImplTy, IfaceTy)) return true; @@ -3184,8 +3190,8 @@ static QualType mergeTypeNullabilityForRedecl(Sema &S, SourceLocation loc, // Complain about mismatched nullability. S.Diag(loc, diag::err_nullability_conflicting) - << static_cast<unsigned>(*nullability) << usesCSKeyword - << static_cast<unsigned>(*prevNullability) << prevUsesCSKeyword; + << DiagNullabilityKind(*nullability, usesCSKeyword) + << DiagNullabilityKind(*prevNullability, prevUsesCSKeyword); return type; } diff --git a/lib/Sema/SemaExceptionSpec.cpp b/lib/Sema/SemaExceptionSpec.cpp index f3bcf76a21ba..2e3e63e00a32 100644 --- a/lib/Sema/SemaExceptionSpec.cpp +++ b/lib/Sema/SemaExceptionSpec.cpp @@ -837,11 +837,13 @@ bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, New->getLocation()); } -static CanThrowResult canSubExprsThrow(Sema &S, const Expr *CE) { - Expr *E = const_cast<Expr*>(CE); +static CanThrowResult canSubExprsThrow(Sema &S, const Expr *E) { CanThrowResult R = CT_Cannot; - for (Expr::child_range I = E->children(); I && R != CT_Can; ++I) - R = mergeCanThrow(R, S.canThrow(cast<Expr>(*I))); + for (const Stmt *SubStmt : E->children()) { + R = mergeCanThrow(R, S.canThrow(cast<Expr>(SubStmt))); + if (R == CT_Can) + break; + } return R; } diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp index b0bc231e7e6c..c023c8523a39 100644 --- a/lib/Sema/SemaExpr.cpp +++ b/lib/Sema/SemaExpr.cpp @@ -3689,7 +3689,7 @@ bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType, // C11 6.5.3.4/3, C++11 [expr.alignof]p3: // When alignof or _Alignof is applied to an array type, the result // is the alignment of the element type. - if (ExprKind == UETT_AlignOf) + if (ExprKind == UETT_AlignOf || ExprKind == UETT_OpenMPRequiredSimdAlign) ExprType = Context.getBaseElementType(ExprType); if (ExprKind == UETT_VecStep) @@ -3824,6 +3824,9 @@ Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc, isInvalid = CheckAlignOfExpr(*this, E); } else if (ExprKind == UETT_VecStep) { isInvalid = CheckVecStepExpr(E); + } else if (ExprKind == UETT_OpenMPRequiredSimdAlign) { + Diag(E->getExprLoc(), diag::err_openmp_default_simd_align_expr); + isInvalid = true; } else if (E->refersToBitField()) { // C99 6.5.3.4p1. Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) << 0; isInvalid = true; @@ -4314,7 +4317,6 @@ Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, SourceLocation RParenLoc, bool IsExecConfig) { // Bail out early if calling a builtin with custom typechecking. - // We don't need to do this in the if (FDecl) if (unsigned ID = FDecl->getBuiltinID()) if (Context.BuiltinInfo.hasCustomTypechecking(ID)) @@ -4938,6 +4940,17 @@ Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, TheCall = new (Context) CallExpr(Context, Fn, Args, Context.BoolTy, VK_RValue, RParenLoc); + if (!getLangOpts().CPlusPlus) { + // C cannot always handle TypoExpr nodes in builtin calls and direct + // function calls as their argument checking don't necessarily handle + // dependent types properly, so make sure any TypoExprs have been + // dealt with. + ExprResult Result = CorrectDelayedTyposInExpr(TheCall); + if (!Result.isUsable()) return ExprError(); + TheCall = dyn_cast<CallExpr>(Result.get()); + if (!TheCall) return Result; + } + // Bail out early if calling a builtin with custom typechecking. if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID)) return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall); @@ -12742,6 +12755,7 @@ bool Sema::tryCaptureVariable( bool Nested = false; bool Explicit = (Kind != TryCapture_Implicit); unsigned FunctionScopesIndex = MaxFunctionScopesIndex; + unsigned OpenMPLevel = 0; do { // Only block literals, captured statements, and lambda expressions can // capture; other scopes don't work. @@ -12768,6 +12782,20 @@ bool Sema::tryCaptureVariable( if (isVariableAlreadyCapturedInScopeInfo(CSI, Var, Nested, CaptureType, DeclRefType)) break; + if (getLangOpts().OpenMP) { + if (auto *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) { + // OpenMP private variables should not be captured in outer scope, so + // just break here. + if (RSI->CapRegionKind == CR_OpenMP) { + if (isOpenMPPrivateVar(Var, OpenMPLevel)) { + Nested = true; + CaptureType = Context.getLValueReferenceType(DeclRefType); + break; + } + ++OpenMPLevel; + } + } + } // If we are instantiating a generic lambda call operator body, // we do not want to capture new variables. What was captured // during either a lambdas transformation or initial parsing diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp index 6c839f356fdc..6608d7c1f061 100644 --- a/lib/Sema/SemaExprCXX.cpp +++ b/lib/Sema/SemaExprCXX.cpp @@ -6506,6 +6506,11 @@ public: // with the same edit length that pass all the checks and filters. // TODO: Properly handle various permutations of possible corrections when // there is more than one potentially ambiguous typo correction. + // Also, disable typo correction while attempting the transform when + // handling potentially ambiguous typo corrections as any new TypoExprs will + // have been introduced by the application of one of the correction + // candidates and add little to no value if corrected. + SemaRef.DisableTypoCorrection = true; while (!AmbiguousTypoExprs.empty()) { auto TE = AmbiguousTypoExprs.back(); auto Cached = TransformCache[TE]; @@ -6522,6 +6527,7 @@ public: State.Consumer->restoreSavedPosition(); TransformCache[TE] = Cached; } + SemaRef.DisableTypoCorrection = false; // Ensure that all of the TypoExprs within the current Expr have been found. if (!Res.isUsable()) diff --git a/lib/Sema/SemaExprObjC.cpp b/lib/Sema/SemaExprObjC.cpp index 9947fad70dd3..c52b6f55a957 100644 --- a/lib/Sema/SemaExprObjC.cpp +++ b/lib/Sema/SemaExprObjC.cpp @@ -563,7 +563,6 @@ ExprResult Sema::BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) { // Look for the appropriate method within NSNumber. BoxingMethod = getNSNumberFactoryMethod(*this, SR.getBegin(), ValueType); BoxedType = NSNumberPointer; - } else if (const EnumType *ET = ValueType->getAs<EnumType>()) { if (!ET->getDecl()->isComplete()) { Diag(SR.getBegin(), diag::err_objc_incomplete_boxed_expression_type) @@ -574,6 +573,109 @@ ExprResult Sema::BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) { BoxingMethod = getNSNumberFactoryMethod(*this, SR.getBegin(), ET->getDecl()->getIntegerType()); BoxedType = NSNumberPointer; + } else if (ValueType->isObjCBoxableRecordType()) { + // Support for structure types, that marked as objc_boxable + // struct __attribute__((objc_boxable)) s { ... }; + + // Look up the NSValue class, if we haven't done so already. It's cached + // in the Sema instance. + if (!NSValueDecl) { + IdentifierInfo *NSValueId = + NSAPIObj->getNSClassId(NSAPI::ClassId_NSValue); + NamedDecl *IF = LookupSingleName(TUScope, NSValueId, + SR.getBegin(), Sema::LookupOrdinaryName); + NSValueDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF); + if (!NSValueDecl) { + if (getLangOpts().DebuggerObjCLiteral) { + // Create a stub definition of NSValue. + DeclContext *TU = Context.getTranslationUnitDecl(); + NSValueDecl = ObjCInterfaceDecl::Create(Context, TU, + SourceLocation(), NSValueId, + nullptr, SourceLocation()); + } else { + // Otherwise, require a declaration of NSValue. + Diag(SR.getBegin(), diag::err_undeclared_nsvalue); + return ExprError(); + } + } else if (!NSValueDecl->hasDefinition()) { + Diag(SR.getBegin(), diag::err_undeclared_nsvalue); + return ExprError(); + } + + // generate the pointer to NSValue type. + QualType NSValueObject = Context.getObjCInterfaceType(NSValueDecl); + NSValuePointer = Context.getObjCObjectPointerType(NSValueObject); + } + + if (!ValueWithBytesObjCTypeMethod) { + IdentifierInfo *II[] = { + &Context.Idents.get("valueWithBytes"), + &Context.Idents.get("objCType") + }; + Selector ValueWithBytesObjCType = Context.Selectors.getSelector(2, II); + + // Look for the appropriate method within NSValue. + BoxingMethod = NSValueDecl->lookupClassMethod(ValueWithBytesObjCType); + if (!BoxingMethod && getLangOpts().DebuggerObjCLiteral) { + // Debugger needs to work even if NSValue hasn't been defined. + TypeSourceInfo *ReturnTInfo = nullptr; + ObjCMethodDecl *M = ObjCMethodDecl::Create( + Context, + SourceLocation(), + SourceLocation(), + ValueWithBytesObjCType, + NSValuePointer, + ReturnTInfo, + NSValueDecl, + /*isInstance=*/false, + /*isVariadic=*/false, + /*isPropertyAccessor=*/false, + /*isImplicitlyDeclared=*/true, + /*isDefined=*/false, + ObjCMethodDecl::Required, + /*HasRelatedResultType=*/false); + + SmallVector<ParmVarDecl *, 2> Params; + + ParmVarDecl *bytes = + ParmVarDecl::Create(Context, M, + SourceLocation(), SourceLocation(), + &Context.Idents.get("bytes"), + Context.VoidPtrTy.withConst(), + /*TInfo=*/nullptr, + SC_None, nullptr); + Params.push_back(bytes); + + QualType ConstCharType = Context.CharTy.withConst(); + ParmVarDecl *type = + ParmVarDecl::Create(Context, M, + SourceLocation(), SourceLocation(), + &Context.Idents.get("type"), + Context.getPointerType(ConstCharType), + /*TInfo=*/nullptr, + SC_None, nullptr); + Params.push_back(type); + + M->setMethodParams(Context, Params, None); + BoxingMethod = M; + } + + if (!validateBoxingMethod(*this, SR.getBegin(), NSValueDecl, + ValueWithBytesObjCType, BoxingMethod)) + return ExprError(); + + ValueWithBytesObjCTypeMethod = BoxingMethod; + } + + if (!ValueType.isTriviallyCopyableType(Context)) { + Diag(SR.getBegin(), + diag::err_objc_non_trivially_copyable_boxed_expression_type) + << ValueType << ValueExpr->getSourceRange(); + return ExprError(); + } + + BoxingMethod = ValueWithBytesObjCTypeMethod; + BoxedType = NSValuePointer; } if (!BoxingMethod) { @@ -582,13 +684,22 @@ ExprResult Sema::BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) { return ExprError(); } - // Convert the expression to the type that the parameter requires. - ParmVarDecl *ParamDecl = BoxingMethod->parameters()[0]; - InitializedEntity Entity = InitializedEntity::InitializeParameter(Context, - ParamDecl); - ExprResult ConvertedValueExpr = PerformCopyInitialization(Entity, - SourceLocation(), - ValueExpr); + DiagnoseUseOfDecl(BoxingMethod, SR.getBegin()); + + ExprResult ConvertedValueExpr; + if (ValueType->isObjCBoxableRecordType()) { + InitializedEntity IE = InitializedEntity::InitializeTemporary(ValueType); + ConvertedValueExpr = PerformCopyInitialization(IE, ValueExpr->getExprLoc(), + ValueExpr); + } else { + // Convert the expression to the type that the parameter requires. + ParmVarDecl *ParamDecl = BoxingMethod->parameters()[0]; + InitializedEntity IE = InitializedEntity::InitializeParameter(Context, + ParamDecl); + ConvertedValueExpr = PerformCopyInitialization(IE, SourceLocation(), + ValueExpr); + } + if (ConvertedValueExpr.isInvalid()) return ExprError(); ValueExpr = ConvertedValueExpr.get(); diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp index 821d7f64b253..f0f7cb93d339 100644 --- a/lib/Sema/SemaInit.cpp +++ b/lib/Sema/SemaInit.cpp @@ -5088,10 +5088,8 @@ void InitializationSequence::InitializeFrom(Sema &S, } InitializationSequence::~InitializationSequence() { - for (SmallVectorImpl<Step>::iterator Step = Steps.begin(), - StepEnd = Steps.end(); - Step != StepEnd; ++Step) - Step->Destroy(); + for (auto &S : Steps) + S.Destroy(); } //===----------------------------------------------------------------------===// diff --git a/lib/Sema/SemaObjCProperty.cpp b/lib/Sema/SemaObjCProperty.cpp index 87fb5b6913a3..0f88abcdf9ea 100644 --- a/lib/Sema/SemaObjCProperty.cpp +++ b/lib/Sema/SemaObjCProperty.cpp @@ -1758,7 +1758,7 @@ void Sema::DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl, } } -void Sema::diagnoseNullResettableSynthesizedSetters(ObjCImplDecl *impDecl) { +void Sema::diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl) { for (const auto *propertyImpl : impDecl->property_impls()) { const auto *property = propertyImpl->getPropertyDecl(); @@ -2025,7 +2025,7 @@ void Sema::ProcessPropertyDecl(ObjCPropertyDecl *property, if (property->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_null_resettable) { QualType modifiedTy = resultTy; - if (auto nullability = AttributedType::stripOuterNullability(modifiedTy)){ + if (auto nullability = AttributedType::stripOuterNullability(modifiedTy)) { if (*nullability == NullabilityKind::Unspecified) resultTy = Context.getAttributedType(AttributedType::attr_nonnull, modifiedTy, modifiedTy); diff --git a/lib/Sema/SemaOpenMP.cpp b/lib/Sema/SemaOpenMP.cpp index e609fcf1d9be..867cb9f3c830 100644 --- a/lib/Sema/SemaOpenMP.cpp +++ b/lib/Sema/SemaOpenMP.cpp @@ -95,19 +95,20 @@ private: Scope *CurScope; SourceLocation ConstructLoc; bool OrderedRegion; + bool NowaitRegion; unsigned CollapseNumber; SourceLocation InnerTeamsRegionLoc; SharingMapTy(OpenMPDirectiveKind DKind, DeclarationNameInfo Name, Scope *CurScope, SourceLocation Loc) : SharingMap(), AlignedMap(), LCVSet(), DefaultAttr(DSA_unspecified), Directive(DKind), DirectiveName(std::move(Name)), CurScope(CurScope), - ConstructLoc(Loc), OrderedRegion(false), CollapseNumber(1), - InnerTeamsRegionLoc() {} + ConstructLoc(Loc), OrderedRegion(false), NowaitRegion(false), + CollapseNumber(1), InnerTeamsRegionLoc() {} SharingMapTy() : SharingMap(), AlignedMap(), LCVSet(), DefaultAttr(DSA_unspecified), Directive(OMPD_unknown), DirectiveName(), CurScope(nullptr), - ConstructLoc(), OrderedRegion(false), CollapseNumber(1), - InnerTeamsRegionLoc() {} + ConstructLoc(), OrderedRegion(false), NowaitRegion(false), + CollapseNumber(1), InnerTeamsRegionLoc() {} }; typedef SmallVector<SharingMapTy, 64> StackTy; @@ -116,7 +117,7 @@ private: StackTy Stack; /// \brief true, if check for DSA must be from parent directive, false, if /// from current directive. - bool FromParent; + OpenMPClauseKind ClauseKindMode; Sema &SemaRef; typedef SmallVector<SharingMapTy, 8>::reverse_iterator reverse_iterator; @@ -127,10 +128,11 @@ private: bool isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter); public: - explicit DSAStackTy(Sema &S) : Stack(1), FromParent(false), SemaRef(S) {} + explicit DSAStackTy(Sema &S) + : Stack(1), ClauseKindMode(OMPC_unknown), SemaRef(S) {} - bool isFromParent() const { return FromParent; } - void setFromParent(bool Flag) { FromParent = Flag; } + bool isClauseParsingMode() const { return ClauseKindMode != OMPC_unknown; } + void setClauseParsingMode(OpenMPClauseKind K) { ClauseKindMode = K; } void push(OpenMPDirectiveKind DKind, const DeclarationNameInfo &DirName, Scope *CurScope, SourceLocation Loc) { @@ -175,6 +177,12 @@ public: DSAVarData hasInnermostDSA(VarDecl *D, ClausesPredicate CPred, DirectivesPredicate DPred, bool FromParent); + /// \brief Checks if the specified variables has explicit data-sharing + /// attributes which match specified \a CPred predicate at the specified + /// OpenMP region. + bool hasExplicitDSA(VarDecl *D, + const llvm::function_ref<bool(OpenMPClauseKind)> &CPred, + unsigned Level); /// \brief Finds a directive which matches specified \a DPred predicate. template <class NamedDirectivesPredicate> bool hasDirective(NamedDirectivesPredicate DPred, bool FromParent); @@ -225,6 +233,17 @@ public: return Stack[Stack.size() - 2].OrderedRegion; return false; } + /// \brief Marks current region as nowait (it has a 'nowait' clause). + void setNowaitRegion(bool IsNowait = true) { + Stack.back().NowaitRegion = IsNowait; + } + /// \brief Returns true, if parent region is nowait (has associated + /// 'nowait' clause), false - otherwise. + bool isParentNowaitRegion() const { + if (Stack.size() > 2) + return Stack[Stack.size() - 2].NowaitRegion; + return false; + } /// \brief Set collapse value for the region. void setCollapseNumber(unsigned Val) { Stack.back().CollapseNumber = Val; } @@ -589,6 +608,23 @@ DSAStackTy::hasInnermostDSA(VarDecl *D, ClausesPredicate CPred, return DSAVarData(); } +bool DSAStackTy::hasExplicitDSA( + VarDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> &CPred, + unsigned Level) { + if (CPred(ClauseKindMode)) + return true; + if (isClauseParsingMode()) + ++Level; + D = D->getCanonicalDecl(); + auto StartI = Stack.rbegin(); + auto EndI = std::prev(Stack.rend()); + if (std::distance(StartI, EndI) <= (int)Level) + return false; + std::advance(StartI, Level); + return (StartI->SharingMap.count(D) > 0) && StartI->SharingMap[D].RefExpr && + CPred(StartI->SharingMap[D].Attributes); +} + template <class NamedDirectivesPredicate> bool DSAStackTy::hasDirective(NamedDirectivesPredicate DPred, bool FromParent) { auto StartI = std::next(Stack.rbegin()); @@ -617,16 +653,22 @@ bool Sema::IsOpenMPCapturedVar(VarDecl *VD) { (VD->hasLocalStorage() && isParallelOrTaskRegion(DSAStack->getCurrentDirective()))) return true; - auto DVarPrivate = DSAStack->getTopDSA(VD, DSAStack->isFromParent()); + auto DVarPrivate = DSAStack->getTopDSA(VD, DSAStack->isClauseParsingMode()); if (DVarPrivate.CKind != OMPC_unknown && isOpenMPPrivate(DVarPrivate.CKind)) return true; DVarPrivate = DSAStack->hasDSA(VD, isOpenMPPrivate, MatchesAlways(), - DSAStack->isFromParent()); + DSAStack->isClauseParsingMode()); return DVarPrivate.CKind != OMPC_unknown; } return false; } +bool Sema::isOpenMPPrivateVar(VarDecl *VD, unsigned Level) { + assert(LangOpts.OpenMP && "OpenMP is not allowed"); + return DSAStack->hasExplicitDSA( + VD, [](OpenMPClauseKind K) -> bool { return K == OMPC_private; }, Level); +} + void Sema::DestroyDataSharingAttributesStack() { delete DSAStack; } void Sema::StartOpenMPDSABlock(OpenMPDirectiveKind DKind, @@ -636,12 +678,12 @@ void Sema::StartOpenMPDSABlock(OpenMPDirectiveKind DKind, PushExpressionEvaluationContext(PotentiallyEvaluated); } -void Sema::StartOpenMPClauses() { - DSAStack->setFromParent(/*Flag=*/true); +void Sema::StartOpenMPClause(OpenMPClauseKind K) { + DSAStack->setClauseParsingMode(K); } -void Sema::EndOpenMPClauses() { - DSAStack->setFromParent(/*Flag=*/false); +void Sema::EndOpenMPClause() { + DSAStack->setClauseParsingMode(/*K=*/OMPC_unknown); } void Sema::EndOpenMPDSABlock(Stmt *CurDirective) { @@ -1282,6 +1324,8 @@ void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) { case OMPD_taskyield: case OMPD_barrier: case OMPD_taskwait: + case OMPD_cancellation_point: + case OMPD_cancel: case OMPD_flush: llvm_unreachable("OpenMP Directive is not allowed"); case OMPD_unknown: @@ -1322,6 +1366,7 @@ StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S, static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, OpenMPDirectiveKind CurrentRegion, const DeclarationNameInfo &CurrentName, + OpenMPDirectiveKind CancelRegion, SourceLocation StartLoc) { // Allowed nesting of constructs // +------------------+-----------------+------------------------------------+ @@ -1349,6 +1394,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | parallel | atomic | * | // | parallel | target | * | // | parallel | teams | + | + // | parallel | cancellation | | + // | | point | ! | + // | parallel | cancel | ! | // +------------------+-----------------+------------------------------------+ // | for | parallel | * | // | for | for | + | @@ -1372,6 +1420,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | for | atomic | * | // | for | target | * | // | for | teams | + | + // | for | cancellation | | + // | | point | ! | + // | for | cancel | ! | // +------------------+-----------------+------------------------------------+ // | master | parallel | * | // | master | for | + | @@ -1395,6 +1446,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | master | atomic | * | // | master | target | * | // | master | teams | + | + // | master | cancellation | | + // | | point | | + // | master | cancel | | // +------------------+-----------------+------------------------------------+ // | critical | parallel | * | // | critical | for | + | @@ -1417,6 +1471,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | critical | atomic | * | // | critical | target | * | // | critical | teams | + | + // | critical | cancellation | | + // | | point | | + // | critical | cancel | | // +------------------+-----------------+------------------------------------+ // | simd | parallel | | // | simd | for | | @@ -1440,6 +1497,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | simd | atomic | | // | simd | target | | // | simd | teams | | + // | simd | cancellation | | + // | | point | | + // | simd | cancel | | // +------------------+-----------------+------------------------------------+ // | for simd | parallel | | // | for simd | for | | @@ -1463,6 +1523,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | for simd | atomic | | // | for simd | target | | // | for simd | teams | | + // | for simd | cancellation | | + // | | point | | + // | for simd | cancel | | // +------------------+-----------------+------------------------------------+ // | parallel for simd| parallel | | // | parallel for simd| for | | @@ -1486,6 +1549,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | parallel for simd| atomic | | // | parallel for simd| target | | // | parallel for simd| teams | | + // | parallel for simd| cancellation | | + // | | point | | + // | parallel for simd| cancel | | // +------------------+-----------------+------------------------------------+ // | sections | parallel | * | // | sections | for | + | @@ -1509,6 +1575,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | sections | atomic | * | // | sections | target | * | // | sections | teams | + | + // | sections | cancellation | | + // | | point | ! | + // | sections | cancel | ! | // +------------------+-----------------+------------------------------------+ // | section | parallel | * | // | section | for | + | @@ -1532,6 +1601,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | section | atomic | * | // | section | target | * | // | section | teams | + | + // | section | cancellation | | + // | | point | ! | + // | section | cancel | ! | // +------------------+-----------------+------------------------------------+ // | single | parallel | * | // | single | for | + | @@ -1555,6 +1627,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | single | atomic | * | // | single | target | * | // | single | teams | + | + // | single | cancellation | | + // | | point | | + // | single | cancel | | // +------------------+-----------------+------------------------------------+ // | parallel for | parallel | * | // | parallel for | for | + | @@ -1578,6 +1653,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | parallel for | atomic | * | // | parallel for | target | * | // | parallel for | teams | + | + // | parallel for | cancellation | | + // | | point | ! | + // | parallel for | cancel | ! | // +------------------+-----------------+------------------------------------+ // | parallel sections| parallel | * | // | parallel sections| for | + | @@ -1601,6 +1679,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | parallel sections| atomic | * | // | parallel sections| target | * | // | parallel sections| teams | + | + // | parallel sections| cancellation | | + // | | point | ! | + // | parallel sections| cancel | ! | // +------------------+-----------------+------------------------------------+ // | task | parallel | * | // | task | for | + | @@ -1624,6 +1705,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | task | atomic | * | // | task | target | * | // | task | teams | + | + // | task | cancellation | | + // | | point | ! | + // | task | cancel | ! | // +------------------+-----------------+------------------------------------+ // | ordered | parallel | * | // | ordered | for | + | @@ -1647,6 +1731,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | ordered | atomic | * | // | ordered | target | * | // | ordered | teams | + | + // | ordered | cancellation | | + // | | point | | + // | ordered | cancel | | // +------------------+-----------------+------------------------------------+ // | atomic | parallel | | // | atomic | for | | @@ -1670,6 +1757,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | atomic | atomic | | // | atomic | target | | // | atomic | teams | | + // | atomic | cancellation | | + // | | point | | + // | atomic | cancel | | // +------------------+-----------------+------------------------------------+ // | target | parallel | * | // | target | for | * | @@ -1693,6 +1783,9 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | target | atomic | * | // | target | target | * | // | target | teams | * | + // | target | cancellation | | + // | | point | | + // | target | cancel | | // +------------------+-----------------+------------------------------------+ // | teams | parallel | * | // | teams | for | + | @@ -1710,12 +1803,15 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // | teams | taskyield | + | // | teams | barrier | + | // | teams | taskwait | + | - // | teams | taskgroup | + | + // | teams | taskgroup | + | // | teams | flush | + | // | teams | ordered | + | // | teams | atomic | + | // | teams | target | + | // | teams | teams | + | + // | teams | cancellation | | + // | | point | | + // | teams | cancel | | // +------------------+-----------------+------------------------------------+ if (Stack->getCurScope()) { auto ParentRegion = Stack->getParentDirective(); @@ -1757,7 +1853,26 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, // called from OpenMP regions with the required preconditions). if (ParentRegion == OMPD_unknown) return false; - if (CurrentRegion == OMPD_master) { + if (CurrentRegion == OMPD_cancellation_point || + CurrentRegion == OMPD_cancel) { + // OpenMP [2.16, Nesting of Regions] + // A cancellation point construct for which construct-type-clause is + // taskgroup must be nested inside a task construct. A cancellation + // point construct for which construct-type-clause is not taskgroup must + // be closely nested inside an OpenMP construct that matches the type + // specified in construct-type-clause. + // A cancel construct for which construct-type-clause is taskgroup must be + // nested inside a task construct. A cancel construct for which + // construct-type-clause is not taskgroup must be closely nested inside an + // OpenMP construct that matches the type specified in + // construct-type-clause. + NestingProhibited = + !((CancelRegion == OMPD_parallel && ParentRegion == OMPD_parallel) || + (CancelRegion == OMPD_for && ParentRegion == OMPD_for) || + (CancelRegion == OMPD_taskgroup && ParentRegion == OMPD_task) || + (CancelRegion == OMPD_sections && + (ParentRegion == OMPD_section || ParentRegion == OMPD_sections))); + } else if (CurrentRegion == OMPD_master) { // OpenMP [2.16, Nesting of Regions] // A master region may not be closely nested inside a worksharing, // atomic, or explicit task region. @@ -1847,14 +1962,13 @@ static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, return false; } -StmtResult Sema::ActOnOpenMPExecutableDirective(OpenMPDirectiveKind Kind, - const DeclarationNameInfo &DirName, - ArrayRef<OMPClause *> Clauses, - Stmt *AStmt, - SourceLocation StartLoc, - SourceLocation EndLoc) { +StmtResult Sema::ActOnOpenMPExecutableDirective( + OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, + OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses, + Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) { StmtResult Res = StmtError(); - if (CheckNestingOfRegions(*this, DSAStack, Kind, DirName, StartLoc)) + if (CheckNestingOfRegions(*this, DSAStack, Kind, DirName, CancelRegion, + StartLoc)) return StmtError(); llvm::SmallVector<OMPClause *, 8> ClausesWithImplicit; @@ -1988,6 +2102,20 @@ StmtResult Sema::ActOnOpenMPExecutableDirective(OpenMPDirectiveKind Kind, Res = ActOnOpenMPTargetDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc); break; + case OMPD_cancellation_point: + assert(ClausesWithImplicit.empty() && + "No clauses are allowed for 'omp cancellation point' directive"); + assert(AStmt == nullptr && "No associated statement allowed for 'omp " + "cancellation point' directive"); + Res = ActOnOpenMPCancellationPointDirective(StartLoc, EndLoc, CancelRegion); + break; + case OMPD_cancel: + assert(ClausesWithImplicit.empty() && + "No clauses are allowed for 'omp cancel' directive"); + assert(AStmt == nullptr && + "No associated statement allowed for 'omp cancel' directive"); + Res = ActOnOpenMPCancelDirective(StartLoc, EndLoc, CancelRegion); + break; case OMPD_threadprivate: llvm_unreachable("OpenMP Directive is not allowed"); case OMPD_unknown: @@ -3216,8 +3344,7 @@ StmtResult Sema::ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses, return StmtError(); // All associated statements must be '#pragma omp section' except for // the first one. - for (++S; S; ++S) { - auto SectionStmt = *S; + for (Stmt *SectionStmt : ++S) { if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) { if (SectionStmt) Diag(SectionStmt->getLocStart(), @@ -3375,8 +3502,7 @@ Sema::ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses, return StmtError(); // All associated statements must be '#pragma omp section' except for // the first one. - for (++S; S; ++S) { - auto SectionStmt = *S; + for (Stmt *SectionStmt : ++S) { if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) { if (SectionStmt) Diag(SectionStmt->getLocStart(), @@ -4174,6 +4300,48 @@ StmtResult Sema::ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses, return OMPTeamsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt); } +StmtResult +Sema::ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc, + SourceLocation EndLoc, + OpenMPDirectiveKind CancelRegion) { + if (CancelRegion != OMPD_parallel && CancelRegion != OMPD_for && + CancelRegion != OMPD_sections && CancelRegion != OMPD_taskgroup) { + Diag(StartLoc, diag::err_omp_wrong_cancel_region) + << getOpenMPDirectiveName(CancelRegion); + return StmtError(); + } + if (DSAStack->isParentNowaitRegion()) { + Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 0; + return StmtError(); + } + if (DSAStack->isParentOrderedRegion()) { + Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 0; + return StmtError(); + } + return OMPCancellationPointDirective::Create(Context, StartLoc, EndLoc, + CancelRegion); +} + +StmtResult Sema::ActOnOpenMPCancelDirective(SourceLocation StartLoc, + SourceLocation EndLoc, + OpenMPDirectiveKind CancelRegion) { + if (CancelRegion != OMPD_parallel && CancelRegion != OMPD_for && + CancelRegion != OMPD_sections && CancelRegion != OMPD_taskgroup) { + Diag(StartLoc, diag::err_omp_wrong_cancel_region) + << getOpenMPDirectiveName(CancelRegion); + return StmtError(); + } + if (DSAStack->isParentNowaitRegion()) { + Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 1; + return StmtError(); + } + if (DSAStack->isParentOrderedRegion()) { + Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 1; + return StmtError(); + } + return OMPCancelDirective::Create(Context, StartLoc, EndLoc, CancelRegion); +} + OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr, SourceLocation StartLoc, SourceLocation LParenLoc, @@ -4218,6 +4386,7 @@ OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr, case OMPC_update: case OMPC_capture: case OMPC_seq_cst: + case OMPC_depend: case OMPC_unknown: llvm_unreachable("Clause is not allowed."); } @@ -4432,6 +4601,7 @@ OMPClause *Sema::ActOnOpenMPSimpleClause( case OMPC_update: case OMPC_capture: case OMPC_seq_cst: + case OMPC_depend: case OMPC_unknown: llvm_unreachable("Clause is not allowed."); } @@ -4552,6 +4722,7 @@ OMPClause *Sema::ActOnOpenMPSingleExprWithArgClause( case OMPC_update: case OMPC_capture: case OMPC_seq_cst: + case OMPC_depend: case OMPC_unknown: llvm_unreachable("Clause is not allowed."); } @@ -4674,6 +4845,7 @@ OMPClause *Sema::ActOnOpenMPClause(OpenMPClauseKind Kind, case OMPC_proc_bind: case OMPC_threadprivate: case OMPC_flush: + case OMPC_depend: case OMPC_unknown: llvm_unreachable("Clause is not allowed."); } @@ -4688,6 +4860,7 @@ OMPClause *Sema::ActOnOpenMPOrderedClause(SourceLocation StartLoc, OMPClause *Sema::ActOnOpenMPNowaitClause(SourceLocation StartLoc, SourceLocation EndLoc) { + DSAStack->setNowaitRegion(); return new (Context) OMPNowaitClause(StartLoc, EndLoc); } @@ -4730,7 +4903,8 @@ OMPClause *Sema::ActOnOpenMPVarListClause( OpenMPClauseKind Kind, ArrayRef<Expr *> VarList, Expr *TailExpr, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, - const DeclarationNameInfo &ReductionId) { + const DeclarationNameInfo &ReductionId, OpenMPDependClauseKind DepKind, + SourceLocation DepLoc) { OMPClause *Res = nullptr; switch (Kind) { case OMPC_private: @@ -4766,6 +4940,10 @@ OMPClause *Sema::ActOnOpenMPVarListClause( case OMPC_flush: Res = ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc, EndLoc); break; + case OMPC_depend: + Res = ActOnOpenMPDependClause(DepKind, DepLoc, ColonLoc, VarList, StartLoc, + LParenLoc, EndLoc); + break; case OMPC_if: case OMPC_final: case OMPC_num_threads: @@ -6316,3 +6494,66 @@ OMPClause *Sema::ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList, return OMPFlushClause::Create(Context, StartLoc, LParenLoc, EndLoc, VarList); } +OMPClause * +Sema::ActOnOpenMPDependClause(OpenMPDependClauseKind DepKind, + SourceLocation DepLoc, SourceLocation ColonLoc, + ArrayRef<Expr *> VarList, SourceLocation StartLoc, + SourceLocation LParenLoc, SourceLocation EndLoc) { + if (DepKind == OMPC_DEPEND_unknown) { + std::string Values; + std::string Sep(", "); + for (unsigned i = 0; i < OMPC_DEPEND_unknown; ++i) { + Values += "'"; + Values += getOpenMPSimpleClauseTypeName(OMPC_depend, i); + Values += "'"; + switch (i) { + case OMPC_DEPEND_unknown - 2: + Values += " or "; + break; + case OMPC_DEPEND_unknown - 1: + break; + default: + Values += Sep; + break; + } + } + Diag(DepLoc, diag::err_omp_unexpected_clause_value) + << Values << getOpenMPClauseName(OMPC_depend); + return nullptr; + } + SmallVector<Expr *, 8> Vars; + for (auto &RefExpr : VarList) { + assert(RefExpr && "NULL expr in OpenMP shared clause."); + if (isa<DependentScopeDeclRefExpr>(RefExpr)) { + // It will be analyzed later. + Vars.push_back(RefExpr); + continue; + } + + SourceLocation ELoc = RefExpr->getExprLoc(); + // OpenMP [2.11.1.1, Restrictions, p.3] + // A variable that is part of another variable (such as a field of a + // structure) but is not an array element or an array section cannot appear + // in a depend clause. + auto *SimpleExpr = RefExpr->IgnoreParenCasts(); + DeclRefExpr *DE = dyn_cast<DeclRefExpr>(SimpleExpr); + ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(SimpleExpr); + if (!RefExpr->IgnoreParenImpCasts()->isLValue() || (!ASE && !DE) || + (DE && !isa<VarDecl>(DE->getDecl())) || + (ASE && !ASE->getBase()->getType()->isAnyPointerType() && + !ASE->getBase()->getType()->isArrayType())) { + Diag(ELoc, diag::err_omp_expected_var_name_or_array_item) + << RefExpr->getSourceRange(); + continue; + } + + Vars.push_back(RefExpr->IgnoreParenImpCasts()); + } + + if (Vars.empty()) + return nullptr; + + return OMPDependClause::Create(Context, StartLoc, LParenLoc, EndLoc, DepKind, + DepLoc, ColonLoc, Vars); +} + diff --git a/lib/Sema/SemaStmt.cpp b/lib/Sema/SemaStmt.cpp index 50e4345216a6..6fca974d5b36 100644 --- a/lib/Sema/SemaStmt.cpp +++ b/lib/Sema/SemaStmt.cpp @@ -495,6 +495,7 @@ Sema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, Decl *CondVar, if (CondVar) { ConditionVar = cast<VarDecl>(CondVar); CondResult = CheckConditionVariable(ConditionVar, IfLoc, true); + CondResult = ActOnFinishFullExpr(CondResult.get(), IfLoc); if (CondResult.isInvalid()) return StmtError(); } @@ -649,12 +650,10 @@ Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, Expr *Cond, if (CondResult.isInvalid()) return StmtError(); Cond = CondResult.get(); - if (!CondVar) { - CondResult = ActOnFinishFullExpr(Cond, SwitchLoc); - if (CondResult.isInvalid()) - return StmtError(); - Cond = CondResult.get(); - } + CondResult = ActOnFinishFullExpr(Cond, SwitchLoc); + if (CondResult.isInvalid()) + return StmtError(); + Cond = CondResult.get(); getCurFunction()->setHasBranchIntoScope(); @@ -1229,6 +1228,7 @@ Sema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond, if (CondVar) { ConditionVar = cast<VarDecl>(CondVar); CondResult = CheckConditionVariable(ConditionVar, WhileLoc, true); + CondResult = ActOnFinishFullExpr(CondResult.get(), WhileLoc); if (CondResult.isInvalid()) return StmtError(); } @@ -1634,6 +1634,7 @@ Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, if (secondVar) { ConditionVar = cast<VarDecl>(secondVar); SecondResult = CheckConditionVariable(ConditionVar, ForLoc, true); + SecondResult = ActOnFinishFullExpr(SecondResult.get(), ForLoc); if (SecondResult.isInvalid()) return StmtError(); } diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp index 6f676ad7c55d..ae8157e70a60 100644 --- a/lib/Sema/SemaTemplateDeduction.cpp +++ b/lib/Sema/SemaTemplateDeduction.cpp @@ -3190,6 +3190,40 @@ static bool hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate, QualType T); +static Sema::TemplateDeductionResult DeduceTemplateArgumentByListElement( + Sema &S, TemplateParameterList *TemplateParams, QualType ParamType, + Expr *Arg, TemplateDeductionInfo &Info, + SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF); + +/// \brief Attempt template argument deduction from an initializer list +/// deemed to be an argument in a function call. +static bool +DeduceFromInitializerList(Sema &S, TemplateParameterList *TemplateParams, + QualType AdjustedParamType, InitListExpr *ILE, + TemplateDeductionInfo &Info, + SmallVectorImpl<DeducedTemplateArgument> &Deduced, + unsigned TDF, Sema::TemplateDeductionResult &Result) { + // If the argument is an initializer list then the parameter is an undeduced + // context, unless the parameter type is (reference to cv) + // std::initializer_list<P'>, in which case deduction is done for each element + // of the initializer list as-if it were an argument in a function call, and + // the result is the deduced type if it's the same for all elements. + QualType X; + if (!S.isStdInitializerList(AdjustedParamType, &X)) + return false; + + Result = Sema::TDK_Success; + + // Recurse down into the init list. + for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { + if ((Result = DeduceTemplateArgumentByListElement( + S, TemplateParams, X, ILE->getInit(i), Info, Deduced, TDF))) + return true; + } + + return true; +} + /// \brief Perform template argument deduction by matching a parameter type /// against a single expression, where the expression is an element of /// an initializer list that was originally matched against a parameter @@ -3204,19 +3238,13 @@ DeduceTemplateArgumentByListElement(Sema &S, // Handle the case where an init list contains another init list as the // element. if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) { - QualType X; - if (!S.isStdInitializerList(ParamType.getNonReferenceType(), &X)) + Sema::TemplateDeductionResult Result; + if (!DeduceFromInitializerList(S, TemplateParams, + ParamType.getNonReferenceType(), ILE, Info, + Deduced, TDF, Result)) return Sema::TDK_Success; // Just ignore this expression. - // Recurse down into the init list. - for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { - if (Sema::TemplateDeductionResult Result = - DeduceTemplateArgumentByListElement(S, TemplateParams, X, - ILE->getInit(i), - Info, Deduced, TDF)) - return Result; - } - return Sema::TDK_Success; + return Result; } // For all other cases, just match by type. @@ -3335,22 +3363,14 @@ Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( // If the argument is an initializer list ... if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) { - // ... then the parameter is an undeduced context, unless the parameter - // type is (reference to cv) std::initializer_list<P'>, in which case - // deduction is done for each element of the initializer list, and the - // result is the deduced type if it's the same for all elements. - QualType X; + TemplateDeductionResult Result; // Removing references was already done. - if (!isStdInitializerList(ParamType, &X)) + if (!DeduceFromInitializerList(*this, TemplateParams, ParamType, ILE, + Info, Deduced, TDF, Result)) continue; - for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { - if (TemplateDeductionResult Result = - DeduceTemplateArgumentByListElement(*this, TemplateParams, X, - ILE->getInit(i), - Info, Deduced, TDF)) - return Result; - } + if (Result) + return Result; // Don't track the argument type, since an initializer list has none. continue; } @@ -3406,19 +3426,15 @@ Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( // As above, initializer lists need special handling. if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) { - QualType X; - if (!isStdInitializerList(ParamType, &X)) { + TemplateDeductionResult Result; + if (!DeduceFromInitializerList(*this, TemplateParams, ParamType, ILE, + Info, Deduced, TDF, Result)) { ++ArgIdx; break; } - for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { - if (TemplateDeductionResult Result = - DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, X, - ILE->getInit(i)->getType(), - Info, Deduced, TDF)) - return Result; - } + if (Result) + return Result; } else { // Keep track of the argument type and corresponding argument index, @@ -3952,6 +3968,8 @@ Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result) { } QualType Deduced = BuildDecltypeType(Init, Init->getLocStart(), false); + if (Deduced.isNull()) + return DAR_FailedAlreadyDiagnosed; // FIXME: Support a non-canonical deduced type for 'auto'. Deduced = Context.getCanonicalType(Deduced); Result = SubstituteAutoTransform(*this, Deduced).Apply(Type); diff --git a/lib/Sema/SemaTemplateInstantiate.cpp b/lib/Sema/SemaTemplateInstantiate.cpp index 82ff7c0ca4f5..7d58017a9bf0 100644 --- a/lib/Sema/SemaTemplateInstantiate.cpp +++ b/lib/Sema/SemaTemplateInstantiate.cpp @@ -1680,11 +1680,24 @@ ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm, } else if (OldParm->hasUnparsedDefaultArg()) { NewParm->setUnparsedDefaultArg(); UnparsedDefaultArgInstantiations[OldParm].push_back(NewParm); - } else if (Expr *Arg = OldParm->getDefaultArg()) - // FIXME: if we non-lazily instantiated non-dependent default args for - // non-dependent parameter types we could remove a bunch of duplicate - // conversion warnings for such arguments. - NewParm->setUninstantiatedDefaultArg(Arg); + } else if (Expr *Arg = OldParm->getDefaultArg()) { + FunctionDecl *OwningFunc = cast<FunctionDecl>(OldParm->getDeclContext()); + CXXRecordDecl *ClassD = dyn_cast<CXXRecordDecl>(OwningFunc->getDeclContext()); + if (ClassD && ClassD->isLocalClass() && !ClassD->isLambda()) { + // If this is a method of a local class, as per DR1484 its default + // arguments must be instantiated. + Sema::ContextRAII SavedContext(*this, ClassD); + LocalInstantiationScope Local(*this); + ExprResult NewArg = SubstExpr(Arg, TemplateArgs); + if (NewArg.isUsable()) + NewParm->setDefaultArg(NewArg.get()); + } else { + // FIXME: if we non-lazily instantiated non-dependent default args for + // non-dependent parameter types we could remove a bunch of duplicate + // conversion warnings for such arguments. + NewParm->setUninstantiatedDefaultArg(Arg); + } + } NewParm->setHasInheritedDefaultArg(OldParm->hasInheritedDefaultArg()); @@ -2269,33 +2282,6 @@ bool Sema::InstantiateClassTemplateSpecialization( // Perform the actual instantiation on the canonical declaration. ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>( ClassTemplateSpec->getCanonicalDecl()); - - // Check whether we have already instantiated or specialized this class - // template specialization. - if (ClassTemplateSpec->getSpecializationKind() != TSK_Undeclared) { - if (ClassTemplateSpec->getSpecializationKind() == - TSK_ExplicitInstantiationDeclaration && - TSK == TSK_ExplicitInstantiationDefinition) { - // An explicit instantiation definition follows an explicit instantiation - // declaration (C++0x [temp.explicit]p10); go ahead and perform the - // explicit instantiation. - ClassTemplateSpec->setSpecializationKind(TSK); - - // If this is an explicit instantiation definition, mark the - // vtable as used. - if (TSK == TSK_ExplicitInstantiationDefinition && - !ClassTemplateSpec->isInvalidDecl()) - MarkVTableUsed(PointOfInstantiation, ClassTemplateSpec, true); - - return false; - } - - // We can only instantiate something that hasn't already been - // instantiated or specialized. Fail without any diagnostics: our - // caller will provide an error message. - return true; - } - if (ClassTemplateSpec->isInvalidDecl()) return true; diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp index f35d1aaf77e9..aff2d1c96676 100644 --- a/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -2094,14 +2094,13 @@ static void collectUnexpandedParameterPacks( Sema &S, TemplateParameterList *Params, SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) { - for (TemplateParameterList::const_iterator I = Params->begin(), - E = Params->end(); I != E; ++I) { - if ((*I)->isTemplateParameterPack()) + for (const auto &P : *Params) { + if (P->isTemplateParameterPack()) continue; - if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*I)) + if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(), Unexpanded); - if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(*I)) + if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P)) collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(), Unexpanded); } @@ -2731,9 +2730,8 @@ TemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) { typedef SmallVector<NamedDecl *, 8> ParamVector; ParamVector Params; Params.reserve(N); - for (TemplateParameterList::iterator PI = L->begin(), PE = L->end(); - PI != PE; ++PI) { - NamedDecl *D = cast_or_null<NamedDecl>(Visit(*PI)); + for (auto &P : *L) { + NamedDecl *D = cast_or_null<NamedDecl>(Visit(P)); Params.push_back(D); Invalid = Invalid || !D || D->isInvalidDecl(); } @@ -3246,10 +3244,18 @@ TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New, // DR1330: In C++11, defer instantiation of a non-trivial // exception specification. + // DR1484: Local classes and their members are instantiated along with the + // containing function. + bool RequireInstantiation = false; + if (CXXRecordDecl *Cls = dyn_cast<CXXRecordDecl>(Tmpl->getDeclContext())) { + if (Cls->isLocalClass()) + RequireInstantiation = true; + } if (SemaRef.getLangOpts().CPlusPlus11 && EPI.ExceptionSpec.Type != EST_None && EPI.ExceptionSpec.Type != EST_DynamicNone && - EPI.ExceptionSpec.Type != EST_BasicNoexcept) { + EPI.ExceptionSpec.Type != EST_BasicNoexcept && + !RequireInstantiation) { FunctionDecl *ExceptionSpecTemplate = Tmpl; if (EPI.ExceptionSpec.Type == EST_Uninstantiated) ExceptionSpecTemplate = EPI.ExceptionSpec.SourceTemplate; diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp index d72f2595abe7..8d76f6920252 100644 --- a/lib/Sema/SemaType.cpp +++ b/lib/Sema/SemaType.cpp @@ -2567,19 +2567,19 @@ namespace { IdentifierInfo *Sema::getNullabilityKeyword(NullabilityKind nullability) { switch (nullability) { case NullabilityKind::NonNull: - if (!Ident___nonnull) - Ident___nonnull = PP.getIdentifierInfo("__nonnull"); - return Ident___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; + 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; + if (!Ident__Null_unspecified) + Ident__Null_unspecified = PP.getIdentifierInfo("_Null_unspecified"); + return Ident__Null_unspecified; } llvm_unreachable("Unknown nullability kind."); } @@ -2900,7 +2900,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, } } - // Determine whether we should infer __nonnull on pointer types. + // Determine whether we should infer _Nonnull on pointer types. Optional<NullabilityKind> inferNullability; bool inferNullabilityCS = false; bool inferNullabilityInnerOnly = false; @@ -3003,7 +3003,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, break; case PointerDeclaratorKind::SingleLevelPointer: - // Infer __nonnull if we are in an assumes-nonnull region. + // Infer _Nonnull if we are in an assumes-nonnull region. if (inAssumeNonNullRegion) { inferNullability = NullabilityKind::NonNull; inferNullabilityCS = (context == Declarator::ObjCParameterContext || @@ -3013,7 +3013,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, case PointerDeclaratorKind::CFErrorRefPointer: case PointerDeclaratorKind::NSErrorPointerPointer: - // Within a function or method signature, infer __nullable at both + // Within a function or method signature, infer _Nullable at both // levels. if (isFunctionOrMethod && inAssumeNonNullRegion) inferNullability = NullabilityKind::Nullable; @@ -3023,7 +3023,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, 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. + // infer the inner pointer as _Nullable. auto hasCFReturnsAttr = [](const AttributeList *NextAttr) -> bool { while (NextAttr) { if (NextAttr->getKind() == AttributeList::AT_CFReturnsRetained || @@ -3070,7 +3070,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, } // Local function that checks the nullability for a given pointer declarator. - // Returns true if __nonnull was inferred. + // Returns true if _Nonnull was inferred. auto inferPointerNullability = [&](SimplePointerKind pointerKind, SourceLocation pointerLoc, AttributeList *&attrs) -> AttributeList * { @@ -5084,8 +5084,7 @@ bool Sema::checkNullabilityTypeSpecifier(QualType &type, // Duplicated nullability. if (nullability == *existingNullability) { Diag(nullabilityLoc, diag::warn_nullability_duplicate) - << static_cast<unsigned>(nullability) - << isContextSensitive + << DiagNullabilityKind(nullability, isContextSensitive) << FixItHint::CreateRemoval(nullabilityLoc); break; @@ -5093,10 +5092,8 @@ bool Sema::checkNullabilityTypeSpecifier(QualType &type, // Conflicting nullability. Diag(nullabilityLoc, diag::err_nullability_conflicting) - << static_cast<unsigned>(nullability) - << isContextSensitive - << static_cast<unsigned>(*existingNullability) - << false; + << DiagNullabilityKind(nullability, isContextSensitive) + << DiagNullabilityKind(*existingNullability, false); return true; } @@ -5110,10 +5107,8 @@ bool Sema::checkNullabilityTypeSpecifier(QualType &type, 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; + << DiagNullabilityKind(nullability, isContextSensitive) + << DiagNullabilityKind(*existingNullability, false); // Try to find the typedef with the existing nullability specifier. if (auto typedefType = desugared->getAs<TypedefType>()) { @@ -5123,7 +5118,7 @@ bool Sema::checkNullabilityTypeSpecifier(QualType &type, = AttributedType::stripOuterNullability(underlyingType)) { if (*typedefNullability == *existingNullability) { Diag(typedefDecl->getLocation(), diag::note_nullability_here) - << static_cast<unsigned>(*existingNullability); + << DiagNullabilityKind(*existingNullability, false); } } } @@ -5135,7 +5130,7 @@ bool Sema::checkNullabilityTypeSpecifier(QualType &type, // 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; + << DiagNullabilityKind(nullability, isContextSensitive) << type; return true; } @@ -5148,10 +5143,10 @@ bool Sema::checkNullabilityTypeSpecifier(QualType &type, pointeeType->isObjCObjectPointerType() || pointeeType->isMemberPointerType()) { Diag(nullabilityLoc, diag::err_nullability_cs_multilevel) - << static_cast<unsigned>(nullability) + << DiagNullabilityKind(nullability, true) << type; Diag(nullabilityLoc, diag::note_nullability_type_specifier) - << static_cast<unsigned>(nullability) + << DiagNullabilityKind(nullability, false) << type << FixItHint::CreateReplacement(nullabilityLoc, getNullabilitySpelling(nullability)); @@ -5202,16 +5197,24 @@ static bool distributeNullabilityTypeAttr(TypeProcessingState &state, // 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; + enum { + PK_Pointer, + PK_BlockPointer, + PK_MemberPointer, + PK_FunctionPointer, + PK_MemberFunctionPointer, + } pointerKind + = chunk.Kind == DeclaratorChunk::Pointer ? (inFunction ? PK_FunctionPointer + : PK_Pointer) + : chunk.Kind == DeclaratorChunk::BlockPointer ? PK_BlockPointer + : inFunction? PK_MemberFunctionPointer : PK_MemberPointer; auto diag = state.getSema().Diag(attr.getLoc(), diag::warn_nullability_declspec) - << static_cast<unsigned>(mapNullabilityAttrKind(attr.getKind())) + << DiagNullabilityKind(mapNullabilityAttrKind(attr.getKind()), + attr.isContextSensitiveKeywordAttribute()) << type - << pointerKind; + << static_cast<unsigned>(pointerKind); // FIXME: MemberPointer chunks don't carry the location of the *. if (chunk.Kind != DeclaratorChunk::MemberPointer) { diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h index 73dde7c97fc2..80896be981d1 100644 --- a/lib/Sema/TreeTransform.h +++ b/lib/Sema/TreeTransform.h @@ -1321,11 +1321,12 @@ public: /// Subclasses may override this routine to provide different behavior. StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind, DeclarationNameInfo DirName, + OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) { - return getSema().ActOnOpenMPExecutableDirective(Kind, DirName, Clauses, - AStmt, StartLoc, EndLoc); + return getSema().ActOnOpenMPExecutableDirective( + Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc); } /// \brief Build a new OpenMP 'if' clause. @@ -1551,6 +1552,19 @@ public: EndLoc); } + /// \brief Build a new OpenMP 'depend' pseudo clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause * + RebuildOMPDependClause(OpenMPDependClauseKind DepKind, SourceLocation DepLoc, + SourceLocation ColonLoc, ArrayRef<Expr *> VarList, + SourceLocation StartLoc, SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPDependClause(DepKind, DepLoc, ColonLoc, VarList, + StartLoc, LParenLoc, EndLoc); + } + /// \brief Rebuild the operand to an Objective-C \@synchronized statement. /// /// By default, performs semantic analysis to build the new statement. @@ -5392,7 +5406,7 @@ QualType TreeTransform<Derived>::TransformAttributedType( if (auto nullability = oldType->getImmediateNullability()) { if (!modifiedType->canHaveNullability()) { SemaRef.Diag(TL.getAttrNameLoc(), diag::err_nullability_nonpointer) - << static_cast<unsigned>(*nullability) << false << modifiedType; + << DiagNullabilityKind(*nullability, false) << modifiedType; return QualType(); } } @@ -6664,7 +6678,9 @@ StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective( for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end(); I != E; ++I) { if (*I) { + getDerived().getSema().StartOpenMPClause((*I)->getClauseKind()); OMPClause *Clause = getDerived().TransformOMPClause(*I); + getDerived().getSema().EndOpenMPClause(); if (Clause) TClauses.push_back(Clause); } else { @@ -6700,10 +6716,16 @@ StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective( DirName = cast<OMPCriticalDirective>(D)->getDirectiveName(); DirName = getDerived().TransformDeclarationNameInfo(DirName); } + OpenMPDirectiveKind CancelRegion = OMPD_unknown; + if (D->getDirectiveKind() == OMPD_cancellation_point) { + CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion(); + } else if (D->getDirectiveKind() == OMPD_cancel) { + CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion(); + } return getDerived().RebuildOMPExecutableDirective( - D->getDirectiveKind(), DirName, TClauses, AssociatedStmt.get(), - D->getLocStart(), D->getLocEnd()); + D->getDirectiveKind(), DirName, CancelRegion, TClauses, + AssociatedStmt.get(), D->getLocStart(), D->getLocEnd()); } template <typename Derived> @@ -6947,6 +6969,28 @@ TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) { return Res; } +template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective( + OMPCancellationPointDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_cancellation_point, DirName, + nullptr, D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_cancel, DirName, nullptr, + D->getLocStart()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + //===----------------------------------------------------------------------===// // OpenMP clause transformation //===----------------------------------------------------------------------===// @@ -7253,6 +7297,22 @@ OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *C) { C->getLParenLoc(), C->getLocEnd()); } +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPDependClause(OMPDependClause *C) { + llvm::SmallVector<Expr *, 16> Vars; + Vars.reserve(C->varlist_size()); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); + if (EVar.isInvalid()) + return nullptr; + Vars.push_back(EVar.get()); + } + return getDerived().RebuildOMPDependClause( + C->getDependencyKind(), C->getDependencyLoc(), C->getColonLoc(), Vars, + C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); +} + //===----------------------------------------------------------------------===// // Expression transformation //===----------------------------------------------------------------------===// @@ -9368,7 +9428,8 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { } // Capture the transformed variable. - getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind); + getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind, + EllipsisLoc); } if (!FinishedExplicitCaptures) getSema().finishLambdaExplicitCaptures(LSI); diff --git a/lib/Serialization/ASTCommon.h b/lib/Serialization/ASTCommon.h index 79d1817159c6..f21e8a7ea030 100644 --- a/lib/Serialization/ASTCommon.h +++ b/lib/Serialization/ASTCommon.h @@ -36,7 +36,8 @@ enum DeclUpdateKind { UPD_MANGLING_NUMBER, UPD_STATIC_LOCAL_NUMBER, UPD_DECL_MARKED_OPENMP_THREADPRIVATE, - UPD_DECL_EXPORTED + UPD_DECL_EXPORTED, + UPD_ADDED_ATTR_TO_RECORD }; TypeIdx TypeIdxFromBuiltin(const BuiltinType *BT); diff --git a/lib/Serialization/ASTReader.cpp b/lib/Serialization/ASTReader.cpp index d75b5eb73d51..48a898cb30da 100644 --- a/lib/Serialization/ASTReader.cpp +++ b/lib/Serialization/ASTReader.cpp @@ -209,6 +209,12 @@ static bool checkLanguageOptions(const LangOptions &LangOpts, #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description) #include "clang/Basic/LangOptions.def" + if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) { + if (Diags) + Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features"; + return true; + } + if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) { if (Diags) Diags->Report(diag::err_pch_langopt_value_mismatch) @@ -2307,7 +2313,8 @@ ASTReader::ReadControlBlock(ModuleFile &F, case INPUT_FILE_OFFSETS: NumInputs = Record[0]; NumUserInputs = Record[1]; - F.InputFileOffsets = (const uint64_t *)Blob.data(); + F.InputFileOffsets = + (const llvm::support::unaligned_uint64_t *)Blob.data(); F.InputFilesLoaded.resize(NumInputs); break; } @@ -4262,6 +4269,7 @@ ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) { CurrentModule->setASTFile(F.File); } + CurrentModule->Signature = F.Signature; CurrentModule->IsFromModuleFile = true; CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem; CurrentModule->IsExternC = IsExternC; @@ -4436,15 +4444,14 @@ bool ASTReader::ParseLanguageOptions(const RecordData &Record, LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]); #include "clang/Basic/Sanitizers.def" + for (unsigned N = Record[Idx++]; N; --N) + LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx)); + ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++]; VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx); LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion); - - unsigned Length = Record[Idx++]; - LangOpts.CurrentModule.assign(Record.begin() + Idx, - Record.begin() + Idx + Length); - Idx += Length; + LangOpts.CurrentModule = ReadString(Record, Idx); // Comment options. for (unsigned N = Record[Idx++]; N; --N) { @@ -7360,6 +7367,37 @@ Module *ASTReader::getModule(unsigned ID) { return getSubmodule(ID); } +ExternalASTSource::ASTSourceDescriptor +ASTReader::getSourceDescriptor(const Module &M) { + StringRef Dir, Filename; + if (M.Directory) + Dir = M.Directory->getName(); + if (auto *File = M.getASTFile()) + Filename = File->getName(); + return ASTReader::ASTSourceDescriptor{ + M.getFullModuleName(), Dir, Filename, + M.Signature + }; +} + +llvm::Optional<ExternalASTSource::ASTSourceDescriptor> +ASTReader::getSourceDescriptor(unsigned ID) { + if (const Module *M = getSubmodule(ID)) + return getSourceDescriptor(*M); + + // If there is only a single PCH, return it instead. + // Chained PCH are not suported. + if (ModuleMgr.size() == 1) { + ModuleFile &MF = ModuleMgr.getPrimaryModule(); + return ASTReader::ASTSourceDescriptor{ + MF.OriginalSourceFileName, MF.OriginalDir, + MF.FileName, + MF.Signature + }; + } + return None; +} + Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) { return DecodeSelector(getGlobalSelectorID(M, LocalID)); } diff --git a/lib/Serialization/ASTReaderDecl.cpp b/lib/Serialization/ASTReaderDecl.cpp index 00ebd3ebe8e4..b23c33c55188 100644 --- a/lib/Serialization/ASTReaderDecl.cpp +++ b/lib/Serialization/ASTReaderDecl.cpp @@ -810,14 +810,14 @@ void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) { FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs, C); void *InsertPos = nullptr; FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr(); - CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos); + FunctionTemplateSpecializationInfo *ExistingInfo = + CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos); if (InsertPos) CommonPtr->Specializations.InsertNode(FTInfo, InsertPos); else { assert(Reader.getContext().getLangOpts().Modules && "already deserialized this template specialization"); - // FIXME: This specialization is a redeclaration of one from another - // module. Merge it. + mergeRedeclarable(FD, ExistingInfo->Function, Redecl); } } break; @@ -839,8 +839,8 @@ void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) { FD->setDependentTemplateSpecialization(Reader.getContext(), TemplDecls, TemplArgs); - - // FIXME: Merging. + // These are not merged; we don't need to merge redeclarations of dependent + // template friends. break; } } @@ -1045,12 +1045,10 @@ void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { 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++]); D->setPropertyAttributesAsWritten( (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]); - // FIXME: stable encoding D->setPropertyImplementation( (ObjCPropertyDecl::PropertyControl)Record[Idx++]); D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector()); @@ -1768,9 +1766,6 @@ DeclID ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) { = Reader.ReadTemplateParameterList(F, Record, Idx); D->init(TemplatedDecl, TemplateParams); - // FIXME: If this is a redeclaration of a template from another module, handle - // inheritance of default template arguments. - return PatternID; } @@ -2622,7 +2617,6 @@ static bool isSameEntity(NamedDecl *X, NamedDecl *Y) { return NAX->getNamespace()->Equals(NAY->getNamespace()); } - // FIXME: Many other cases to implement. return false; } @@ -2772,9 +2766,6 @@ ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) { return Result; } - // FIXME: Bail out for non-canonical declarations. We will have performed any - // necessary merging already. - DeclContext *DC = D->getDeclContext()->getRedeclContext(); if (TypedefNameForLinkage) { auto It = Reader.ImportedTypedefNamesForLinkage.find( @@ -3888,7 +3879,7 @@ void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile, Reader.Context, ReadSourceRange(Record, Idx))); break; - case UPD_DECL_EXPORTED: + case UPD_DECL_EXPORTED: { unsigned SubmoduleID = readSubmoduleID(Record, Idx); auto *Exported = cast<NamedDecl>(D); if (auto *TD = dyn_cast<TagDecl>(Exported)) @@ -3897,18 +3888,28 @@ void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile, if (Reader.getContext().getLangOpts().ModulesLocalVisibility) { // FIXME: This doesn't send the right notifications if there are // ASTMutationListeners other than an ASTWriter. - Reader.getContext().mergeDefinitionIntoModule(cast<NamedDecl>(D), Owner, - /*NotifyListeners*/false); - Reader.PendingMergedDefinitionsToDeduplicate.insert(cast<NamedDecl>(D)); + Reader.getContext().mergeDefinitionIntoModule( + cast<NamedDecl>(Exported), Owner, + /*NotifyListeners*/ false); + Reader.PendingMergedDefinitionsToDeduplicate.insert( + cast<NamedDecl>(Exported)); } else if (Owner && Owner->NameVisibility != Module::AllVisible) { // If Owner is made visible at some later point, make this declaration // visible too. - Reader.HiddenNamesMap[Owner].push_back(D); + Reader.HiddenNamesMap[Owner].push_back(Exported); } else { // The declaration is now visible. - D->Hidden = false; + Exported->Hidden = false; } break; } + + case UPD_ADDED_ATTR_TO_RECORD: + AttrVec Attrs; + Reader.ReadAttributes(F, Attrs, Record, Idx); + assert(Attrs.size() == 1); + D->addAttr(Attrs[0]); + break; + } } } diff --git a/lib/Serialization/ASTReaderStmt.cpp b/lib/Serialization/ASTReaderStmt.cpp index c15f6b0b552f..ca5d0be6329a 100644 --- a/lib/Serialization/ASTReaderStmt.cpp +++ b/lib/Serialization/ASTReaderStmt.cpp @@ -1785,6 +1785,9 @@ OMPClause *OMPClauseReader::readClause() { case OMPC_flush: C = OMPFlushClause::CreateEmpty(Context, Record[Idx++]); break; + case OMPC_depend: + C = OMPDependClause::CreateEmpty(Context, Record[Idx++]); + break; } Visit(C); C->setLocStart(Reader->ReadSourceLocation(Record, Idx)); @@ -2049,6 +2052,19 @@ void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) { C->setVarRefs(Vars); } +void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) { + C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setDependencyKind(static_cast<OpenMPDependClauseKind>(Record[Idx++])); + C->setDependencyLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setColonLoc(Reader->ReadSourceLocation(Record, Idx)); + unsigned NumVars = C->varlist_size(); + SmallVector<Expr *, 16> Vars; + Vars.reserve(NumVars); + for (unsigned i = 0; i != NumVars; ++i) + Vars.push_back(Reader->Reader.ReadSubExpr()); + C->setVarRefs(Vars); +} + //===----------------------------------------------------------------------===// // OpenMP Directives. //===----------------------------------------------------------------------===// @@ -2233,6 +2249,19 @@ void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) { VisitOMPExecutableDirective(D); } +void ASTStmtReader::VisitOMPCancellationPointDirective( + OMPCancellationPointDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); + D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record[Idx++])); +} + +void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); + D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record[Idx++])); +} + //===----------------------------------------------------------------------===// // ASTReader Implementation //===----------------------------------------------------------------------===// @@ -2836,6 +2865,14 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { Context, Record[ASTStmtReader::NumStmtFields], Empty); break; + case STMT_OMP_CANCELLATION_POINT_DIRECTIVE: + S = OMPCancellationPointDirective::CreateEmpty(Context, Empty); + break; + + case STMT_OMP_CANCEL_DIRECTIVE: + S = OMPCancelDirective::CreateEmpty(Context, Empty); + break; + case EXPR_CXX_OPERATOR_CALL: S = new (Context) CXXOperatorCallExpr(Context, Empty); break; diff --git a/lib/Serialization/ASTWriter.cpp b/lib/Serialization/ASTWriter.cpp index 5bb0bec4f569..0d15b17c7cec 100644 --- a/lib/Serialization/ASTWriter.cpp +++ b/lib/Serialization/ASTWriter.cpp @@ -1266,11 +1266,14 @@ void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context, Record.push_back(LangOpts.Sanitize.has(SanitizerKind::ID)); #include "clang/Basic/Sanitizers.def" + Record.push_back(LangOpts.ModuleFeatures.size()); + for (StringRef Feature : LangOpts.ModuleFeatures) + AddString(Feature, Record); + Record.push_back((unsigned) LangOpts.ObjCRuntime.getKind()); AddVersionTuple(LangOpts.ObjCRuntime.getVersion(), Record); - - Record.push_back(LangOpts.CurrentModule.size()); - Record.append(LangOpts.CurrentModule.begin(), LangOpts.CurrentModule.end()); + + AddString(LangOpts.CurrentModule, Record); // Comment options. Record.push_back(LangOpts.CommentOpts.BlockCommandNames.size()); @@ -4618,6 +4621,10 @@ void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) { case UPD_DECL_EXPORTED: Record.push_back(getSubmoduleID(Update.getModule())); break; + + case UPD_ADDED_ATTR_TO_RECORD: + WriteAttributes(llvm::makeArrayRef(Update.getAttr()), Record); + break; } } @@ -5766,3 +5773,11 @@ void ASTWriter::RedefinedHiddenDefinition(const NamedDecl *D, Module *M) { assert(D->isHidden() && "expected a hidden declaration"); DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_EXPORTED, M)); } + +void ASTWriter::AddedAttributeToRecord(const Attr *Attr, + const RecordDecl *Record) { + assert(!WritingAST && "Already writing the AST!"); + if (!Record->isFromASTFile()) + return; + DeclUpdates[Record].push_back(DeclUpdate(UPD_ADDED_ATTR_TO_RECORD, Attr)); +} diff --git a/lib/Serialization/ASTWriterStmt.cpp b/lib/Serialization/ASTWriterStmt.cpp index a461d3f66390..cddefaca8f35 100644 --- a/lib/Serialization/ASTWriterStmt.cpp +++ b/lib/Serialization/ASTWriterStmt.cpp @@ -1906,6 +1906,16 @@ void OMPClauseWriter::VisitOMPFlushClause(OMPFlushClause *C) { Writer->Writer.AddStmt(VE); } +void OMPClauseWriter::VisitOMPDependClause(OMPDependClause *C) { + Record.push_back(C->varlist_size()); + Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); + Record.push_back(C->getDependencyKind()); + Writer->Writer.AddSourceLocation(C->getDependencyLoc(), Record); + Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); + for (auto *VE : C->varlists()) + Writer->Writer.AddStmt(VE); +} + //===----------------------------------------------------------------------===// // OpenMP Directives. //===----------------------------------------------------------------------===// @@ -2097,6 +2107,21 @@ void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) { Code = serialization::STMT_OMP_TEAMS_DIRECTIVE; } +void ASTStmtWriter::VisitOMPCancellationPointDirective( + OMPCancellationPointDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); + Record.push_back(D->getCancelRegion()); + Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE; +} + +void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); + Record.push_back(D->getCancelRegion()); + Code = serialization::STMT_OMP_CANCEL_DIRECTIVE; +} + //===----------------------------------------------------------------------===// // ASTWriter Implementation //===----------------------------------------------------------------------===// diff --git a/lib/Serialization/GeneratePCH.cpp b/lib/Serialization/GeneratePCH.cpp index c50b3f9bb9e2..c461fe936ee4 100644 --- a/lib/Serialization/GeneratePCH.cpp +++ b/lib/Serialization/GeneratePCH.cpp @@ -19,7 +19,6 @@ #include "clang/Lex/Preprocessor.h" #include "clang/Sema/SemaConsumer.h" #include "llvm/Bitcode/BitstreamWriter.h" -#include "llvm/Support/raw_ostream.h" #include <string> using namespace clang; diff --git a/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp b/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp index cb5b01009f1d..557439b28881 100644 --- a/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp @@ -76,11 +76,10 @@ void ArrayBoundChecker::checkLocation(SVal l, bool isLoad, const Stmt* LoadS, // reference is outside the range. // Generate a report for this bug. - BugReport *report = - new BugReport(*BT, BT->getDescription(), N); + auto report = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N); report->addRange(LoadS->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); return; } diff --git a/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp b/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp index e462e2b2f15e..d8dc2aaa6363 100644 --- a/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp +++ b/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp @@ -207,7 +207,8 @@ void ArrayBoundCheckerV2::reportOOB(CheckerContext &checkerContext, break; } - checkerContext.emitReport(new BugReport(*BT, os.str(), errorNode)); + checkerContext.emitReport( + llvm::make_unique<BugReport>(*BT, os.str(), errorNode)); } void RegionRawOffsetV2::dump() const { diff --git a/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp b/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp index 3fd55760bc5f..f763284aa2c9 100644 --- a/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp +++ b/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp @@ -207,10 +207,10 @@ void NilArgChecker::generateBugReport(ExplodedNode *N, if (!BT) BT.reset(new APIMisuse(this, "nil argument")); - BugReport *R = new BugReport(*BT, Msg, N); + auto R = llvm::make_unique<BugReport>(*BT, Msg, N); R->addRange(Range); bugreporter::trackNullOrUndefValue(N, E, *R); - C.emitReport(R); + C.emitReport(std::move(R)); } void NilArgChecker::checkPreObjCMessage(const ObjCMethodCall &msg, @@ -516,9 +516,9 @@ void CFNumberCreateChecker::checkPreStmt(const CallExpr *CE, if (!BT) BT.reset(new APIMisuse(this, "Bad use of CFNumberCreate")); - BugReport *report = new BugReport(*BT, os.str(), N); + auto report = llvm::make_unique<BugReport>(*BT, os.str(), N); report->addRange(CE->getArg(2)->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); } } @@ -605,10 +605,10 @@ void CFRetainReleaseChecker::checkPreStmt(const CallExpr *CE, else llvm_unreachable("impossible case"); - BugReport *report = new BugReport(*BT, description, N); + auto report = llvm::make_unique<BugReport>(*BT, description, N); report->addRange(Arg->getSourceRange()); bugreporter::trackNullOrUndefValue(N, Arg, *report); - C.emitReport(report); + C.emitReport(std::move(report)); return; } @@ -666,9 +666,9 @@ void ClassReleaseChecker::checkPreObjCMessage(const ObjCMethodCall &msg, "of class '" << Class->getName() << "' and not the class directly"; - BugReport *report = new BugReport(*BT, os.str(), N); + auto report = llvm::make_unique<BugReport>(*BT, os.str(), N); report->addRange(msg.getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); } } @@ -819,9 +819,9 @@ void VariadicMethodTypeChecker::checkPreObjCMessage(const ObjCMethodCall &msg, ArgTy.print(os, C.getLangOpts()); os << "'"; - BugReport *R = new BugReport(*BT, os.str(), errorNode.getValue()); + auto R = llvm::make_unique<BugReport>(*BT, os.str(), errorNode.getValue()); R->addRange(msg.getArgSourceRange(I)); - C.emitReport(R); + C.emitReport(std::move(R)); } } diff --git a/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp b/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp index 83a37c978c22..e945c38e77c7 100644 --- a/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp @@ -35,7 +35,7 @@ void BoolAssignmentChecker::emitReport(ProgramStateRef state, if (ExplodedNode *N = C.addTransition(state)) { if (!BT) BT.reset(new BuiltinBug(this, "Assignment of a non-Boolean value")); - C.emitReport(new BugReport(*BT, BT->getDescription(), N)); + C.emitReport(llvm::make_unique<BugReport>(*BT, BT->getDescription(), N)); } } diff --git a/lib/StaticAnalyzer/Checkers/CStringChecker.cpp b/lib/StaticAnalyzer/Checkers/CStringChecker.cpp index 0f5741bf9e68..54b12410aa56 100644 --- a/lib/StaticAnalyzer/Checkers/CStringChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/CStringChecker.cpp @@ -245,11 +245,11 @@ ProgramStateRef CStringChecker::checkNonNull(CheckerContext &C, // Generate a report for this bug. BuiltinBug *BT = static_cast<BuiltinBug*>(BT_Null.get()); - BugReport *report = new BugReport(*BT, os.str(), N); + auto report = llvm::make_unique<BugReport>(*BT, os.str(), N); report->addRange(S->getSourceRange()); bugreporter::trackNullOrUndefValue(N, S, *report); - C.emitReport(report); + C.emitReport(std::move(report)); return nullptr; } @@ -304,9 +304,9 @@ ProgramStateRef CStringChecker::CheckLocation(CheckerContext &C, BuiltinBug *BT = static_cast<BuiltinBug*>(BT_Bounds.get()); // Generate a report for this bug. - BugReport *report; + std::unique_ptr<BugReport> report; if (warningMsg) { - report = new BugReport(*BT, warningMsg, N); + report = llvm::make_unique<BugReport>(*BT, warningMsg, N); } else { assert(CurrentFunctionDescription); assert(CurrentFunctionDescription[0] != '\0'); @@ -316,7 +316,7 @@ ProgramStateRef CStringChecker::CheckLocation(CheckerContext &C, os << toUppercase(CurrentFunctionDescription[0]) << &CurrentFunctionDescription[1] << " accesses out-of-bound array element"; - report = new BugReport(*BT, os.str(), N); + report = llvm::make_unique<BugReport>(*BT, os.str(), N); } // FIXME: It would be nice to eventually make this diagnostic more clear, @@ -324,7 +324,7 @@ ProgramStateRef CStringChecker::CheckLocation(CheckerContext &C, // reference is outside the range. report->addRange(S->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); return nullptr; } @@ -534,13 +534,12 @@ void CStringChecker::emitOverlapBug(CheckerContext &C, ProgramStateRef state, categories::UnixAPI, "Improper arguments")); // Generate a report for this bug. - BugReport *report = - new BugReport(*BT_Overlap, - "Arguments must not be overlapping buffers", N); + auto report = llvm::make_unique<BugReport>( + *BT_Overlap, "Arguments must not be overlapping buffers", N); report->addRange(First->getSourceRange()); report->addRange(Second->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); } ProgramStateRef CStringChecker::checkAdditionOverflow(CheckerContext &C, @@ -603,8 +602,8 @@ ProgramStateRef CStringChecker::checkAdditionOverflow(CheckerContext &C, "be represented as a size_t"; // Generate a report for this bug. - BugReport *report = new BugReport(*BT_AdditionOverflow, warning, N); - C.emitReport(report); + C.emitReport( + llvm::make_unique<BugReport>(*BT_AdditionOverflow, warning, N)); return nullptr; } @@ -721,10 +720,10 @@ SVal CStringChecker::getCStringLength(CheckerContext &C, ProgramStateRef &state, << "', which is not a null-terminated string"; // Generate a report for this bug. - BugReport *report = new BugReport(*BT_NotCString, os.str(), N); + auto report = llvm::make_unique<BugReport>(*BT_NotCString, os.str(), N); report->addRange(Ex->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); } return UndefinedVal(); @@ -785,11 +784,10 @@ SVal CStringChecker::getCStringLength(CheckerContext &C, ProgramStateRef &state, os << "not a null-terminated string"; // Generate a report for this bug. - BugReport *report = new BugReport(*BT_NotCString, - os.str(), N); + auto report = llvm::make_unique<BugReport>(*BT_NotCString, os.str(), N); report->addRange(Ex->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); } return UndefinedVal(); diff --git a/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp b/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp index abfb971d4ccc..3db19946a300 100644 --- a/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp @@ -168,10 +168,9 @@ void WalkAST::VisitCallExpr(CallExpr *CE) { } void WalkAST::VisitChildren(Stmt *S) { - for (Stmt::child_iterator I = S->child_begin(), E = S->child_end(); I != E; - ++I) - if (Stmt *child = *I) - Visit(child); + for (Stmt *Child : S->children()) + if (Child) + Visit(Child); } namespace { diff --git a/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp b/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp index adb7a54900e0..26423b7368ef 100644 --- a/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp @@ -94,14 +94,14 @@ void CallAndMessageChecker::emitBadCall(BugType *BT, CheckerContext &C, if (!N) return; - BugReport *R = new BugReport(*BT, BT->getName(), N); + auto R = llvm::make_unique<BugReport>(*BT, BT->getName(), N); if (BadE) { R->addRange(BadE->getSourceRange()); if (BadE->isGLValue()) BadE = bugreporter::getDerefExpr(BadE); bugreporter::trackNullOrUndefValue(N, BadE, *R); } - C.emitReport(R); + C.emitReport(std::move(R)); } static StringRef describeUninitializedArgumentInCall(const CallEvent &Call, @@ -164,12 +164,12 @@ bool CallAndMessageChecker::uninitRefOrPointer(CheckerContext &C, if (PSV.isUndef()) { if (ExplodedNode *N = C.generateSink()) { LazyInit_BT(BD, BT); - BugReport *R = new BugReport(*BT, Message, N); + auto R = llvm::make_unique<BugReport>(*BT, Message, N); R->addRange(ArgRange); if (ArgEx) { bugreporter::trackNullOrUndefValue(N, ArgEx, *R); } - C.emitReport(R); + C.emitReport(std::move(R)); } return true; } @@ -199,11 +199,11 @@ bool CallAndMessageChecker::PreVisitProcessArg(CheckerContext &C, // Generate a report for this bug. StringRef Desc = describeUninitializedArgumentInCall(Call, IsFirstArgument); - BugReport *R = new BugReport(*BT, Desc, N); + auto R = llvm::make_unique<BugReport>(*BT, Desc, N); R->addRange(ArgRange); if (ArgEx) bugreporter::trackNullOrUndefValue(N, ArgEx, *R); - C.emitReport(R); + C.emitReport(std::move(R)); } return true; } @@ -281,12 +281,12 @@ bool CallAndMessageChecker::PreVisitProcessArg(CheckerContext &C, } // Generate a report for this bug. - BugReport *R = new BugReport(*BT, os.str(), N); + auto R = llvm::make_unique<BugReport>(*BT, os.str(), N); R->addRange(ArgRange); // FIXME: enhance track back for uninitialized value for arbitrary // memregions - C.emitReport(R); + C.emitReport(std::move(R)); } return true; } @@ -342,9 +342,9 @@ void CallAndMessageChecker::checkPreStmt(const CXXDeleteExpr *DE, else Desc = "Argument to 'delete' is uninitialized"; BugType *BT = BT_cxx_delete_undef.get(); - BugReport *R = new BugReport(*BT, Desc, N); + auto R = llvm::make_unique<BugReport>(*BT, Desc, N); bugreporter::trackNullOrUndefValue(N, DE, *R); - C.emitReport(R); + C.emitReport(std::move(R)); return; } } @@ -400,8 +400,8 @@ void CallAndMessageChecker::checkPreCall(const CallEvent &Call, << (Params == 1 ? "" : "s") << " is called with less (" << Call.getNumArgs() << ")"; - BugReport *R = new BugReport(*BT_call_few_args, os.str(), N); - C.emitReport(R); + C.emitReport( + llvm::make_unique<BugReport>(*BT_call_few_args, os.str(), N)); } } @@ -461,14 +461,14 @@ void CallAndMessageChecker::checkPreObjCMessage(const ObjCMethodCall &msg, } assert(BT && "Unknown message kind."); - BugReport *R = new BugReport(*BT, BT->getName(), N); + auto R = llvm::make_unique<BugReport>(*BT, BT->getName(), N); const ObjCMessageExpr *ME = msg.getOriginExpr(); R->addRange(ME->getReceiverRange()); // FIXME: getTrackNullOrUndefValueVisitor can't handle "super" yet. if (const Expr *ReceiverE = ME->getInstanceReceiver()) bugreporter::trackNullOrUndefValue(N, ReceiverE, *R); - C.emitReport(R); + C.emitReport(std::move(R)); } return; } else { @@ -512,13 +512,13 @@ void CallAndMessageChecker::emitNilReceiverBug(CheckerContext &C, os << "' that will be garbage"; } - BugReport *report = new BugReport(*BT_msg_ret, os.str(), N); + auto report = llvm::make_unique<BugReport>(*BT_msg_ret, os.str(), N); report->addRange(ME->getReceiverRange()); // FIXME: This won't track "self" in messages to super. if (const Expr *receiver = ME->getInstanceReceiver()) { bugreporter::trackNullOrUndefValue(N, receiver, *report); } - C.emitReport(report); + C.emitReport(std::move(report)); } static bool supportsNilWithFloatRet(const llvm::Triple &triple) { diff --git a/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp b/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp index 3ba063ddc821..0d683f96df08 100644 --- a/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp @@ -136,9 +136,9 @@ void CastSizeChecker::checkPreStmt(const CastExpr *CE,CheckerContext &C) const { BT.reset(new BuiltinBug(this, "Cast region with wrong size.", "Cast a region whose size is not a multiple" " of the destination type size.")); - BugReport *R = new BugReport(*BT, BT->getDescription(), errorNode); + auto R = llvm::make_unique<BugReport>(*BT, BT->getDescription(), errorNode); R->addRange(CE->getSourceRange()); - C.emitReport(R); + C.emitReport(std::move(R)); } } diff --git a/lib/StaticAnalyzer/Checkers/CastToStructChecker.cpp b/lib/StaticAnalyzer/Checkers/CastToStructChecker.cpp index d765315bb57b..ba3024d78a19 100644 --- a/lib/StaticAnalyzer/Checkers/CastToStructChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/CastToStructChecker.cpp @@ -63,9 +63,9 @@ void CastToStructChecker::checkPreStmt(const CastExpr *CE, "Casting a non-structure type to a structure type " "and accessing a field can lead to memory access " "errors or data corruption.")); - BugReport *R = new BugReport(*BT,BT->getDescription(), N); + auto R = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N); R->addRange(CE->getSourceRange()); - C.emitReport(R); + C.emitReport(std::move(R)); } } } diff --git a/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp b/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp index 339af8f03324..12eb0bde28ad 100644 --- a/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp +++ b/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp @@ -69,8 +69,8 @@ static bool scan_ivar_release(Stmt *S, ObjCIvarDecl *ID, } // Recurse to children. - for (Stmt::child_iterator I = S->child_begin(), E= S->child_end(); I!=E; ++I) - if (*I && scan_ivar_release(*I, ID, PD, Release, SelfII, Ctx)) + for (Stmt *SubStmt : S->children()) + if (SubStmt && scan_ivar_release(SubStmt, ID, PD, Release, SelfII, Ctx)) return true; return false; diff --git a/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp b/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp index 0beb917833d6..e0c113c86262 100644 --- a/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp +++ b/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp @@ -109,9 +109,9 @@ public: //===----------------------------------------------------------------------===// void WalkAST::VisitChildren(Stmt *S) { - for (Stmt::child_iterator I = S->child_begin(), E = S->child_end(); I!=E; ++I) - if (Stmt *child = *I) - Visit(child); + for (Stmt *Child : S->children()) + if (Child) + Visit(Child); } void WalkAST::VisitCallExpr(CallExpr *CE) { @@ -162,11 +162,11 @@ void WalkAST::VisitCallExpr(CallExpr *CE) { } void WalkAST::VisitCompoundStmt(CompoundStmt *S) { - for (Stmt::child_iterator I = S->child_begin(), E = S->child_end(); I!=E; ++I) - if (Stmt *child = *I) { - if (CallExpr *CE = dyn_cast<CallExpr>(child)) + for (Stmt *Child : S->children()) + if (Child) { + if (CallExpr *CE = dyn_cast<CallExpr>(Child)) checkUncheckedReturnValue(CE); - Visit(child); + Visit(Child); } } diff --git a/lib/StaticAnalyzer/Checkers/CheckSizeofPointer.cpp b/lib/StaticAnalyzer/Checkers/CheckSizeofPointer.cpp index a61e658f69c9..81a20063f972 100644 --- a/lib/StaticAnalyzer/Checkers/CheckSizeofPointer.cpp +++ b/lib/StaticAnalyzer/Checkers/CheckSizeofPointer.cpp @@ -37,9 +37,9 @@ public: } void WalkAST::VisitChildren(Stmt *S) { - for (Stmt::child_iterator I = S->child_begin(), E = S->child_end(); I!=E; ++I) - if (Stmt *child = *I) - Visit(child); + for (Stmt *Child : S->children()) + if (Child) + Visit(Child); } // CWE-467: Use of sizeof() on a Pointer Type diff --git a/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp b/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp index ad415770e5e5..804e83c0fb2a 100644 --- a/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp @@ -145,11 +145,10 @@ void ChrootChecker::checkPreStmt(const CallExpr *CE, CheckerContext &C) const { BT_BreakJail.reset(new BuiltinBug( this, "Break out of jail", "No call of chdir(\"/\") immediately " "after chroot")); - BugReport *R = new BugReport(*BT_BreakJail, - BT_BreakJail->getDescription(), N); - C.emitReport(R); + C.emitReport(llvm::make_unique<BugReport>( + *BT_BreakJail, BT_BreakJail->getDescription(), N)); } - + return; } diff --git a/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp b/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp index 2e442c7d875c..2ba7ea4a4e4d 100644 --- a/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp @@ -160,10 +160,8 @@ void DereferenceChecker::reportBug(ProgramStateRef State, const Stmt *S, } os.flush(); - BugReport *report = - new BugReport(*BT_null, - buf.empty() ? BT_null->getDescription() : StringRef(buf), - N); + auto report = llvm::make_unique<BugReport>( + *BT_null, buf.empty() ? BT_null->getDescription() : StringRef(buf), N); bugreporter::trackNullOrUndefValue(N, bugreporter::getDerefExpr(S), *report); @@ -171,7 +169,7 @@ void DereferenceChecker::reportBug(ProgramStateRef State, const Stmt *S, I = Ranges.begin(), E = Ranges.end(); I!=E; ++I) report->addRange(*I); - C.emitReport(report); + C.emitReport(std::move(report)); } void DereferenceChecker::checkLocation(SVal l, bool isLoad, const Stmt* S, @@ -183,11 +181,11 @@ void DereferenceChecker::checkLocation(SVal l, bool isLoad, const Stmt* S, BT_undef.reset( new BuiltinBug(this, "Dereference of undefined pointer value")); - BugReport *report = - new BugReport(*BT_undef, BT_undef->getDescription(), N); + auto report = + llvm::make_unique<BugReport>(*BT_undef, BT_undef->getDescription(), N); bugreporter::trackNullOrUndefValue(N, bugreporter::getDerefExpr(S), *report); - C.emitReport(report); + C.emitReport(std::move(report)); } return; } diff --git a/lib/StaticAnalyzer/Checkers/DirectIvarAssignment.cpp b/lib/StaticAnalyzer/Checkers/DirectIvarAssignment.cpp index 0bcebf6e7744..a71def23c0bc 100644 --- a/lib/StaticAnalyzer/Checkers/DirectIvarAssignment.cpp +++ b/lib/StaticAnalyzer/Checkers/DirectIvarAssignment.cpp @@ -78,9 +78,9 @@ class DirectIvarAssignment : void VisitBinaryOperator(const BinaryOperator *BO); void VisitChildren(const Stmt *S) { - for (Stmt::const_child_range I = S->children(); I; ++I) - if (*I) - this->Visit(*I); + for (const Stmt *Child : S->children()) + if (Child) + this->Visit(Child); } }; diff --git a/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp b/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp index e060c36184c4..79f9479b1448 100644 --- a/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp @@ -39,9 +39,9 @@ void DivZeroChecker::reportBug(const char *Msg, if (!BT) BT.reset(new BuiltinBug(this, "Division by zero")); - BugReport *R = new BugReport(*BT, Msg, N); + auto R = llvm::make_unique<BugReport>(*BT, Msg, N); bugreporter::trackNullOrUndefValue(N, bugreporter::GetDenomExpr(N), *R); - C.emitReport(R); + C.emitReport(std::move(R)); } } diff --git a/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp b/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp index f36ec2c687f5..7dc0a8745958 100644 --- a/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp @@ -97,8 +97,8 @@ void ExprInspectionChecker::analyzerEval(const CallExpr *CE, if (!BT) BT.reset(new BugType(this, "Checking analyzer assumptions", "debug")); - BugReport *R = new BugReport(*BT, getArgumentValueString(CE, C), N); - C.emitReport(R); + C.emitReport( + llvm::make_unique<BugReport>(*BT, getArgumentValueString(CE, C), N)); } void ExprInspectionChecker::analyzerWarnIfReached(const CallExpr *CE, @@ -108,8 +108,7 @@ void ExprInspectionChecker::analyzerWarnIfReached(const CallExpr *CE, if (!BT) BT.reset(new BugType(this, "Checking analyzer assumptions", "debug")); - BugReport *R = new BugReport(*BT, "REACHABLE", N); - C.emitReport(R); + C.emitReport(llvm::make_unique<BugReport>(*BT, "REACHABLE", N)); } void ExprInspectionChecker::analyzerCheckInlined(const CallExpr *CE, @@ -128,8 +127,8 @@ void ExprInspectionChecker::analyzerCheckInlined(const CallExpr *CE, if (!BT) BT.reset(new BugType(this, "Checking analyzer assumptions", "debug")); - BugReport *R = new BugReport(*BT, getArgumentValueString(CE, C), N); - C.emitReport(R); + C.emitReport( + llvm::make_unique<BugReport>(*BT, getArgumentValueString(CE, C), N)); } void ExprInspectionChecker::analyzerCrash(const CallExpr *CE, diff --git a/lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp b/lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp index 60bb03654f5d..48d6bd4b37e6 100644 --- a/lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp @@ -57,9 +57,9 @@ void FixedAddressChecker::checkPreStmt(const BinaryOperator *B, "Using a fixed address is not portable because that " "address will probably not be valid in all " "environments or platforms.")); - BugReport *R = new BugReport(*BT, BT->getDescription(), N); + auto R = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N); R->addRange(B->getRHS()->getSourceRange()); - C.emitReport(R); + C.emitReport(std::move(R)); } } diff --git a/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp b/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp index 275481f9e46c..2cf508ff086c 100644 --- a/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp @@ -642,9 +642,9 @@ bool GenericTaintChecker::generateReportIfTainted(const Expr *E, // Generate diagnostic. if (ExplodedNode *N = C.addTransition()) { initBugType(); - BugReport *report = new BugReport(*BT, Msg, N); + auto report = llvm::make_unique<BugReport>(*BT, Msg, N); report->addRange(E->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); return true; } return false; diff --git a/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp b/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp index 02c12095b5a5..3df5fa034a43 100644 --- a/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp @@ -167,9 +167,9 @@ class IvarInvalidationCheckerImpl { void VisitObjCMessageExpr(const ObjCMessageExpr *ME); void VisitChildren(const Stmt *S) { - for (Stmt::const_child_range I = S->children(); I; ++I) { - if (*I) - this->Visit(*I); + for (const Stmt *Child : S->children()) { + if (Child) + this->Visit(Child); if (CalledAnotherInvalidationMethod) return; } diff --git a/lib/StaticAnalyzer/Checkers/LLVMConventionsChecker.cpp b/lib/StaticAnalyzer/Checkers/LLVMConventionsChecker.cpp index 0b7375a4b614..4e3f9b73acb2 100644 --- a/lib/StaticAnalyzer/Checkers/LLVMConventionsChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/LLVMConventionsChecker.cpp @@ -124,10 +124,9 @@ public: const CheckerBase *checker) : DeclWithIssue(declWithIssue), BR(br), Checker(checker) {} void VisitChildren(Stmt *S) { - for (Stmt::child_iterator I = S->child_begin(), E = S->child_end() ; - I != E; ++I) - if (Stmt *child = *I) - Visit(child); + for (Stmt *Child : S->children()) + if (Child) + Visit(Child); } void VisitStmt(Stmt *S) { VisitChildren(S); } void VisitDeclStmt(DeclStmt *DS); diff --git a/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp b/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp index 52e29368cea3..783890135ea3 100644 --- a/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp @@ -103,9 +103,8 @@ private: const ExplodedNode *getAllocationNode(const ExplodedNode *N, SymbolRef Sym, CheckerContext &C) const; - BugReport *generateAllocatedDataNotReleasedReport(const AllocationPair &AP, - ExplodedNode *N, - CheckerContext &C) const; + std::unique_ptr<BugReport> generateAllocatedDataNotReleasedReport( + const AllocationPair &AP, ExplodedNode *N, CheckerContext &C) const; /// Check if RetSym evaluates to an error value in the current state. bool definitelyReturnedError(SymbolRef RetSym, @@ -269,11 +268,11 @@ void MacOSKeychainAPIChecker:: os << "Deallocator doesn't match the allocator: '" << FunctionsToTrack[PDeallocIdx].Name << "' should be used."; - BugReport *Report = new BugReport(*BT, os.str(), N); + auto Report = llvm::make_unique<BugReport>(*BT, os.str(), N); Report->addVisitor(llvm::make_unique<SecKeychainBugVisitor>(AP.first)); Report->addRange(ArgExpr->getSourceRange()); - markInteresting(Report, AP); - C.emitReport(Report); + markInteresting(Report.get(), AP); + C.emitReport(std::move(Report)); } void MacOSKeychainAPIChecker::checkPreStmt(const CallExpr *CE, @@ -314,11 +313,11 @@ void MacOSKeychainAPIChecker::checkPreStmt(const CallExpr *CE, << "the allocator: missing a call to '" << FunctionsToTrack[DIdx].Name << "'."; - BugReport *Report = new BugReport(*BT, os.str(), N); + auto Report = llvm::make_unique<BugReport>(*BT, os.str(), N); Report->addVisitor(llvm::make_unique<SecKeychainBugVisitor>(V)); Report->addRange(ArgExpr->getSourceRange()); Report->markInteresting(AS->Region); - C.emitReport(Report); + C.emitReport(std::move(Report)); } } return; @@ -370,12 +369,12 @@ void MacOSKeychainAPIChecker::checkPreStmt(const CallExpr *CE, if (!N) return; initBugType(); - BugReport *Report = new BugReport(*BT, - "Trying to free data which has not been allocated.", N); + auto Report = llvm::make_unique<BugReport>( + *BT, "Trying to free data which has not been allocated.", N); Report->addRange(ArgExpr->getSourceRange()); if (AS) Report->markInteresting(AS->Region); - C.emitReport(Report); + C.emitReport(std::move(Report)); return; } @@ -436,12 +435,12 @@ void MacOSKeychainAPIChecker::checkPreStmt(const CallExpr *CE, if (!N) return; initBugType(); - BugReport *Report = new BugReport(*BT, - "Only call free if a valid (non-NULL) buffer was returned.", N); + auto Report = llvm::make_unique<BugReport>( + *BT, "Only call free if a valid (non-NULL) buffer was returned.", N); Report->addVisitor(llvm::make_unique<SecKeychainBugVisitor>(ArgSM)); Report->addRange(ArgExpr->getSourceRange()); Report->markInteresting(AS->Region); - C.emitReport(Report); + C.emitReport(std::move(Report)); return; } @@ -519,10 +518,9 @@ MacOSKeychainAPIChecker::getAllocationNode(const ExplodedNode *N, return AllocNode; } -BugReport *MacOSKeychainAPIChecker:: - generateAllocatedDataNotReleasedReport(const AllocationPair &AP, - ExplodedNode *N, - CheckerContext &C) const { +std::unique_ptr<BugReport> +MacOSKeychainAPIChecker::generateAllocatedDataNotReleasedReport( + const AllocationPair &AP, ExplodedNode *N, CheckerContext &C) const { const ADFunctionInfo &FI = FunctionsToTrack[AP.second->AllocatorIdx]; initBugType(); SmallString<70> sbuf; @@ -547,11 +545,12 @@ BugReport *MacOSKeychainAPIChecker:: C.getSourceManager(), AllocNode->getLocationContext()); - BugReport *Report = new BugReport(*BT, os.str(), N, LocUsedForUniqueing, - AllocNode->getLocationContext()->getDecl()); + auto Report = + llvm::make_unique<BugReport>(*BT, os.str(), N, LocUsedForUniqueing, + AllocNode->getLocationContext()->getDecl()); Report->addVisitor(llvm::make_unique<SecKeychainBugVisitor>(AP.first)); - markInteresting(Report, AP); + markInteresting(Report.get(), AP); return Report; } @@ -589,10 +588,8 @@ void MacOSKeychainAPIChecker::checkDeadSymbols(SymbolReaper &SR, ExplodedNode *N = C.addTransition(C.getState(), C.getPredecessor(), &Tag); // Generate the error reports. - for (AllocationPairVec::iterator I = Errors.begin(), E = Errors.end(); - I != E; ++I) { - C.emitReport(generateAllocatedDataNotReleasedReport(*I, N, C)); - } + for (const auto P : Errors) + C.emitReport(generateAllocatedDataNotReleasedReport(P, N, C)); // Generate the new, cleaned up state. C.addTransition(State, N); diff --git a/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp b/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp index 13a401d1e675..11ba6096e2dc 100644 --- a/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp @@ -92,9 +92,9 @@ void MacOSXAPIChecker::CheckDispatchOnce(CheckerContext &C, const CallExpr *CE, if (isa<VarRegion>(R) && isa<StackLocalsSpaceRegion>(R->getMemorySpace())) os << " Perhaps you intended to declare the variable as 'static'?"; - BugReport *report = new BugReport(*BT_dispatchOnce, os.str(), N); + auto report = llvm::make_unique<BugReport>(*BT_dispatchOnce, os.str(), N); report->addRange(CE->getArg(0)->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); } //===----------------------------------------------------------------------===// diff --git a/lib/StaticAnalyzer/Checkers/MallocChecker.cpp b/lib/StaticAnalyzer/Checkers/MallocChecker.cpp index 0cf009407349..a9e08653b241 100644 --- a/lib/StaticAnalyzer/Checkers/MallocChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/MallocChecker.cpp @@ -1619,10 +1619,10 @@ void MallocChecker::ReportBadFree(CheckerContext &C, SVal ArgVal, printExpectedAllocName(os, C, DeallocExpr); - BugReport *R = new BugReport(*BT_BadFree[*CheckKind], os.str(), N); + auto R = llvm::make_unique<BugReport>(*BT_BadFree[*CheckKind], os.str(), N); R->markInteresting(MR); R->addRange(Range); - C.emitReport(R); + C.emitReport(std::move(R)); } } @@ -1643,11 +1643,12 @@ void MallocChecker::ReportFreeAlloca(CheckerContext &C, SVal ArgVal, BT_FreeAlloca[*CheckKind].reset( new BugType(CheckNames[*CheckKind], "Free alloca()", "Memory Error")); - BugReport *R = new BugReport(*BT_FreeAlloca[*CheckKind], - "Memory allocated by alloca() should not be deallocated", N); + auto R = llvm::make_unique<BugReport>( + *BT_FreeAlloca[*CheckKind], + "Memory allocated by alloca() should not be deallocated", N); R->markInteresting(ArgVal.getAsRegion()); R->addRange(Range); - C.emitReport(R); + C.emitReport(std::move(R)); } } @@ -1698,11 +1699,11 @@ void MallocChecker::ReportMismatchedDealloc(CheckerContext &C, os << ", not " << DeallocOs.str(); } - BugReport *R = new BugReport(*BT_MismatchedDealloc, os.str(), N); + auto R = llvm::make_unique<BugReport>(*BT_MismatchedDealloc, os.str(), N); R->markInteresting(Sym); R->addRange(Range); R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym)); - C.emitReport(R); + C.emitReport(std::move(R)); } } @@ -1757,10 +1758,10 @@ void MallocChecker::ReportOffsetFree(CheckerContext &C, SVal ArgVal, else os << "allocated memory"; - BugReport *R = new BugReport(*BT_OffsetFree[*CheckKind], os.str(), N); + auto R = llvm::make_unique<BugReport>(*BT_OffsetFree[*CheckKind], os.str(), N); R->markInteresting(MR->getBaseRegion()); R->addRange(Range); - C.emitReport(R); + C.emitReport(std::move(R)); } void MallocChecker::ReportUseAfterFree(CheckerContext &C, SourceRange Range, @@ -1779,13 +1780,13 @@ void MallocChecker::ReportUseAfterFree(CheckerContext &C, SourceRange Range, BT_UseFree[*CheckKind].reset(new BugType( CheckNames[*CheckKind], "Use-after-free", "Memory Error")); - BugReport *R = new BugReport(*BT_UseFree[*CheckKind], - "Use of memory after it is freed", N); + auto R = llvm::make_unique<BugReport>(*BT_UseFree[*CheckKind], + "Use of memory after it is freed", N); R->markInteresting(Sym); R->addRange(Range); R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym)); - C.emitReport(R); + C.emitReport(std::move(R)); } } @@ -1806,17 +1807,17 @@ void MallocChecker::ReportDoubleFree(CheckerContext &C, SourceRange Range, BT_DoubleFree[*CheckKind].reset( new BugType(CheckNames[*CheckKind], "Double free", "Memory Error")); - BugReport *R = - new BugReport(*BT_DoubleFree[*CheckKind], - (Released ? "Attempt to free released memory" - : "Attempt to free non-owned memory"), - N); + auto R = llvm::make_unique<BugReport>( + *BT_DoubleFree[*CheckKind], + (Released ? "Attempt to free released memory" + : "Attempt to free non-owned memory"), + N); R->addRange(Range); R->markInteresting(Sym); if (PrevSym) R->markInteresting(PrevSym); R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym)); - C.emitReport(R); + C.emitReport(std::move(R)); } } @@ -1834,12 +1835,12 @@ void MallocChecker::ReportDoubleDelete(CheckerContext &C, SymbolRef Sym) const { BT_DoubleDelete.reset(new BugType(CheckNames[CK_NewDeleteChecker], "Double delete", "Memory Error")); - BugReport *R = new BugReport(*BT_DoubleDelete, - "Attempt to delete released memory", N); + auto R = llvm::make_unique<BugReport>( + *BT_DoubleDelete, "Attempt to delete released memory", N); R->markInteresting(Sym); R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym)); - C.emitReport(R); + C.emitReport(std::move(R)); } } @@ -1861,15 +1862,15 @@ void MallocChecker::ReportUseZeroAllocated(CheckerContext &C, BT_UseZerroAllocated[*CheckKind].reset(new BugType( CheckNames[*CheckKind], "Use of zero allocated", "Memory Error")); - BugReport *R = new BugReport(*BT_UseZerroAllocated[*CheckKind], - "Use of zero-allocated memory", N); + auto R = llvm::make_unique<BugReport>(*BT_UseZerroAllocated[*CheckKind], + "Use of zero-allocated memory", N); R->addRange(Range); if (Sym) { R->markInteresting(Sym); R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym)); } - C.emitReport(R); + C.emitReport(std::move(R)); } } @@ -2099,12 +2100,12 @@ void MallocChecker::reportLeak(SymbolRef Sym, ExplodedNode *N, os << "Potential memory leak"; } - BugReport *R = - new BugReport(*BT_Leak[*CheckKind], os.str(), N, LocUsedForUniqueing, - AllocNode->getLocationContext()->getDecl()); + auto R = llvm::make_unique<BugReport>( + *BT_Leak[*CheckKind], os.str(), N, LocUsedForUniqueing, + AllocNode->getLocationContext()->getDecl()); R->markInteresting(Sym); R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym, true)); - C.emitReport(R); + C.emitReport(std::move(R)); } void MallocChecker::checkDeadSymbols(SymbolReaper &SymReaper, diff --git a/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp b/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp index 296aec66805a..fb07484bfcd9 100644 --- a/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp @@ -65,10 +65,9 @@ public: } void VisitChildren(const Stmt *S) { - for (Stmt::const_child_iterator I = S->child_begin(), E = S->child_end(); - I!=E; ++I) - if (const Stmt *child = *I) - VisitChild(S, child); + for (const Stmt *Child : S->children()) + if (Child) + VisitChild(S, Child); } TypeCallPair VisitCastExpr(const CastExpr *E) { diff --git a/lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp b/lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp index b180c03f0871..d23708ecbd97 100644 --- a/lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp @@ -68,10 +68,11 @@ void NSAutoreleasePoolChecker::checkPreObjCMessage(const ObjCMethodCall &msg, return; } - BugReport *Report = new BugReport(*BT, "Use -drain instead of -release when " - "using NSAutoreleasePool and garbage collection", N); + auto Report = llvm::make_unique<BugReport>( + *BT, "Use -drain instead of -release when using NSAutoreleasePool and " + "garbage collection", N); Report->addRange(msg.getSourceRange()); - C.emitReport(Report); + C.emitReport(std::move(Report)); } void ento::registerNSAutoreleasePoolChecker(CheckerManager &mgr) { diff --git a/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp b/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp index 2be7f1d4ab8c..c351c6e9e08b 100644 --- a/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp @@ -275,8 +275,7 @@ void NSOrCFErrorDerefChecker::checkEvent(ImplicitNullDerefEvent event) const { CFBT.reset(new CFErrorDerefBug(this)); bug = CFBT.get(); } - BugReport *report = new BugReport(*bug, os.str(), event.SinkNode); - BR.emitReport(report); + BR.emitReport(llvm::make_unique<BugReport>(*bug, os.str(), event.SinkNode)); } static bool IsNSError(QualType T, IdentifierInfo *II) { diff --git a/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp b/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp index cb2d46b58310..73f8087fd3c0 100644 --- a/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp @@ -36,10 +36,11 @@ public: void checkPreCall(const CallEvent &Call, CheckerContext &C) const; - BugReport *genReportNullAttrNonNull(const ExplodedNode *ErrorN, - const Expr *ArgE) const; - BugReport *genReportReferenceToNullPointer(const ExplodedNode *ErrorN, - const Expr *ArgE) const; + std::unique_ptr<BugReport> + genReportNullAttrNonNull(const ExplodedNode *ErrorN, const Expr *ArgE) const; + std::unique_ptr<BugReport> + genReportReferenceToNullPointer(const ExplodedNode *ErrorN, + const Expr *ArgE) const; }; } // end anonymous namespace @@ -143,7 +144,7 @@ void NonNullParamChecker::checkPreCall(const CallEvent &Call, // we cache out. if (ExplodedNode *errorNode = C.generateSink(stateNull)) { - BugReport *R = nullptr; + std::unique_ptr<BugReport> R; if (haveAttrNonNull) R = genReportNullAttrNonNull(errorNode, ArgE); else if (haveRefTypeParam) @@ -153,7 +154,7 @@ void NonNullParamChecker::checkPreCall(const CallEvent &Call, R->addRange(Call.getArgSourceRange(idx)); // Emit the bug report. - C.emitReport(R); + C.emitReport(std::move(R)); } // Always return. Either we cached out or we just emitted an error. @@ -171,8 +172,9 @@ void NonNullParamChecker::checkPreCall(const CallEvent &Call, C.addTransition(state); } -BugReport *NonNullParamChecker::genReportNullAttrNonNull( - const ExplodedNode *ErrorNode, const Expr *ArgE) const { +std::unique_ptr<BugReport> +NonNullParamChecker::genReportNullAttrNonNull(const ExplodedNode *ErrorNode, + const Expr *ArgE) const { // Lazily allocate the BugType object if it hasn't already been // created. Ownership is transferred to the BugReporter object once // the BugReport is passed to 'EmitWarning'. @@ -180,23 +182,22 @@ BugReport *NonNullParamChecker::genReportNullAttrNonNull( BTAttrNonNull.reset(new BugType( this, "Argument with 'nonnull' attribute passed null", "API")); - BugReport *R = new BugReport(*BTAttrNonNull, - "Null pointer passed as an argument to a 'nonnull' parameter", - ErrorNode); + auto R = llvm::make_unique<BugReport>( + *BTAttrNonNull, + "Null pointer passed as an argument to a 'nonnull' parameter", ErrorNode); if (ArgE) bugreporter::trackNullOrUndefValue(ErrorNode, ArgE, *R); return R; } -BugReport *NonNullParamChecker::genReportReferenceToNullPointer( - const ExplodedNode *ErrorNode, const Expr *ArgE) const { +std::unique_ptr<BugReport> NonNullParamChecker::genReportReferenceToNullPointer( + const ExplodedNode *ErrorNode, const Expr *ArgE) const { if (!BTNullRefArg) BTNullRefArg.reset(new BuiltinBug(this, "Dereference of null pointer")); - BugReport *R = new BugReport(*BTNullRefArg, - "Forming reference to null pointer", - ErrorNode); + auto R = llvm::make_unique<BugReport>( + *BTNullRefArg, "Forming reference to null pointer", ErrorNode); if (ArgE) { const Expr *ArgEDeref = bugreporter::getDerefExpr(ArgE); if (!ArgEDeref) diff --git a/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp b/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp index fbf2d73dd86c..a7b92b4c67f2 100644 --- a/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp @@ -47,10 +47,10 @@ void ObjCAtSyncChecker::checkPreStmt(const ObjCAtSynchronizedStmt *S, if (!BT_undef) BT_undef.reset(new BuiltinBug(this, "Uninitialized value used as mutex " "for @synchronized")); - BugReport *report = - new BugReport(*BT_undef, BT_undef->getDescription(), N); + auto report = + llvm::make_unique<BugReport>(*BT_undef, BT_undef->getDescription(), N); bugreporter::trackNullOrUndefValue(N, Ex, *report); - C.emitReport(report); + C.emitReport(std::move(report)); } return; } @@ -71,11 +71,11 @@ void ObjCAtSyncChecker::checkPreStmt(const ObjCAtSynchronizedStmt *S, BT_null.reset(new BuiltinBug( this, "Nil value used as mutex for @synchronized() " "(no synchronization will occur)")); - BugReport *report = - new BugReport(*BT_null, BT_null->getDescription(), N); + auto report = + llvm::make_unique<BugReport>(*BT_null, BT_null->getDescription(), N); bugreporter::trackNullOrUndefValue(N, Ex, *report); - C.emitReport(report); + C.emitReport(std::move(report)); return; } } diff --git a/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp b/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp index e3fc611a7e00..224251beb09a 100644 --- a/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp @@ -153,9 +153,9 @@ void WalkAST::VisitCallExpr(CallExpr *CE) { } void WalkAST::VisitChildren(Stmt *S) { - for (Stmt::child_iterator I = S->child_begin(), E = S->child_end(); I!=E; ++I) - if (Stmt *child = *I) - Visit(child); + for (Stmt *Child : S->children()) + if (Child) + Visit(Child); } namespace { diff --git a/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp b/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp index 4f0b7e51da10..53e159879eb2 100644 --- a/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp @@ -143,9 +143,9 @@ void ObjCContainersChecker::checkPreStmt(const CallExpr *CE, if (!N) return; initBugType(); - BugReport *R = new BugReport(*BT, "Index is out of bounds", N); + auto R = llvm::make_unique<BugReport>(*BT, "Index is out of bounds", N); R->addRange(IdxExpr->getSourceRange()); - C.emitReport(R); + C.emitReport(std::move(R)); return; } } diff --git a/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp b/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp index 51bc7e66dce2..93b0553b3b72 100644 --- a/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp @@ -160,8 +160,7 @@ void ObjCSelfInitChecker::checkForInvalidSelf(const Expr *E, CheckerContext &C, if (!BT) BT.reset(new BugType(this, "Missing \"self = [(super or self) init...]\"", categories::CoreFoundationObjectiveC)); - BugReport *report = new BugReport(*BT, errorStr, N); - C.emitReport(report); + C.emitReport(llvm::make_unique<BugReport>(*BT, errorStr, N)); } void ObjCSelfInitChecker::checkPostObjCMessage(const ObjCMethodCall &Msg, diff --git a/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp b/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp index d3b17534fdac..c6da37eac0c0 100644 --- a/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp @@ -57,8 +57,8 @@ static void Scan(IvarUsageMap& M, const Stmt *S) { Scan(M, sub); } - for (Stmt::const_child_iterator I=S->child_begin(),E=S->child_end(); I!=E;++I) - Scan(M, *I); + for (const Stmt *SubStmt : S->children()) + Scan(M, SubStmt); } static void Scan(IvarUsageMap& M, const ObjCPropertyImplDecl *D) { diff --git a/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp b/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp index 00480e4abf12..806312468beb 100644 --- a/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp @@ -58,9 +58,9 @@ void PointerArithChecker::checkPreStmt(const BinaryOperator *B, "Pointer arithmetic done on non-array variables " "means reliance on memory layout, which is " "dangerous.")); - BugReport *R = new BugReport(*BT, BT->getDescription(), N); + auto R = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N); R->addRange(B->getSourceRange()); - C.emitReport(R); + C.emitReport(std::move(R)); } } } diff --git a/lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp b/lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp index fbb2628a9ce5..cf1f88a2851b 100644 --- a/lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp @@ -66,9 +66,9 @@ void PointerSubChecker::checkPreStmt(const BinaryOperator *B, new BuiltinBug(this, "Pointer subtraction", "Subtraction of two pointers that do not point to " "the same memory chunk may cause incorrect result.")); - BugReport *R = new BugReport(*BT, BT->getDescription(), N); + auto R = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N); R->addRange(B->getSourceRange()); - C.emitReport(R); + C.emitReport(std::move(R)); } } diff --git a/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp b/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp index 1ede3a2a5126..4209017a58d5 100644 --- a/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp @@ -145,11 +145,10 @@ void PthreadLockChecker::AcquireLock(CheckerContext &C, const CallExpr *CE, ExplodedNode *N = C.generateSink(); if (!N) return; - BugReport *report = new BugReport(*BT_doublelock, - "This lock has already been acquired", - N); + auto report = llvm::make_unique<BugReport>( + *BT_doublelock, "This lock has already been acquired", N); report->addRange(CE->getArg(0)->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); return; } else if (LState->isDestroyed()) { reportUseDestroyedBug(C, CE); @@ -208,11 +207,10 @@ void PthreadLockChecker::ReleaseLock(CheckerContext &C, const CallExpr *CE, ExplodedNode *N = C.generateSink(); if (!N) return; - BugReport *Report = new BugReport(*BT_doubleunlock, - "This lock has already been unlocked", - N); + auto Report = llvm::make_unique<BugReport>( + *BT_doubleunlock, "This lock has already been unlocked", N); Report->addRange(CE->getArg(0)->getSourceRange()); - C.emitReport(Report); + C.emitReport(std::move(Report)); return; } else if (LState->isDestroyed()) { reportUseDestroyedBug(C, CE); @@ -232,13 +230,11 @@ void PthreadLockChecker::ReleaseLock(CheckerContext &C, const CallExpr *CE, ExplodedNode *N = C.generateSink(); if (!N) return; - BugReport *report = new BugReport(*BT_lor, - "This was not the most recently " - "acquired lock. Possible lock order " - "reversal", - N); + auto report = llvm::make_unique<BugReport>( + *BT_lor, "This was not the most recently acquired lock. Possible " + "lock order reversal", N); report->addRange(CE->getArg(0)->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); return; } // Record that the lock was released. @@ -279,9 +275,9 @@ void PthreadLockChecker::DestroyLock(CheckerContext &C, const CallExpr *CE, ExplodedNode *N = C.generateSink(); if (!N) return; - BugReport *Report = new BugReport(*BT_destroylock, Message, N); + auto Report = llvm::make_unique<BugReport>(*BT_destroylock, Message, N); Report->addRange(CE->getArg(0)->getSourceRange()); - C.emitReport(Report); + C.emitReport(std::move(Report)); } void PthreadLockChecker::InitLock(CheckerContext &C, const CallExpr *CE, @@ -314,9 +310,9 @@ void PthreadLockChecker::InitLock(CheckerContext &C, const CallExpr *CE, ExplodedNode *N = C.generateSink(); if (!N) return; - BugReport *Report = new BugReport(*BT_initlock, Message, N); + auto Report = llvm::make_unique<BugReport>(*BT_initlock, Message, N); Report->addRange(CE->getArg(0)->getSourceRange()); - C.emitReport(Report); + C.emitReport(std::move(Report)); } void PthreadLockChecker::reportUseDestroyedBug(CheckerContext &C, @@ -327,11 +323,10 @@ void PthreadLockChecker::reportUseDestroyedBug(CheckerContext &C, ExplodedNode *N = C.generateSink(); if (!N) return; - BugReport *Report = new BugReport(*BT_destroylock, - "This lock has already been destroyed", - N); + auto Report = llvm::make_unique<BugReport>( + *BT_destroylock, "This lock has already been destroyed", N); Report->addRange(CE->getArg(0)->getSourceRange()); - C.emitReport(Report); + C.emitReport(std::move(Report)); } void ento::registerPthreadLockChecker(CheckerManager &mgr) { diff --git a/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp b/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp index 49eef236e906..6ee87a561e02 100644 --- a/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp @@ -2182,9 +2182,8 @@ PathDiagnosticPiece *CFRefReportVisitor::VisitNode(const ExplodedNode *N, // Add the range by scanning the children of the statement for any bindings // to Sym. - for (Stmt::const_child_iterator I = S->child_begin(), E = S->child_end(); - I!=E; ++I) - if (const Expr *Exp = dyn_cast_or_null<Expr>(*I)) + for (const Stmt *Child : S->children()) + if (const Expr *Exp = dyn_cast_or_null<Expr>(Child)) if (CurrSt->getSValAsScalarOrLoc(Exp, LCtx).getAsLocSymbol() == Sym) { P->addRange(Exp->getSourceRange()); break; @@ -2779,16 +2778,14 @@ void RetainCountChecker::processObjCLiterals(CheckerContext &C, const Expr *Ex) const { ProgramStateRef state = C.getState(); const ExplodedNode *pred = C.getPredecessor(); - for (Stmt::const_child_iterator it = Ex->child_begin(), et = Ex->child_end() ; - it != et ; ++it) { - const Stmt *child = *it; - SVal V = state->getSVal(child, pred->getLocationContext()); + for (const Stmt *Child : Ex->children()) { + SVal V = state->getSVal(Child, pred->getLocationContext()); if (SymbolRef sym = V.getAsSymbol()) if (const RefVal* T = getRefBinding(state, sym)) { RefVal::Kind hasErr = (RefVal::Kind) 0; state = updateSymbol(state, sym, *T, MayEscape, hasErr, C); if (hasErr) { - processNonLeakError(state, child->getSourceRange(), hasErr, sym, C); + processNonLeakError(state, Child->getSourceRange(), hasErr, sym, C); return; } } @@ -3320,31 +3317,31 @@ void RetainCountChecker::processNonLeakError(ProgramStateRef St, case RefVal::ErrorUseAfterRelease: if (!useAfterRelease) useAfterRelease.reset(new UseAfterRelease(this)); - BT = &*useAfterRelease; + BT = useAfterRelease.get(); break; case RefVal::ErrorReleaseNotOwned: if (!releaseNotOwned) releaseNotOwned.reset(new BadRelease(this)); - BT = &*releaseNotOwned; + BT = releaseNotOwned.get(); break; case RefVal::ErrorDeallocGC: if (!deallocGC) deallocGC.reset(new DeallocGC(this)); - BT = &*deallocGC; + BT = deallocGC.get(); break; case RefVal::ErrorDeallocNotOwned: if (!deallocNotOwned) deallocNotOwned.reset(new DeallocNotOwned(this)); - BT = &*deallocNotOwned; + BT = deallocNotOwned.get(); break; } assert(BT); - CFRefReport *report = new CFRefReport(*BT, C.getASTContext().getLangOpts(), - C.isObjCGCEnabled(), SummaryLog, - N, Sym); + auto report = std::unique_ptr<BugReport>( + new CFRefReport(*BT, C.getASTContext().getLangOpts(), C.isObjCGCEnabled(), + SummaryLog, N, Sym)); report->addRange(ErrorRange); - C.emitReport(report); + C.emitReport(std::move(report)); } //===----------------------------------------------------------------------===// @@ -3573,12 +3570,9 @@ void RetainCountChecker::checkReturnWithRetEffect(const ReturnStmt *S, if (N) { const LangOptions &LOpts = C.getASTContext().getLangOpts(); bool GCEnabled = C.isObjCGCEnabled(); - CFRefReport *report = - new CFRefLeakReport(*getLeakAtReturnBug(LOpts, GCEnabled), - LOpts, GCEnabled, SummaryLog, - N, Sym, C, IncludeAllocationLine); - - C.emitReport(report); + C.emitReport(std::unique_ptr<BugReport>(new CFRefLeakReport( + *getLeakAtReturnBug(LOpts, GCEnabled), LOpts, GCEnabled, + SummaryLog, N, Sym, C, IncludeAllocationLine))); } } } @@ -3603,11 +3597,9 @@ void RetainCountChecker::checkReturnWithRetEffect(const ReturnStmt *S, if (!returnNotOwnedForOwned) returnNotOwnedForOwned.reset(new ReturnedNotOwnedForOwned(this)); - CFRefReport *report = - new CFRefReport(*returnNotOwnedForOwned, - C.getASTContext().getLangOpts(), - C.isObjCGCEnabled(), SummaryLog, N, Sym); - C.emitReport(report); + C.emitReport(std::unique_ptr<BugReport>(new CFRefReport( + *returnNotOwnedForOwned, C.getASTContext().getLangOpts(), + C.isObjCGCEnabled(), SummaryLog, N, Sym))); } } } @@ -3810,10 +3802,9 @@ RetainCountChecker::handleAutoreleaseCounts(ProgramStateRef state, overAutorelease.reset(new OverAutorelease(this)); const LangOptions &LOpts = Ctx.getASTContext().getLangOpts(); - CFRefReport *report = - new CFRefReport(*overAutorelease, LOpts, /* GCEnabled = */ false, - SummaryLog, N, Sym, os.str()); - Ctx.emitReport(report); + Ctx.emitReport(std::unique_ptr<BugReport>( + new CFRefReport(*overAutorelease, LOpts, /* GCEnabled = */ false, + SummaryLog, N, Sym, os.str()))); } return nullptr; @@ -3865,10 +3856,9 @@ RetainCountChecker::processLeaks(ProgramStateRef state, : getLeakAtReturnBug(LOpts, GCEnabled); assert(BT && "BugType not initialized."); - CFRefLeakReport *report = new CFRefLeakReport(*BT, LOpts, GCEnabled, - SummaryLog, N, *I, Ctx, - IncludeAllocationLine); - Ctx.emitReport(report); + Ctx.emitReport(std::unique_ptr<BugReport>( + new CFRefLeakReport(*BT, LOpts, GCEnabled, SummaryLog, N, *I, Ctx, + IncludeAllocationLine))); } } diff --git a/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp b/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp index b1cde6b897cb..acbd0d95d07b 100644 --- a/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp @@ -80,11 +80,10 @@ void ReturnPointerRangeChecker::checkPreStmt(const ReturnStmt *RS, // reference is outside the range. // Generate a report for this bug. - BugReport *report = - new BugReport(*BT, BT->getDescription(), N); + auto report = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N); report->addRange(RetE->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); } } diff --git a/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp b/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp index 6622313c991f..2668ac1e1eca 100644 --- a/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp @@ -84,12 +84,12 @@ static void emitBug(CheckerContext &C, BuiltinBug &BT, const Expr *RetE, if (!N) return; - BugReport *Report = new BugReport(BT, BT.getDescription(), N); + auto Report = llvm::make_unique<BugReport>(BT, BT.getDescription(), N); Report->addRange(RetE->getSourceRange()); bugreporter::trackNullOrUndefValue(N, TrackingE ? TrackingE : RetE, *Report); - C.emitReport(Report); + C.emitReport(std::move(Report)); } void ReturnUndefChecker::emitUndef(CheckerContext &C, const Expr *RetE) const { diff --git a/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp b/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp index ccf816c80c1e..c22e78b7eb62 100644 --- a/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp @@ -214,11 +214,11 @@ void SimpleStreamChecker::reportDoubleClose(SymbolRef FileDescSym, return; // Generate the report. - BugReport *R = new BugReport(*DoubleCloseBugType, + auto R = llvm::make_unique<BugReport>(*DoubleCloseBugType, "Closing a previously closed file stream", ErrNode); R->addRange(Call.getSourceRange()); R->markInteresting(FileDescSym); - C.emitReport(R); + C.emitReport(std::move(R)); } void SimpleStreamChecker::reportLeaks(ArrayRef<SymbolRef> LeakedStreams, @@ -227,10 +227,10 @@ void SimpleStreamChecker::reportLeaks(ArrayRef<SymbolRef> LeakedStreams, // Attach bug reports to the leak node. // TODO: Identify the leaked file descriptor. for (SymbolRef LeakedStream : LeakedStreams) { - BugReport *R = new BugReport(*LeakBugType, + auto R = llvm::make_unique<BugReport>(*LeakBugType, "Opened file is never closed; potential resource leak", ErrNode); R->markInteresting(LeakedStream); - C.emitReport(R); + C.emitReport(std::move(R)); } } diff --git a/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp b/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp index 327a9e0ac435..813c811ef15f 100644 --- a/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp @@ -108,12 +108,12 @@ void StackAddrEscapeChecker::EmitStackError(CheckerContext &C, const MemRegion * llvm::raw_svector_ostream os(buf); SourceRange range = genName(os, R, C.getASTContext()); os << " returned to caller"; - BugReport *report = new BugReport(*BT_returnstack, os.str(), N); + auto report = llvm::make_unique<BugReport>(*BT_returnstack, os.str(), N); report->addRange(RetE->getSourceRange()); if (range.isValid()) report->addRange(range); - C.emitReport(report); + C.emitReport(std::move(report)); } void StackAddrEscapeChecker::checkPreStmt(const ReturnStmt *RS, @@ -231,11 +231,11 @@ void StackAddrEscapeChecker::checkEndFunction(CheckerContext &Ctx) const { const VarRegion *VR = cast<VarRegion>(cb.V[i].first->getBaseRegion()); os << *VR->getDecl() << "' upon returning to the caller. This will be a dangling reference"; - BugReport *report = new BugReport(*BT_stackleak, os.str(), N); + auto report = llvm::make_unique<BugReport>(*BT_stackleak, os.str(), N); if (range.isValid()) report->addRange(range); - Ctx.emitReport(report); + Ctx.emitReport(std::move(report)); } } diff --git a/lib/StaticAnalyzer/Checkers/StreamChecker.cpp b/lib/StaticAnalyzer/Checkers/StreamChecker.cpp index 894765a785ea..2109a75b1fb6 100644 --- a/lib/StaticAnalyzer/Checkers/StreamChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/StreamChecker.cpp @@ -277,9 +277,8 @@ void StreamChecker::Fseek(CheckerContext &C, const CallExpr *CE) const { new BuiltinBug(this, "Illegal whence argument", "The whence argument to fseek() should be " "SEEK_SET, SEEK_END, or SEEK_CUR.")); - BugReport *R = new BugReport(*BT_illegalwhence, - BT_illegalwhence->getDescription(), N); - C.emitReport(R); + C.emitReport(llvm::make_unique<BugReport>( + *BT_illegalwhence, BT_illegalwhence->getDescription(), N)); } } @@ -354,8 +353,8 @@ ProgramStateRef StreamChecker::CheckNullStream(SVal SV, ProgramStateRef state, if (!BT_nullfp) BT_nullfp.reset(new BuiltinBug(this, "NULL stream pointer", "Stream pointer might be NULL.")); - BugReport *R =new BugReport(*BT_nullfp, BT_nullfp->getDescription(), N); - C.emitReport(R); + C.emitReport(llvm::make_unique<BugReport>( + *BT_nullfp, BT_nullfp->getDescription(), N)); } return nullptr; } @@ -385,9 +384,8 @@ ProgramStateRef StreamChecker::CheckDoubleClose(const CallExpr *CE, BT_doubleclose.reset(new BuiltinBug( this, "Double fclose", "Try to close a file Descriptor already" " closed. Cause undefined behaviour.")); - BugReport *R = new BugReport(*BT_doubleclose, - BT_doubleclose->getDescription(), N); - C.emitReport(R); + C.emitReport(llvm::make_unique<BugReport>( + *BT_doubleclose, BT_doubleclose->getDescription(), N)); } return nullptr; } @@ -414,9 +412,8 @@ void StreamChecker::checkDeadSymbols(SymbolReaper &SymReaper, BT_ResourceLeak.reset(new BuiltinBug( this, "Resource Leak", "Opened File never closed. Potential Resource leak.")); - BugReport *R = new BugReport(*BT_ResourceLeak, - BT_ResourceLeak->getDescription(), N); - C.emitReport(R); + C.emitReport(llvm::make_unique<BugReport>( + *BT_ResourceLeak, BT_ResourceLeak->getDescription(), N)); } } } diff --git a/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp b/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp index d33c977826a5..6e2477579f55 100644 --- a/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp @@ -50,9 +50,9 @@ void TaintTesterChecker::checkPostStmt(const Expr *E, if (State->isTainted(E, C.getLocationContext())) { if (ExplodedNode *N = C.addTransition()) { initBugType(); - BugReport *report = new BugReport(*BT, "tainted",N); + auto report = llvm::make_unique<BugReport>(*BT, "tainted",N); report->addRange(E->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); } } } diff --git a/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp b/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp index 083075db8fb9..638701da8a01 100644 --- a/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp @@ -171,14 +171,14 @@ void TestAfterDivZeroChecker::reportBug(SVal Val, CheckerContext &C) const { if (!DivZeroBug) DivZeroBug.reset(new BuiltinBug(this, "Division by zero")); - BugReport *R = - new BugReport(*DivZeroBug, "Value being compared against zero has " - "already been used for division", - N); + auto R = llvm::make_unique<BugReport>( + *DivZeroBug, "Value being compared against zero has already been used " + "for division", + N); R->addVisitor(llvm::make_unique<DivisionBRVisitor>(Val.getAsSymbol(), C.getStackFrame())); - C.emitReport(R); + C.emitReport(std::move(R)); } } diff --git a/lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp b/lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp index fc49a46eae58..1d8ef9947175 100644 --- a/lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp @@ -37,12 +37,10 @@ class UndefBranchChecker : public Checker<check::BranchCondition> { if (!MatchesCriteria(Ex)) return nullptr; - for (Stmt::const_child_iterator I = Ex->child_begin(), - E = Ex->child_end();I!=E;++I) - if (const Expr *ExI = dyn_cast_or_null<Expr>(*I)) { - const Expr *E2 = FindExpr(ExI); - if (E2) return E2; - } + for (const Stmt *SubStmt : Ex->children()) + if (const Expr *ExI = dyn_cast_or_null<Expr>(SubStmt)) + if (const Expr *E2 = FindExpr(ExI)) + return E2; return Ex; } @@ -98,11 +96,11 @@ void UndefBranchChecker::checkBranchCondition(const Stmt *Condition, Ex = FindIt.FindExpr(Ex); // Emit the bug report. - BugReport *R = new BugReport(*BT, BT->getDescription(), N); + auto R = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N); bugreporter::trackNullOrUndefValue(N, Ex, *R); R->addRange(Ex->getSourceRange()); - Ctx.emitReport(R); + Ctx.emitReport(std::move(R)); } } } diff --git a/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp b/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp index 8976e0a699ec..53fd069bf150 100644 --- a/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp @@ -40,13 +40,10 @@ static const DeclRefExpr *FindBlockDeclRefExpr(const Stmt *S, if (BR->getDecl() == VD) return BR; - for (Stmt::const_child_iterator I = S->child_begin(), E = S->child_end(); - I!=E; ++I) - if (const Stmt *child = *I) { - const DeclRefExpr *BR = FindBlockDeclRefExpr(child, VD); - if (BR) + for (const Stmt *Child : S->children()) + if (Child) + if (const DeclRefExpr *BR = FindBlockDeclRefExpr(Child, VD)) return BR; - } return nullptr; } @@ -89,14 +86,14 @@ UndefCapturedBlockVarChecker::checkPostStmt(const BlockExpr *BE, os << "Variable '" << VD->getName() << "' is uninitialized when captured by block"; - BugReport *R = new BugReport(*BT, os.str(), N); + auto R = llvm::make_unique<BugReport>(*BT, os.str(), N); if (const Expr *Ex = FindBlockDeclRefExpr(BE->getBody(), VD)) R->addRange(Ex->getSourceRange()); R->addVisitor(llvm::make_unique<FindLastStoreBRVisitor>( *V, VR, /*EnableNullFPSuppression*/ false)); R->disablePathPruning(); // need location of block - C.emitReport(R); + C.emitReport(std::move(R)); } } } diff --git a/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp b/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp index f3f4dce8b17d..5353310e6d5a 100644 --- a/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp @@ -84,7 +84,7 @@ void UndefResultChecker::checkPostStmt(const BinaryOperator *B, << BinaryOperator::getOpcodeStr(B->getOpcode()) << "' expression is undefined"; } - BugReport *report = new BugReport(*BT, OS.str(), N); + auto report = llvm::make_unique<BugReport>(*BT, OS.str(), N); if (Ex) { report->addRange(Ex->getSourceRange()); bugreporter::trackNullOrUndefValue(N, Ex, *report); @@ -92,7 +92,7 @@ void UndefResultChecker::checkPostStmt(const BinaryOperator *B, else bugreporter::trackNullOrUndefValue(N, B, *report); - C.emitReport(report); + C.emitReport(std::move(report)); } } diff --git a/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp b/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp index e952671efffc..ba4daf835148 100644 --- a/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp @@ -53,10 +53,10 @@ UndefinedArraySubscriptChecker::checkPreStmt(const ArraySubscriptExpr *A, BT.reset(new BuiltinBug(this, "Array subscript is undefined")); // Generate a report for this bug. - BugReport *R = new BugReport(*BT, BT->getName(), N); + auto R = llvm::make_unique<BugReport>(*BT, BT->getName(), N); R->addRange(A->getIdx()->getSourceRange()); bugreporter::trackNullOrUndefValue(N, A->getIdx(), *R); - C.emitReport(R); + C.emitReport(std::move(R)); } void ento::registerUndefinedArraySubscriptChecker(CheckerManager &mgr) { diff --git a/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp b/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp index bd4493d55605..81c96c4860bc 100644 --- a/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp @@ -83,12 +83,12 @@ void UndefinedAssignmentChecker::checkBind(SVal location, SVal val, break; } - BugReport *R = new BugReport(*BT, str, N); + auto R = llvm::make_unique<BugReport>(*BT, str, N); if (ex) { R->addRange(ex->getSourceRange()); bugreporter::trackNullOrUndefValue(N, ex, *R); } - C.emitReport(R); + C.emitReport(std::move(R)); } void ento::registerUndefinedAssignmentChecker(CheckerManager &mgr) { diff --git a/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp b/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp index 4bfed8504f98..a799b4c21982 100644 --- a/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp @@ -83,9 +83,9 @@ void UnixAPIChecker::ReportOpenBug(CheckerContext &C, LazyInitialize(BT_open, "Improper use of 'open'"); - BugReport *Report = new BugReport(*BT_open, Msg, N); + auto Report = llvm::make_unique<BugReport>(*BT_open, Msg, N); Report->addRange(SR); - C.emitReport(Report); + C.emitReport(std::move(Report)); } void UnixAPIChecker::CheckOpen(CheckerContext &C, const CallExpr *CE) const { @@ -200,9 +200,9 @@ void UnixAPIChecker::CheckPthreadOnce(CheckerContext &C, LazyInitialize(BT_pthreadOnce, "Improper use of 'pthread_once'"); - BugReport *report = new BugReport(*BT_pthreadOnce, os.str(), N); + auto report = llvm::make_unique<BugReport>(*BT_pthreadOnce, os.str(), N); report->addRange(CE->getArg(0)->getSourceRange()); - C.emitReport(report); + C.emitReport(std::move(report)); } //===----------------------------------------------------------------------===// @@ -241,11 +241,11 @@ bool UnixAPIChecker::ReportZeroByteAllocation(CheckerContext &C, SmallString<256> S; llvm::raw_svector_ostream os(S); os << "Call to '" << fn_name << "' has an allocation size of 0 bytes"; - BugReport *report = new BugReport(*BT_mallocZero, os.str(), N); + auto report = llvm::make_unique<BugReport>(*BT_mallocZero, os.str(), N); report->addRange(arg->getSourceRange()); bugreporter::trackNullOrUndefValue(N, arg, *report); - C.emitReport(report); + C.emitReport(std::move(report)); return true; } diff --git a/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp b/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp index cceffef82b36..80384bbfdb30 100644 --- a/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp @@ -72,10 +72,10 @@ void VLASizeChecker::reportBug(VLASize_Kind Kind, break; } - BugReport *report = new BugReport(*BT, os.str(), N); + auto report = llvm::make_unique<BugReport>(*BT, os.str(), N); report->addRange(SizeE->getSourceRange()); bugreporter::trackNullOrUndefValue(N, SizeE, *report); - C.emitReport(report); + C.emitReport(std::move(report)); return; } diff --git a/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp b/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp index 7e1fc1eb54ad..f6ef4aef5c78 100644 --- a/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp @@ -125,9 +125,9 @@ public: //===----------------------------------------------------------------------===// void WalkAST::VisitChildren(Stmt *S) { - for (Stmt::child_iterator I = S->child_begin(), E = S->child_end(); I!=E; ++I) - if (Stmt *child = *I) - Visit(child); + for (Stmt *Child : S->children()) + if (Child) + Visit(Child); } void WalkAST::VisitCallExpr(CallExpr *CE) { diff --git a/lib/StaticAnalyzer/Core/BasicValueFactory.cpp b/lib/StaticAnalyzer/Core/BasicValueFactory.cpp index 0e90566839ca..3c3f41a885e9 100644 --- a/lib/StaticAnalyzer/Core/BasicValueFactory.cpp +++ b/lib/StaticAnalyzer/Core/BasicValueFactory.cpp @@ -154,9 +154,13 @@ BasicValueFactory::evalAPSInt(BinaryOperator::Opcode Op, return &getValue( V1 * V2 ); case BO_Div: + if (V2 == 0) // Avoid division by zero + return nullptr; return &getValue( V1 / V2 ); case BO_Rem: + if (V2 == 0) // Avoid division by zero + return nullptr; return &getValue( V1 % V2 ); case BO_Add: diff --git a/lib/StaticAnalyzer/Core/BugReporter.cpp b/lib/StaticAnalyzer/Core/BugReporter.cpp index 97e97ef8c4d6..e4db64fe34e0 100644 --- a/lib/StaticAnalyzer/Core/BugReporter.cpp +++ b/lib/StaticAnalyzer/Core/BugReporter.cpp @@ -1250,10 +1250,8 @@ static void reversePropagateIntererstingSymbols(BugReport &R, // Fall through. case Stmt::BinaryOperatorClass: case Stmt::UnaryOperatorClass: { - for (Stmt::const_child_iterator CI = Ex->child_begin(), - CE = Ex->child_end(); - CI != CE; ++CI) { - if (const Expr *child = dyn_cast_or_null<Expr>(*CI)) { + for (const Stmt *SubStmt : Ex->children()) { + if (const Expr *child = dyn_cast_or_null<Expr>(SubStmt)) { IE.insert(child); SVal ChildV = State->getSVal(child, LCtx); R.markInteresting(ChildV); @@ -3224,10 +3222,7 @@ void BugReporter::Register(BugType *BT) { BugTypes = F.add(BugTypes, BT); } -void BugReporter::emitReport(BugReport* R) { - // To guarantee memory release. - std::unique_ptr<BugReport> UniqueR(R); - +void BugReporter::emitReport(std::unique_ptr<BugReport> R) { if (const ExplodedNode *E = R->getErrorNode()) { const AnalysisDeclContext *DeclCtx = E->getLocationContext()->getAnalysisDeclContext(); @@ -3258,11 +3253,11 @@ void BugReporter::emitReport(BugReport* R) { BugReportEquivClass* EQ = EQClasses.FindNodeOrInsertPos(ID, InsertPos); if (!EQ) { - EQ = new BugReportEquivClass(std::move(UniqueR)); + EQ = new BugReportEquivClass(std::move(R)); EQClasses.InsertNode(EQ, InsertPos); EQClassesVector.push_back(EQ); } else - EQ->AddReport(std::move(UniqueR)); + EQ->AddReport(std::move(R)); } @@ -3462,12 +3457,12 @@ void BugReporter::EmitBasicReport(const Decl *DeclWithIssue, // 'BT' is owned by BugReporter. BugType *BT = getBugTypeForName(CheckName, name, category); - BugReport *R = new BugReport(*BT, str, Loc); + auto R = llvm::make_unique<BugReport>(*BT, str, Loc); R->setDeclWithIssue(DeclWithIssue); for (ArrayRef<SourceRange>::iterator I = Ranges.begin(), E = Ranges.end(); I != E; ++I) R->addRange(*I); - emitReport(R); + emitReport(std::move(R)); } BugType *BugReporter::getBugTypeForName(CheckName CheckName, StringRef name, diff --git a/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp b/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp index fa7884f4a462..f2915ed818b2 100644 --- a/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp +++ b/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp @@ -1130,9 +1130,8 @@ void FindLastStoreBRVisitor::registerStatementVarDecls(BugReport &BR, } } - for (Stmt::const_child_iterator I = Head->child_begin(); - I != Head->child_end(); ++I) - WorkList.push_back(*I); + for (const Stmt *SubStmt : Head->children()) + WorkList.push_back(SubStmt); } } diff --git a/lib/StaticAnalyzer/Core/CheckerHelpers.cpp b/lib/StaticAnalyzer/Core/CheckerHelpers.cpp index 28df6959aff5..3d9a81581549 100644 --- a/lib/StaticAnalyzer/Core/CheckerHelpers.cpp +++ b/lib/StaticAnalyzer/Core/CheckerHelpers.cpp @@ -22,11 +22,9 @@ bool clang::ento::containsMacro(const Stmt *S) { if (S->getLocEnd().isMacroID()) return true; - for (Stmt::const_child_iterator I = S->child_begin(); I != S->child_end(); - ++I) - if (const Stmt *child = *I) - if (containsMacro(child)) - return true; + for (const Stmt *Child : S->children()) + if (Child && containsMacro(Child)) + return true; return false; } @@ -38,11 +36,9 @@ bool clang::ento::containsEnum(const Stmt *S) { if (DR && isa<EnumConstantDecl>(DR->getDecl())) return true; - for (Stmt::const_child_iterator I = S->child_begin(); I != S->child_end(); - ++I) - if (const Stmt *child = *I) - if (containsEnum(child)) - return true; + for (const Stmt *Child : S->children()) + if (Child && containsEnum(Child)) + return true; return false; } @@ -56,11 +52,9 @@ bool clang::ento::containsStaticLocal(const Stmt *S) { if (VD->isStaticLocal()) return true; - for (Stmt::const_child_iterator I = S->child_begin(); I != S->child_end(); - ++I) - if (const Stmt *child = *I) - if (containsStaticLocal(child)) - return true; + for (const Stmt *Child : S->children()) + if (Child && containsStaticLocal(Child)) + return true; return false; } @@ -70,11 +64,9 @@ bool clang::ento::containsBuiltinOffsetOf(const Stmt *S) { if (isa<OffsetOfExpr>(S)) return true; - for (Stmt::const_child_iterator I = S->child_begin(); I != S->child_end(); - ++I) - if (const Stmt *child = *I) - if (containsBuiltinOffsetOf(child)) - return true; + for (const Stmt *Child : S->children()) + if (Child && containsBuiltinOffsetOf(Child)) + return true; return false; } diff --git a/lib/StaticAnalyzer/Core/ExprEngine.cpp b/lib/StaticAnalyzer/Core/ExprEngine.cpp index ef515fb5937b..a3239f591a38 100644 --- a/lib/StaticAnalyzer/Core/ExprEngine.cpp +++ b/lib/StaticAnalyzer/Core/ExprEngine.cpp @@ -822,6 +822,8 @@ void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred, case Stmt::OMPAtomicDirectiveClass: case Stmt::OMPTargetDirectiveClass: case Stmt::OMPTeamsDirectiveClass: + case Stmt::OMPCancellationPointDirectiveClass: + case Stmt::OMPCancelDirectiveClass: llvm_unreachable("Stmt should not be in analyzer evaluation loop"); case Stmt::ObjCSubscriptRefExprClass: diff --git a/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp b/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp index fbeffb8aac80..c957a654a84c 100644 --- a/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp +++ b/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp @@ -588,7 +588,10 @@ AnalysisConsumer::getModeForDecl(Decl *D, AnalysisMode Mode) { // - Header files: run non-path-sensitive checks only. // - System headers: don't run any checks. SourceManager &SM = Ctx->getSourceManager(); - SourceLocation SL = SM.getExpansionLoc(D->getLocation()); + SourceLocation SL = D->hasBody() ? D->getBody()->getLocStart() + : D->getLocation(); + SL = SM.getExpansionLoc(SL); + if (!Opts->AnalyzeAll && !SM.isWrittenInMainFile(SL)) { if (SL.isInvalid() || SM.isInSystemHeader(SL)) return AM_None; diff --git a/lib/Tooling/CompilationDatabase.cpp b/lib/Tooling/CompilationDatabase.cpp index 4483b189ca9f..2272be632b9e 100644 --- a/lib/Tooling/CompilationDatabase.cpp +++ b/lib/Tooling/CompilationDatabase.cpp @@ -250,14 +250,11 @@ static bool stripPositionalArgs(std::vector<const char *> Args, CompileJobAnalyzer CompileAnalyzer; - for (const auto &Job : Jobs) { - if (Job.getKind() == driver::Job::CommandClass) { - const driver::Command &Cmd = cast<driver::Command>(Job); - // Collect only for Assemble jobs. If we do all jobs we get duplicates - // since Link jobs point to Assemble jobs as inputs. - if (Cmd.getSource().getKind() == driver::Action::AssembleJobClass) - CompileAnalyzer.run(&Cmd.getSource()); - } + for (const auto &Cmd : Jobs) { + // Collect only for Assemble jobs. If we do all jobs we get duplicates + // since Link jobs point to Assemble jobs as inputs. + if (Cmd.getSource().getKind() == driver::Action::AssembleJobClass) + CompileAnalyzer.run(&Cmd.getSource()); } if (CompileAnalyzer.Inputs.empty()) { diff --git a/test/Analysis/division-by-zero.c b/test/Analysis/division-by-zero.c new file mode 100644 index 000000000000..d3c228e6c97d --- /dev/null +++ b/test/Analysis/division-by-zero.c @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -analyze -analyzer-checker=unix.Malloc %s +// Do not crash due to division by zero + +int f(unsigned int a) { + if (a <= 0) return 1 / a; + return a; +} diff --git a/test/Analysis/retain-release.m b/test/Analysis/retain-release.m index 1dbcda507c17..f0d91e34c1b0 100644 --- a/test/Analysis/retain-release.m +++ b/test/Analysis/retain-release.m @@ -2165,7 +2165,7 @@ void testCFReturnsNotRetained() { } void testCFReturnsNotRetainedAnnotated() { - extern void getViaParam2(CFTypeRef * __nonnull CF_RETURNS_NOT_RETAINED outObj); + 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}} diff --git a/test/Analysis/test-include-cpp.cpp b/test/Analysis/test-include-cpp.cpp new file mode 100644 index 000000000000..2ac5e11c997e --- /dev/null +++ b/test/Analysis/test-include-cpp.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -analyze -analyzer-checker=core -verify %s + +#include "test-include-cpp.h" + +int TestIncludeClass::test1(int *p) { + p = 0; + return *p; // expected-warning{{Dereference of null pointer}} +} + +int TestIncludeClass::test2(int *p) { + p = 0; + return *p; // expected-warning{{Dereference of null pointer}} +} diff --git a/test/Analysis/test-include-cpp.h b/test/Analysis/test-include-cpp.h new file mode 100644 index 000000000000..90ec27acd5d3 --- /dev/null +++ b/test/Analysis/test-include-cpp.h @@ -0,0 +1,9 @@ +#ifndef TEST_INCLUDE_CPP_H +#define TEST_INCLUDE_CPP_H + +class TestIncludeClass { + int test1(int *); + static int test2(int *); +}; + +#endif diff --git a/test/Analysis/test-include.c b/test/Analysis/test-include.c new file mode 100644 index 000000000000..6aa80b96426c --- /dev/null +++ b/test/Analysis/test-include.c @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -analyze -analyzer-checker=core -verify %s + +#include "test-include.h" +#define DIVYX(X,Y) Y/X + +void test_01(int *data) { + data = 0; + *data = 1; // expected-warning{{Dereference of null pointer}} +} + +int test_02() { + int res = DIVXY(1,0); // expected-warning{{Division by zero}} + // expected-warning@-1{{division by zero is undefined}} + return res; +} + +int test_03() { + int res = DIVYX(0,1); // expected-warning{{Division by zero}} + // expected-warning@-1{{division by zero is undefined}} + return res; +}
\ No newline at end of file diff --git a/test/Analysis/test-include.h b/test/Analysis/test-include.h new file mode 100644 index 000000000000..07cd1c9dca1b --- /dev/null +++ b/test/Analysis/test-include.h @@ -0,0 +1,2 @@ +void test_01(int * data); +#define DIVXY(X,Y) X/Y diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-1y.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-1y.cpp index f7b3e8e7be63..c3dc1de3ed6f 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-1y.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-1y.cpp @@ -11,6 +11,9 @@ namespace std { int i; int &&f(); +template <typename T> +void overloaded_fn(T); // expected-note {{possible target}} + using Int = int; using IntLRef = int&; using IntRRef = int&&; @@ -57,6 +60,7 @@ decltype(auto) ((((((v1)))))) = 0; // ok decltype(auto) v2[1] = { 0 }; // expected-error {{cannot form array of 'decltype(auto)'}} decltype(auto) &v3 = { 0 }; // expected-error {{cannot form reference to 'decltype(auto)'}} decltype(auto) *v4 = { 0 }; // expected-error {{cannot form pointer to 'decltype(auto)'}} +decltype(auto) v5 = &overloaded_fn; // expected-error {{could not be resolved}} auto multi1a = 0, &multi1b = multi1a; auto multi1c = multi1a, multi1d = multi1b; diff --git a/test/CXX/drs/dr9xx.cpp b/test/CXX/drs/dr9xx.cpp index 4bcd6565e068..b37e17d6b098 100644 --- a/test/CXX/drs/dr9xx.cpp +++ b/test/CXX/drs/dr9xx.cpp @@ -44,3 +44,32 @@ namespace dr990 { // dr990: 3.5 D d{}; #endif } + +namespace dr948 { // dr948: 3.7 +#if __cplusplus >= 201103L + class A { + public: + constexpr A(int v) : v(v) { } + constexpr operator int() const { return v; } + private: + int v; + }; + + constexpr int id(int x) + { + return x; + } + + void f() { + if (constexpr int i = id(101)) { } + switch (constexpr int i = id(2)) { default: break; case 2: break; } + for (; constexpr int i = id(0); ) { } + while (constexpr int i = id(0)) { } + + if (constexpr A i = 101) { } + switch (constexpr A i = 2) { default: break; case 2: break; } + for (; constexpr A i = 0; ) { } + while (constexpr A i = 0) { } + } +#endif +} diff --git a/test/CodeCompletion/macros-in-modules.c b/test/CodeCompletion/macros-in-modules.c new file mode 100644 index 000000000000..82ffaae7cb10 --- /dev/null +++ b/test/CodeCompletion/macros-in-modules.c @@ -0,0 +1,11 @@ +// RUN: rm -rf %t && mkdir %t +// RUN: echo 'module Foo { header "foo.h" }' > %t/module.modulemap +// RUN: echo '#define FOO_MACRO 42' > %t/foo.h +// RUN: c-index-test -code-completion-at=%s:9:1 -I %t %s | FileCheck %s +// RUN: c-index-test -code-completion-at=%s:9:1 -I %t -fmodules %s | FileCheck %s + +#include "foo.h" +int x = +/*here*/1; + +// CHECK: FOO_MACRO diff --git a/test/CodeCompletion/macros-in-modules.m b/test/CodeCompletion/macros-in-modules.m new file mode 100644 index 000000000000..8d6b3753d043 --- /dev/null +++ b/test/CodeCompletion/macros-in-modules.m @@ -0,0 +1,10 @@ +// RUN: rm -rf %t && mkdir %t +// RUN: echo 'module Foo { header "foo.h" }' > %t/module.modulemap +// RUN: echo '#define FOO_MACRO 42' > %t/foo.h +// RUN: c-index-test -code-completion-at=%s:8:1 -I %t -fmodules %s | FileCheck %s + +@import Foo; +int x = +/*here*/1; + +// CHECK: FOO_MACRO diff --git a/test/CodeGen/2004-11-27-StaticFunctionRedeclare.c b/test/CodeGen/2004-11-27-StaticFunctionRedeclare.c index 9ceee4c99127..f6ce5528a4ea 100644 --- a/test/CodeGen/2004-11-27-StaticFunctionRedeclare.c +++ b/test/CodeGen/2004-11-27-StaticFunctionRedeclare.c @@ -6,7 +6,7 @@ // This is PR244 -// CHECK-LABEL: define void @bar( +// CHECK-LABEL: define {{.*}}void @bar( // CHECK: call {{.*}} @func // CHECK: define internal {{.*}}i32 @func( static int func(); diff --git a/test/CodeGen/2007-04-14-FNoBuiltin.c b/test/CodeGen/2007-04-14-FNoBuiltin.c index 25ae01c5dcc0..4d194b1e0df1 100644 --- a/test/CodeGen/2007-04-14-FNoBuiltin.c +++ b/test/CodeGen/2007-04-14-FNoBuiltin.c @@ -3,7 +3,7 @@ extern int printf(const char*, ...); -// CHECK: define void {{.*}}foo( +// CHECK: define {{.*}}void {{.*}}foo( void foo(const char *msg) { // CHECK: call {{.*}}printf printf("%s\n",msg); diff --git a/test/CodeGen/PR8880.c b/test/CodeGen/PR8880.c index e03d2a42b610..ff8491ed4d5a 100644 --- a/test/CodeGen/PR8880.c +++ b/test/CodeGen/PR8880.c @@ -1,7 +1,7 @@ // RUN: %clang_cc1 -Wno-gcc-compat -emit-llvm -o - %s | FileCheck %s void pr8880_cg_1(int *iptr) { -// CHECK-LABEL: define void @pr8880_cg_1( +// CHECK-LABEL: define {{.*}}void @pr8880_cg_1( int i, j; // CHECK: br label %[[OUTER_COND:[0-9A-Za-z$._]+]] for (i = 2; i != 10 ; i++ ) @@ -31,7 +31,7 @@ void pr8880_cg_1(int *iptr) { } void pr8880_cg_2(int *iptr) { -// CHECK-LABEL: define void @pr8880_cg_2( +// CHECK-LABEL: define {{.*}}void @pr8880_cg_2( int i, j; // CHECK: br label %[[OUTER_COND:[0-9A-Za-z$._]+]] for (i = 2; i != 10 ; i++ ) @@ -61,7 +61,7 @@ void pr8880_cg_2(int *iptr) { } void pr8880_cg_3(int *iptr) { -// CHECK-LABEL: define void @pr8880_cg_3( +// CHECK-LABEL: define {{.*}}void @pr8880_cg_3( int i, j; // CHECK: br label %[[OUTER_COND:[0-9A-Za-z$._]+]] for (i = 2 ; i != 10 ; i++ ) @@ -92,7 +92,7 @@ void pr8880_cg_3(int *iptr) { } void pr8880_cg_4(int *iptr) { -// CHECK-LABEL: define void @pr8880_cg_4( +// CHECK-LABEL: define {{.*}}void @pr8880_cg_4( int i, j; // CHECK: br label %[[OUTER_COND:[0-9A-Za-z$._]+]] for (i = 2 ; i != 10 ; i++ ) @@ -123,7 +123,7 @@ void pr8880_cg_4(int *iptr) { } void pr8880_cg_5(int x, int *iptr) { -// CHECK-LABEL: define void @pr8880_cg_5( +// CHECK-LABEL: define {{.*}}void @pr8880_cg_5( int y = 5; // CHECK: br label %[[OUTER_COND:[0-9A-Za-z$._]+]] // CHECK: [[OUTER_COND]] @@ -148,7 +148,7 @@ void pr8880_cg_5(int x, int *iptr) { } void pr8880_cg_6(int x, int *iptr) { -// CHECK-LABEL: define void @pr8880_cg_6( +// CHECK-LABEL: define {{.*}}void @pr8880_cg_6( int y = 5; // CHECK: br label %[[OUTER_COND:[0-9A-Za-z$._]+]] // CHECK: [[OUTER_COND]] diff --git a/test/CodeGen/arm-microsoft-intrinsics.c b/test/CodeGen/arm-microsoft-intrinsics.c index 5f19e5e7c87c..e073cc2c0c05 100644 --- a/test/CodeGen/arm-microsoft-intrinsics.c +++ b/test/CodeGen/arm-microsoft-intrinsics.c @@ -47,17 +47,17 @@ unsigned int check_MoveFromCoprocessor2(void) { // CHECK-MSVC: @llvm.arm.mrc2(i32 0, i32 0, i32 0, i32 0, i32 0) // CHECK-EABI: error: implicit declaration of function '_MoveFromCoprocessor2' -void check_MoveToCoprocessor(void) { - _MoveToCoprocessor(0, 0, 0, 0, 0, 0); +void check_MoveToCoprocessor(unsigned int value) { + _MoveToCoprocessor(value, 10, 7, 1, 0, 0); } -// CHECK-MSVC: @llvm.arm.mcr(i32 0, i32 0, i32 0, i32 0, i32 0, i32 0) +// CHECK-MSVC: @llvm.arm.mcr(i32 10, i32 7, i32 %{{[^,]*}}, i32 1, i32 0, i32 0) // CHECK-EABI: error: implicit declaration of function '_MoveToCoprocessor' -void check_MoveToCoprocessor2(void) { - _MoveToCoprocessor2(0, 0, 0, 0, 0, 0); +void check_MoveToCoprocessor2(unsigned int value) { + _MoveToCoprocessor2(value, 10, 7, 1, 0, 0); } -// CHECK-MSVC: @llvm.arm.mcr2(i32 0, i32 0, i32 0, i32 0, i32 0, i32 0) +// CHECK-MSVC: @llvm.arm.mcr2(i32 10, i32 7, i32 %{{[^,]*}}, i32 1, i32 0, i32 0) // CHECK-EABI: error: implicit declaration of function '_MoveToCoprocessor2' diff --git a/test/CodeGen/arm-target-features.c b/test/CodeGen/arm-target-features.c index ece8bdfc5e2d..36804b4e3bb1 100644 --- a/test/CodeGen/arm-target-features.c +++ b/test/CodeGen/arm-target-features.c @@ -6,7 +6,7 @@ // RUN: %clang_cc1 -triple thumbv7-linux-gnueabihf -target-cpu cortex-a5 -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-VFP4 -// CHECK-VFP4: "target-features"="+vfp4,+neon" +// CHECK-VFP4: "target-features"="+neon,+vfp4" // RUN: %clang_cc1 -triple thumbv7-linux-gnueabihf -target-cpu cortex-a7 -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-VFP4-DIV @@ -15,14 +15,14 @@ // RUN: %clang_cc1 -triple armv7-linux-gnueabihf -target-cpu cortex-a17 -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-VFP4-DIV // RUN: %clang_cc1 -triple thumbv7s-linux-gnueabi -target-cpu swift -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-VFP4-DIV // RUN: %clang_cc1 -triple thumbv7-linux-gnueabihf -target-cpu krait -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-VFP4-DIV -// CHECK-VFP4-DIV: "target-features"="+vfp4,+neon,+hwdiv,+hwdiv-arm" +// CHECK-VFP4-DIV: "target-features"="+hwdiv,+hwdiv-arm,+neon,+vfp4" // RUN: %clang_cc1 -triple thumbv7s-apple-ios7.0 -target-cpu cyclone -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-BASIC-V8 // RUN: %clang_cc1 -triple armv8-linux-gnueabi -target-cpu cortex-a53 -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-BASIC-V8 // RUN: %clang_cc1 -triple thumbv8-linux-gnueabihf -target-cpu cortex-a57 -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-BASIC-V8 // RUN: %clang_cc1 -triple thumbv8-linux-gnueabihf -target-cpu cortex-a72 -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-BASIC-V8 -// CHECK-BASIC-V8: "target-features"="+neon,+fp-armv8,+hwdiv,+crypto,+crc,+hwdiv-arm" +// CHECK-BASIC-V8: "target-features"="+crc,+crypto,+fp-armv8,+hwdiv,+hwdiv-arm,+neon" // RUN: %clang_cc1 -triple thumbv7-linux-gnueabi -target-cpu cortex-r5 -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-DIV diff --git a/test/CodeGen/attr-nodebug.c b/test/CodeGen/attr-nodebug.c index 66caa2b38fac..07a4aa35a897 100644 --- a/test/CodeGen/attr-nodebug.c +++ b/test/CodeGen/attr-nodebug.c @@ -1,12 +1,32 @@ -// RUN: %clang_cc1 -g -emit-llvm -o %t %s -// RUN: not grep 'call void @llvm.dbg.func.start' %t +// RUN: %clang_cc1 -g -emit-llvm -o - %s | FileCheck %s void t1() __attribute__((nodebug)); void t1() { int a = 10; - a++; } +void t2() +{ + int b = 10; + b++; +} + +// With nodebug, IR should have no llvm.dbg.* calls, or !dbg annotations. +// CHECK-LABEL: @t1 +// CHECK-NOT: dbg +// CHECK: } + +// For sanity, check those things do occur normally. +// CHECK-LABEL: @t2 +// CHECK: call{{.*}}llvm.dbg +// CHECK: !dbg +// CHECK: } + +// We should see a function description for t2 but not t1. +// CHECK-NOT: DISubprogram(name: "t1" +// CHECK: DISubprogram(name: "t2" +// CHECK-NOT: DISubprogram(name: "t1" + diff --git a/test/CodeGen/attr-target.c b/test/CodeGen/attr-target.c index 8c0f335f857d..7ea5fe5a07a0 100644 --- a/test/CodeGen/attr-target.c +++ b/test/CodeGen/attr-target.c @@ -9,6 +9,8 @@ int __attribute__((target("fpmath=387"))) koala(int a) { return 4; } int __attribute__((target("mno-sse2"))) echidna(int a) { return 4; } +int __attribute__((target("sse4"))) panda(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. @@ -21,5 +23,6 @@ int bar(int a) { return baz(a) + foo(a); } // 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" +// CHECK: #1 = {{.*}}"target-cpu"="ivybridge" "target-features"="+avx,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3" +// CHECK: #2 = {{.*}}"target-cpu"="x86-64" "target-features"="+sse,-aes,-avx,-avx2,-avx512bw,-avx512cd,-avx512dq,-avx512er,-avx512f,-avx512pf,-avx512vl,-f16c,-fma,-fma4,-pclmul,-sha,-sse2,-sse3,-sse4.1,-sse4.2,-sse4a,-ssse3,-xop" +// CHECK: #3 = {{.*}}"target-cpu"="x86-64" "target-features"="+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3" diff --git a/test/CodeGen/avx512bw-builtins.c b/test/CodeGen/avx512bw-builtins.c index 452d737beaa2..6cc02ef705db 100644 --- a/test/CodeGen/avx512bw-builtins.c +++ b/test/CodeGen/avx512bw-builtins.c @@ -427,3 +427,409 @@ __m512i test_mm512_maskz_mullo_epi16 (__mmask32 __U, __m512i __A, __m512i __B) { //CHECK: @llvm.x86.avx512.mask.pmull.w.512 return _mm512_maskz_mullo_epi16(__U, __A, __B); } + +__m512i test_mm512_mask_blend_epi8(__mmask64 __U, __m512i __A, __m512i __W) { + // CHECK-LABEL: @test_mm512_mask_blend_epi8 + // CHECK: @llvm.x86.avx512.mask.blend.b.512 + return _mm512_mask_blend_epi8(__U,__A,__W); +} +__m512i test_mm512_mask_blend_epi16(__mmask32 __U, __m512i __A, __m512i __W) { + // CHECK-LABEL: @test_mm512_mask_blend_epi16 + // CHECK: @llvm.x86.avx512.mask.blend.w.512 + return _mm512_mask_blend_epi16(__U,__A,__W); +} +__m512i test_mm512_abs_epi8(__m512i __A) { + // CHECK-LABEL: @test_mm512_abs_epi8 + // CHECK: @llvm.x86.avx512.mask.pabs.b.512 + return _mm512_abs_epi8(__A); +} +__m512i test_mm512_mask_abs_epi8(__m512i __W, __mmask64 __U, __m512i __A) { + // CHECK-LABEL: @test_mm512_mask_abs_epi8 + // CHECK: @llvm.x86.avx512.mask.pabs.b.512 + return _mm512_mask_abs_epi8(__W,__U,__A); +} +__m512i test_mm512_maskz_abs_epi8(__mmask64 __U, __m512i __A) { + // CHECK-LABEL: @test_mm512_maskz_abs_epi8 + // CHECK: @llvm.x86.avx512.mask.pabs.b.512 + return _mm512_maskz_abs_epi8(__U,__A); +} +__m512i test_mm512_abs_epi16(__m512i __A) { + // CHECK-LABEL: @test_mm512_abs_epi16 + // CHECK: @llvm.x86.avx512.mask.pabs.w.512 + return _mm512_abs_epi16(__A); +} +__m512i test_mm512_mask_abs_epi16(__m512i __W, __mmask32 __U, __m512i __A) { + // CHECK-LABEL: @test_mm512_mask_abs_epi16 + // CHECK: @llvm.x86.avx512.mask.pabs.w.512 + return _mm512_mask_abs_epi16(__W,__U,__A); +} +__m512i test_mm512_maskz_abs_epi16(__mmask32 __U, __m512i __A) { + // CHECK-LABEL: @test_mm512_maskz_abs_epi16 + // CHECK: @llvm.x86.avx512.mask.pabs.w.512 + return _mm512_maskz_abs_epi16(__U,__A); +} +__m512i test_mm512_packs_epi32(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_packs_epi32 + // CHECK: @llvm.x86.avx512.mask.packssdw.512 + return _mm512_packs_epi32(__A,__B); +} +__m512i test_mm512_maskz_packs_epi32(__mmask32 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_packs_epi32 + // CHECK: @llvm.x86.avx512.mask.packssdw.512 + return _mm512_maskz_packs_epi32(__M,__A,__B); +} +__m512i test_mm512_mask_packs_epi32(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_packs_epi32 + // CHECK: @llvm.x86.avx512.mask.packssdw.512 + return _mm512_mask_packs_epi32(__W,__M,__A,__B); +} +__m512i test_mm512_packs_epi16(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_packs_epi16 + // CHECK: @llvm.x86.avx512.mask.packsswb.512 + return _mm512_packs_epi16(__A,__B); +} +__m512i test_mm512_mask_packs_epi16(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_packs_epi16 + // CHECK: @llvm.x86.avx512.mask.packsswb.512 + return _mm512_mask_packs_epi16(__W,__M,__A,__B); +} +__m512i test_mm512_maskz_packs_epi16(__mmask64 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_packs_epi16 + // CHECK: @llvm.x86.avx512.mask.packsswb.512 + return _mm512_maskz_packs_epi16(__M,__A,__B); +} +__m512i test_mm512_packus_epi32(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_packus_epi32 + // CHECK: @llvm.x86.avx512.mask.packusdw.512 + return _mm512_packus_epi32(__A,__B); +} +__m512i test_mm512_maskz_packus_epi32(__mmask32 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_packus_epi32 + // CHECK: @llvm.x86.avx512.mask.packusdw.512 + return _mm512_maskz_packus_epi32(__M,__A,__B); +} +__m512i test_mm512_mask_packus_epi32(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_packus_epi32 + // CHECK: @llvm.x86.avx512.mask.packusdw.512 + return _mm512_mask_packus_epi32(__W,__M,__A,__B); +} +__m512i test_mm512_packus_epi16(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_packus_epi16 + // CHECK: @llvm.x86.avx512.mask.packuswb.512 + return _mm512_packus_epi16(__A,__B); +} +__m512i test_mm512_mask_packus_epi16(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_packus_epi16 + // CHECK: @llvm.x86.avx512.mask.packuswb.512 + return _mm512_mask_packus_epi16(__W,__M,__A,__B); +} +__m512i test_mm512_maskz_packus_epi16(__mmask64 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_packus_epi16 + // CHECK: @llvm.x86.avx512.mask.packuswb.512 + return _mm512_maskz_packus_epi16(__M,__A,__B); +} +__m512i test_mm512_adds_epi8(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_adds_epi8 + // CHECK: @llvm.x86.avx512.mask.padds.b.512 + return _mm512_adds_epi8(__A,__B); +} +__m512i test_mm512_mask_adds_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_adds_epi8 + // CHECK: @llvm.x86.avx512.mask.padds.b.512 + return _mm512_mask_adds_epi8(__W,__U,__A,__B); +} +__m512i test_mm512_maskz_adds_epi8(__mmask64 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_adds_epi8 + // CHECK: @llvm.x86.avx512.mask.padds.b.512 + return _mm512_maskz_adds_epi8(__U,__A,__B); +} +__m512i test_mm512_adds_epi16(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_adds_epi16 + // CHECK: @llvm.x86.avx512.mask.padds.w.512 + return _mm512_adds_epi16(__A,__B); +} +__m512i test_mm512_mask_adds_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_adds_epi16 + // CHECK: @llvm.x86.avx512.mask.padds.w.512 + return _mm512_mask_adds_epi16(__W,__U,__A,__B); +} +__m512i test_mm512_maskz_adds_epi16(__mmask32 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_adds_epi16 + // CHECK: @llvm.x86.avx512.mask.padds.w.512 + return _mm512_maskz_adds_epi16(__U,__A,__B); +} +__m512i test_mm512_adds_epu8(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_adds_epu8 + // CHECK: @llvm.x86.avx512.mask.paddus.b.512 + return _mm512_adds_epu8(__A,__B); +} +__m512i test_mm512_mask_adds_epu8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_adds_epu8 + // CHECK: @llvm.x86.avx512.mask.paddus.b.512 + return _mm512_mask_adds_epu8(__W,__U,__A,__B); +} +__m512i test_mm512_maskz_adds_epu8(__mmask64 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_adds_epu8 + // CHECK: @llvm.x86.avx512.mask.paddus.b.512 + return _mm512_maskz_adds_epu8(__U,__A,__B); +} +__m512i test_mm512_adds_epu16(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_adds_epu16 + // CHECK: @llvm.x86.avx512.mask.paddus.w.512 + return _mm512_adds_epu16(__A,__B); +} +__m512i test_mm512_mask_adds_epu16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_adds_epu16 + // CHECK: @llvm.x86.avx512.mask.paddus.w.512 + return _mm512_mask_adds_epu16(__W,__U,__A,__B); +} +__m512i test_mm512_maskz_adds_epu16(__mmask32 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_adds_epu16 + // CHECK: @llvm.x86.avx512.mask.paddus.w.512 + return _mm512_maskz_adds_epu16(__U,__A,__B); +} +__m512i test_mm512_avg_epu8(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_avg_epu8 + // CHECK: @llvm.x86.avx512.mask.pavg.b.512 + return _mm512_avg_epu8(__A,__B); +} +__m512i test_mm512_mask_avg_epu8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_avg_epu8 + // CHECK: @llvm.x86.avx512.mask.pavg.b.512 + return _mm512_mask_avg_epu8(__W,__U,__A,__B); +} +__m512i test_mm512_maskz_avg_epu8(__mmask64 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_avg_epu8 + // CHECK: @llvm.x86.avx512.mask.pavg.b.512 + return _mm512_maskz_avg_epu8(__U,__A,__B); +} +__m512i test_mm512_avg_epu16(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_avg_epu16 + // CHECK: @llvm.x86.avx512.mask.pavg.w.512 + return _mm512_avg_epu16(__A,__B); +} +__m512i test_mm512_mask_avg_epu16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_avg_epu16 + // CHECK: @llvm.x86.avx512.mask.pavg.w.512 + return _mm512_mask_avg_epu16(__W,__U,__A,__B); +} +__m512i test_mm512_maskz_avg_epu16(__mmask32 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_avg_epu16 + // CHECK: @llvm.x86.avx512.mask.pavg.w.512 + return _mm512_maskz_avg_epu16(__U,__A,__B); +} +__m512i test_mm512_max_epi8(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_max_epi8 + // CHECK: @llvm.x86.avx512.mask.pmaxs.b.512 + return _mm512_max_epi8(__A,__B); +} +__m512i test_mm512_maskz_max_epi8(__mmask64 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_max_epi8 + // CHECK: @llvm.x86.avx512.mask.pmaxs.b.512 + return _mm512_maskz_max_epi8(__M,__A,__B); +} +__m512i test_mm512_mask_max_epi8(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_max_epi8 + // CHECK: @llvm.x86.avx512.mask.pmaxs.b.512 + return _mm512_mask_max_epi8(__W,__M,__A,__B); +} +__m512i test_mm512_max_epi16(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_max_epi16 + // CHECK: @llvm.x86.avx512.mask.pmaxs.w.512 + return _mm512_max_epi16(__A,__B); +} +__m512i test_mm512_maskz_max_epi16(__mmask32 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_max_epi16 + // CHECK: @llvm.x86.avx512.mask.pmaxs.w.512 + return _mm512_maskz_max_epi16(__M,__A,__B); +} +__m512i test_mm512_mask_max_epi16(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_max_epi16 + // CHECK: @llvm.x86.avx512.mask.pmaxs.w.512 + return _mm512_mask_max_epi16(__W,__M,__A,__B); +} +__m512i test_mm512_max_epu8(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_max_epu8 + // CHECK: @llvm.x86.avx512.mask.pmaxu.b.512 + return _mm512_max_epu8(__A,__B); +} +__m512i test_mm512_maskz_max_epu8(__mmask64 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_max_epu8 + // CHECK: @llvm.x86.avx512.mask.pmaxu.b.512 + return _mm512_maskz_max_epu8(__M,__A,__B); +} +__m512i test_mm512_mask_max_epu8(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_max_epu8 + // CHECK: @llvm.x86.avx512.mask.pmaxu.b.512 + return _mm512_mask_max_epu8(__W,__M,__A,__B); +} +__m512i test_mm512_max_epu16(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_max_epu16 + // CHECK: @llvm.x86.avx512.mask.pmaxu.w.512 + return _mm512_max_epu16(__A,__B); +} +__m512i test_mm512_maskz_max_epu16(__mmask32 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_max_epu16 + // CHECK: @llvm.x86.avx512.mask.pmaxu.w.512 + return _mm512_maskz_max_epu16(__M,__A,__B); +} +__m512i test_mm512_mask_max_epu16(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_max_epu16 + // CHECK: @llvm.x86.avx512.mask.pmaxu.w.512 + return _mm512_mask_max_epu16(__W,__M,__A,__B); +} +__m512i test_mm512_min_epi8(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_min_epi8 + // CHECK: @llvm.x86.avx512.mask.pmins.b.512 + return _mm512_min_epi8(__A,__B); +} +__m512i test_mm512_maskz_min_epi8(__mmask64 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_min_epi8 + // CHECK: @llvm.x86.avx512.mask.pmins.b.512 + return _mm512_maskz_min_epi8(__M,__A,__B); +} +__m512i test_mm512_mask_min_epi8(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_min_epi8 + // CHECK: @llvm.x86.avx512.mask.pmins.b.512 + return _mm512_mask_min_epi8(__W,__M,__A,__B); +} +__m512i test_mm512_min_epi16(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_min_epi16 + // CHECK: @llvm.x86.avx512.mask.pmins.w.512 + return _mm512_min_epi16(__A,__B); +} +__m512i test_mm512_maskz_min_epi16(__mmask32 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_min_epi16 + // CHECK: @llvm.x86.avx512.mask.pmins.w.512 + return _mm512_maskz_min_epi16(__M,__A,__B); +} +__m512i test_mm512_mask_min_epi16(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_min_epi16 + // CHECK: @llvm.x86.avx512.mask.pmins.w.512 + return _mm512_mask_min_epi16(__W,__M,__A,__B); +} +__m512i test_mm512_min_epu8(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_min_epu8 + // CHECK: @llvm.x86.avx512.mask.pminu.b.512 + return _mm512_min_epu8(__A,__B); +} +__m512i test_mm512_maskz_min_epu8(__mmask64 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_min_epu8 + // CHECK: @llvm.x86.avx512.mask.pminu.b.512 + return _mm512_maskz_min_epu8(__M,__A,__B); +} +__m512i test_mm512_mask_min_epu8(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_min_epu8 + // CHECK: @llvm.x86.avx512.mask.pminu.b.512 + return _mm512_mask_min_epu8(__W,__M,__A,__B); +} +__m512i test_mm512_min_epu16(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_min_epu16 + // CHECK: @llvm.x86.avx512.mask.pminu.w.512 + return _mm512_min_epu16(__A,__B); +} +__m512i test_mm512_maskz_min_epu16(__mmask32 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_min_epu16 + // CHECK: @llvm.x86.avx512.mask.pminu.w.512 + return _mm512_maskz_min_epu16(__M,__A,__B); +} +__m512i test_mm512_mask_min_epu16(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_min_epu16 + // CHECK: @llvm.x86.avx512.mask.pminu.w.512 + return _mm512_mask_min_epu16(__W,__M,__A,__B); +} +__m512i test_mm512_shuffle_epi8(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_shuffle_epi8 + // CHECK: @llvm.x86.avx512.mask.pshuf.b.512 + return _mm512_shuffle_epi8(__A,__B); +} +__m512i test_mm512_mask_shuffle_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_shuffle_epi8 + // CHECK: @llvm.x86.avx512.mask.pshuf.b.512 + return _mm512_mask_shuffle_epi8(__W,__U,__A,__B); +} +__m512i test_mm512_maskz_shuffle_epi8(__mmask64 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_shuffle_epi8 + // CHECK: @llvm.x86.avx512.mask.pshuf.b.512 + return _mm512_maskz_shuffle_epi8(__U,__A,__B); +} +__m512i test_mm512_subs_epi8(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_subs_epi8 + // CHECK: @llvm.x86.avx512.mask.psubs.b.512 + return _mm512_subs_epi8(__A,__B); +} +__m512i test_mm512_mask_subs_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_subs_epi8 + // CHECK: @llvm.x86.avx512.mask.psubs.b.512 + return _mm512_mask_subs_epi8(__W,__U,__A,__B); +} +__m512i test_mm512_maskz_subs_epi8(__mmask64 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_subs_epi8 + // CHECK: @llvm.x86.avx512.mask.psubs.b.512 + return _mm512_maskz_subs_epi8(__U,__A,__B); +} +__m512i test_mm512_subs_epi16(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_subs_epi16 + // CHECK: @llvm.x86.avx512.mask.psubs.w.512 + return _mm512_subs_epi16(__A,__B); +} +__m512i test_mm512_mask_subs_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_subs_epi16 + // CHECK: @llvm.x86.avx512.mask.psubs.w.512 + return _mm512_mask_subs_epi16(__W,__U,__A,__B); +} +__m512i test_mm512_maskz_subs_epi16(__mmask32 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_subs_epi16 + // CHECK: @llvm.x86.avx512.mask.psubs.w.512 + return _mm512_maskz_subs_epi16(__U,__A,__B); +} +__m512i test_mm512_subs_epu8(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_subs_epu8 + // CHECK: @llvm.x86.avx512.mask.psubus.b.512 + return _mm512_subs_epu8(__A,__B); +} +__m512i test_mm512_mask_subs_epu8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_subs_epu8 + // CHECK: @llvm.x86.avx512.mask.psubus.b.512 + return _mm512_mask_subs_epu8(__W,__U,__A,__B); +} +__m512i test_mm512_maskz_subs_epu8(__mmask64 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_subs_epu8 + // CHECK: @llvm.x86.avx512.mask.psubus.b.512 + return _mm512_maskz_subs_epu8(__U,__A,__B); +} +__m512i test_mm512_subs_epu16(__m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_subs_epu16 + // CHECK: @llvm.x86.avx512.mask.psubus.w.512 + return _mm512_subs_epu16(__A,__B); +} +__m512i test_mm512_mask_subs_epu16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_subs_epu16 + // CHECK: @llvm.x86.avx512.mask.psubus.w.512 + return _mm512_mask_subs_epu16(__W,__U,__A,__B); +} +__m512i test_mm512_maskz_subs_epu16(__mmask32 __U, __m512i __A, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_subs_epu16 + // CHECK: @llvm.x86.avx512.mask.psubus.w.512 + return _mm512_maskz_subs_epu16(__U,__A,__B); +} +__m512i test_mm512_mask2_permutex2var_epi16(__m512i __A, __m512i __I, __mmask32 __U, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask2_permutex2var_epi16 + // CHECK: @llvm.x86.avx512.mask.vpermi2var.hi.512 + return _mm512_mask2_permutex2var_epi16(__A,__I,__U,__B); +} +__m512i test_mm512_permutex2var_epi16(__m512i __A, __m512i __I, __m512i __B) { + // CHECK-LABEL: @test_mm512_permutex2var_epi16 + // CHECK: @llvm.x86.avx512.mask.vpermt2var.hi.512 + return _mm512_permutex2var_epi16(__A,__I,__B); +} +__m512i test_mm512_mask_permutex2var_epi16(__m512i __A, __mmask32 __U, __m512i __I, __m512i __B) { + // CHECK-LABEL: @test_mm512_mask_permutex2var_epi16 + // CHECK: @llvm.x86.avx512.mask.vpermt2var.hi.512 + return _mm512_mask_permutex2var_epi16(__A,__U,__I,__B); +} +__m512i test_mm512_maskz_permutex2var_epi16(__mmask32 __U, __m512i __A, __m512i __I, __m512i __B) { + // CHECK-LABEL: @test_mm512_maskz_permutex2var_epi16 + // CHECK: @llvm.x86.avx512.mask.vpermt2var.hi.512 + return _mm512_maskz_permutex2var_epi16(__U,__A,__I,__B); +} diff --git a/test/CodeGen/avx512cdintrin.c b/test/CodeGen/avx512cdintrin.c new file mode 100644 index 000000000000..1b4860a7fd24 --- /dev/null +++ b/test/CodeGen/avx512cdintrin.c @@ -0,0 +1,62 @@ +// RUN: %clang_cc1 %s -O0 -triple=x86_64-apple-darwin -ffreestanding -target-feature +avx512cd -emit-llvm -o - -Werror | FileCheck %s +#include <immintrin.h> +__m512i test_mm512_conflict_epi64(__m512i __A) { + // CHECK-LABEL: @test_mm512_conflict_epi64 + // CHECK: @llvm.x86.avx512.mask.conflict.q.512 + return _mm512_conflict_epi64(__A); +} +__m512i test_mm512_mask_conflict_epi64(__m512i __W, __mmask8 __U, __m512i __A) { + // CHECK-LABEL: @test_mm512_mask_conflict_epi64 + // CHECK: @llvm.x86.avx512.mask.conflict.q.512 + return _mm512_mask_conflict_epi64(__W,__U,__A); +} +__m512i test_mm512_maskz_conflict_epi64(__mmask8 __U, __m512i __A) { + // CHECK-LABEL: @test_mm512_maskz_conflict_epi64 + // CHECK: @llvm.x86.avx512.mask.conflict.q.512 + return _mm512_maskz_conflict_epi64(__U,__A); +} +__m512i test_mm512_conflict_epi32(__m512i __A) { + // CHECK-LABEL: @test_mm512_conflict_epi32 + // CHECK: @llvm.x86.avx512.mask.conflict.d.512 + return _mm512_conflict_epi32(__A); +} +__m512i test_mm512_mask_conflict_epi32(__m512i __W, __mmask16 __U, __m512i __A) { + // CHECK-LABEL: @test_mm512_mask_conflict_epi32 + // CHECK: @llvm.x86.avx512.mask.conflict.d.512 + return _mm512_mask_conflict_epi32(__W,__U,__A); +} +__m512i test_mm512_maskz_conflict_epi32(__mmask16 __U, __m512i __A) { + // CHECK-LABEL: @test_mm512_maskz_conflict_epi32 + // CHECK: @llvm.x86.avx512.mask.conflict.d.512 + return _mm512_maskz_conflict_epi32(__U,__A); +} +__m512i test_mm512_lzcnt_epi32(__m512i __A) { + // CHECK-LABEL: @test_mm512_lzcnt_epi32 + // CHECK: @llvm.x86.avx512.mask.lzcnt.d.512 + return _mm512_lzcnt_epi32(__A); +} +__m512i test_mm512_mask_lzcnt_epi32(__m512i __W, __mmask16 __U, __m512i __A) { + // CHECK-LABEL: @test_mm512_mask_lzcnt_epi32 + // CHECK: @llvm.x86.avx512.mask.lzcnt.d.512 + return _mm512_mask_lzcnt_epi32(__W,__U,__A); +} +__m512i test_mm512_maskz_lzcnt_epi32(__mmask16 __U, __m512i __A) { + // CHECK-LABEL: @test_mm512_maskz_lzcnt_epi32 + // CHECK: @llvm.x86.avx512.mask.lzcnt.d.512 + return _mm512_maskz_lzcnt_epi32(__U,__A); +} +__m512i test_mm512_lzcnt_epi64(__m512i __A) { + // CHECK-LABEL: @test_mm512_lzcnt_epi64 + // CHECK: @llvm.x86.avx512.mask.lzcnt.q.512 + return _mm512_lzcnt_epi64(__A); +} +__m512i test_mm512_mask_lzcnt_epi64(__m512i __W, __mmask8 __U, __m512i __A) { + // CHECK-LABEL: @test_mm512_mask_lzcnt_epi64 + // CHECK: @llvm.x86.avx512.mask.lzcnt.q.512 + return _mm512_mask_lzcnt_epi64(__W,__U,__A); +} +__m512i test_mm512_maskz_lzcnt_epi64(__mmask8 __U, __m512i __A) { + // CHECK-LABEL: @test_mm512_maskz_lzcnt_epi64 + // CHECK: @llvm.x86.avx512.mask.lzcnt.q.512 + return _mm512_maskz_lzcnt_epi64(__U,__A); +} diff --git a/test/CodeGen/avx512f-builtins.c b/test/CodeGen/avx512f-builtins.c index a49a1982bf47..112dfd8b6ee1 100644 --- a/test/CodeGen/avx512f-builtins.c +++ b/test/CodeGen/avx512f-builtins.c @@ -201,11 +201,486 @@ __m512d test_mm512_broadcastsd_pd(__m128d a) return _mm512_broadcastsd_pd(a); } -__m512i test_mm512_fmadd_pd(__m512d a, __m512d b, __m512d c) -{ +__m512d test_mm512_fmadd_round_pd(__m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_fmadd_round_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.512 + return _mm512_fmadd_round_pd(__A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} + +__m512d test_mm512_mask_fmadd_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_mask_fmadd_round_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.512 + return _mm512_mask_fmadd_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_mask3_fmadd_round_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmadd_round_pd + // CHECK: @llvm.x86.avx512.mask3.vfmadd.pd.512 + return _mm512_mask3_fmadd_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_maskz_fmadd_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_maskz_fmadd_round_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.512 + return _mm512_maskz_fmadd_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_fmsub_round_pd(__m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_fmsub_round_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.512 + return _mm512_fmsub_round_pd(__A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_mask_fmsub_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_mask_fmsub_round_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.512 + return _mm512_mask_fmsub_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_maskz_fmsub_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_maskz_fmsub_round_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.512 + return _mm512_maskz_fmsub_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_fnmadd_round_pd(__m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_fnmadd_round_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.512 + return _mm512_fnmadd_round_pd(__A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_mask3_fnmadd_round_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm512_mask3_fnmadd_round_pd + // CHECK: @llvm.x86.avx512.mask3.vfmadd.pd.512 + return _mm512_mask3_fnmadd_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_maskz_fnmadd_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_maskz_fnmadd_round_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.512 + return _mm512_maskz_fnmadd_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_fnmsub_round_pd(__m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_fnmsub_round_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.512 + return _mm512_fnmsub_round_pd(__A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_maskz_fnmsub_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_maskz_fnmsub_round_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.512 + return _mm512_maskz_fnmsub_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_fmadd_pd(__m512d __A, __m512d __B, __m512d __C) { // CHECK-LABEL: @test_mm512_fmadd_pd - // CHECK: @llvm.x86.fma.mask.vfmadd.pd.512 - return _mm512_fmadd_pd(a, b, c); + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.512 + return _mm512_fmadd_pd(__A, __B, __C); +} +__m512d test_mm512_mask_fmadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_mask_fmadd_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.512 + return _mm512_mask_fmadd_pd(__A, __U, __B, __C); +} +__m512d test_mm512_mask3_fmadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmadd_pd + // CHECK: @llvm.x86.avx512.mask3.vfmadd.pd.512 + return _mm512_mask3_fmadd_pd(__A, __B, __C, __U); +} +__m512d test_mm512_maskz_fmadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_maskz_fmadd_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.512 + return _mm512_maskz_fmadd_pd(__U, __A, __B, __C); +} +__m512d test_mm512_fmsub_pd(__m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_fmsub_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.512 + return _mm512_fmsub_pd(__A, __B, __C); +} +__m512d test_mm512_mask_fmsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_mask_fmsub_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.512 + return _mm512_mask_fmsub_pd(__A, __U, __B, __C); +} +__m512d test_mm512_maskz_fmsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_maskz_fmsub_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.512 + return _mm512_maskz_fmsub_pd(__U, __A, __B, __C); +} +__m512d test_mm512_fnmadd_pd(__m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_fnmadd_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.512 + return _mm512_fnmadd_pd(__A, __B, __C); +} +__m512d test_mm512_mask3_fnmadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm512_mask3_fnmadd_pd + // CHECK: @llvm.x86.avx512.mask3.vfmadd.pd.512 + return _mm512_mask3_fnmadd_pd(__A, __B, __C, __U); +} +__m512d test_mm512_maskz_fnmadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_maskz_fnmadd_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.512 + return _mm512_maskz_fnmadd_pd(__U, __A, __B, __C); +} +__m512d test_mm512_fnmsub_pd(__m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_fnmsub_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.512 + return _mm512_fnmsub_pd(__A, __B, __C); +} +__m512d test_mm512_maskz_fnmsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_maskz_fnmsub_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.512 + return _mm512_maskz_fnmsub_pd(__U, __A, __B, __C); +} +__m512 test_mm512_fmadd_round_ps(__m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_fmadd_round_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.512 + return _mm512_fmadd_round_ps(__A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_mask_fmadd_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_mask_fmadd_round_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.512 + return _mm512_mask_fmadd_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_mask3_fmadd_round_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmadd_round_ps + // CHECK: @llvm.x86.avx512.mask3.vfmadd.ps.512 + return _mm512_mask3_fmadd_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_maskz_fmadd_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_maskz_fmadd_round_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.512 + return _mm512_maskz_fmadd_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_fmsub_round_ps(__m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_fmsub_round_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.512 + return _mm512_fmsub_round_ps(__A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_mask_fmsub_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_mask_fmsub_round_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.512 + return _mm512_mask_fmsub_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_maskz_fmsub_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_maskz_fmsub_round_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.512 + return _mm512_maskz_fmsub_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_fnmadd_round_ps(__m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_fnmadd_round_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.512 + return _mm512_fnmadd_round_ps(__A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_mask3_fnmadd_round_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { + // CHECK-LABEL: @test_mm512_mask3_fnmadd_round_ps + // CHECK: @llvm.x86.avx512.mask3.vfmadd.ps.512 + return _mm512_mask3_fnmadd_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_maskz_fnmadd_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_maskz_fnmadd_round_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.512 + return _mm512_maskz_fnmadd_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_fnmsub_round_ps(__m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_fnmsub_round_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.512 + return _mm512_fnmsub_round_ps(__A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_maskz_fnmsub_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_maskz_fnmsub_round_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.512 + return _mm512_maskz_fnmsub_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_fmadd_ps(__m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_fmadd_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.512 + return _mm512_fmadd_ps(__A, __B, __C); +} +__m512 test_mm512_mask_fmadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_mask_fmadd_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.512 + return _mm512_mask_fmadd_ps(__A, __U, __B, __C); +} +__m512 test_mm512_mask3_fmadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmadd_ps + // CHECK: @llvm.x86.avx512.mask3.vfmadd.ps.512 + return _mm512_mask3_fmadd_ps(__A, __B, __C, __U); +} +__m512 test_mm512_maskz_fmadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_maskz_fmadd_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.512 + return _mm512_maskz_fmadd_ps(__U, __A, __B, __C); +} +__m512 test_mm512_fmsub_ps(__m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_fmsub_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.512 + return _mm512_fmsub_ps(__A, __B, __C); +} +__m512 test_mm512_mask_fmsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_mask_fmsub_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.512 + return _mm512_mask_fmsub_ps(__A, __U, __B, __C); +} +__m512 test_mm512_maskz_fmsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_maskz_fmsub_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.512 + return _mm512_maskz_fmsub_ps(__U, __A, __B, __C); +} +__m512 test_mm512_fnmadd_ps(__m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_fnmadd_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.512 + return _mm512_fnmadd_ps(__A, __B, __C); +} +__m512 test_mm512_mask3_fnmadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { + // CHECK-LABEL: @test_mm512_mask3_fnmadd_ps + // CHECK: @llvm.x86.avx512.mask3.vfmadd.ps.512 + return _mm512_mask3_fnmadd_ps(__A, __B, __C, __U); +} +__m512 test_mm512_maskz_fnmadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_maskz_fnmadd_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.512 + return _mm512_maskz_fnmadd_ps(__U, __A, __B, __C); +} +__m512 test_mm512_fnmsub_ps(__m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_fnmsub_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.512 + return _mm512_fnmsub_ps(__A, __B, __C); +} +__m512 test_mm512_maskz_fnmsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_maskz_fnmsub_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.512 + return _mm512_maskz_fnmsub_ps(__U, __A, __B, __C); +} +__m512d test_mm512_fmaddsub_round_pd(__m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_fmaddsub_round_pd + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.pd.512 + return _mm512_fmaddsub_round_pd(__A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_mask_fmaddsub_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_mask_fmaddsub_round_pd + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.pd.512 + return _mm512_mask_fmaddsub_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_mask3_fmaddsub_round_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmaddsub_round_pd + // CHECK: @llvm.x86.avx512.mask3.vfmaddsub.pd.512 + return _mm512_mask3_fmaddsub_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_maskz_fmaddsub_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_maskz_fmaddsub_round_pd + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.pd.512 + return _mm512_maskz_fmaddsub_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_fmsubadd_round_pd(__m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_fmsubadd_round_pd + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.pd.512 + return _mm512_fmsubadd_round_pd(__A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_mask_fmsubadd_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_mask_fmsubadd_round_pd + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.pd.512 + return _mm512_mask_fmsubadd_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_maskz_fmsubadd_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_maskz_fmsubadd_round_pd + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.pd.512 + return _mm512_maskz_fmsubadd_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_fmaddsub_pd(__m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_fmaddsub_pd + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.pd.512 + return _mm512_fmaddsub_pd(__A, __B, __C); +} +__m512d test_mm512_mask_fmaddsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_mask_fmaddsub_pd + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.pd.512 + return _mm512_mask_fmaddsub_pd(__A, __U, __B, __C); +} +__m512d test_mm512_mask3_fmaddsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmaddsub_pd + // CHECK: @llvm.x86.avx512.mask3.vfmaddsub.pd.512 + return _mm512_mask3_fmaddsub_pd(__A, __B, __C, __U); +} +__m512d test_mm512_maskz_fmaddsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_maskz_fmaddsub_pd + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.pd.512 + return _mm512_maskz_fmaddsub_pd(__U, __A, __B, __C); +} +__m512d test_mm512_fmsubadd_pd(__m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_fmsubadd_pd + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.pd.512 + return _mm512_fmsubadd_pd(__A, __B, __C); +} +__m512d test_mm512_mask_fmsubadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_mask_fmsubadd_pd + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.pd.512 + return _mm512_mask_fmsubadd_pd(__A, __U, __B, __C); +} +__m512d test_mm512_maskz_fmsubadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_maskz_fmsubadd_pd + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.pd.512 + return _mm512_maskz_fmsubadd_pd(__U, __A, __B, __C); +} +__m512 test_mm512_fmaddsub_round_ps(__m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_fmaddsub_round_ps + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.ps.512 + return _mm512_fmaddsub_round_ps(__A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_mask_fmaddsub_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_mask_fmaddsub_round_ps + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.ps.512 + return _mm512_mask_fmaddsub_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_mask3_fmaddsub_round_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmaddsub_round_ps + // CHECK: @llvm.x86.avx512.mask3.vfmaddsub.ps.512 + return _mm512_mask3_fmaddsub_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_maskz_fmaddsub_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_maskz_fmaddsub_round_ps + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.ps.512 + return _mm512_maskz_fmaddsub_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_fmsubadd_round_ps(__m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_fmsubadd_round_ps + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.ps.512 + return _mm512_fmsubadd_round_ps(__A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_mask_fmsubadd_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_mask_fmsubadd_round_ps + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.ps.512 + return _mm512_mask_fmsubadd_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_maskz_fmsubadd_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_maskz_fmsubadd_round_ps + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.ps.512 + return _mm512_maskz_fmsubadd_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_fmaddsub_ps(__m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_fmaddsub_ps + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.ps.512 + return _mm512_fmaddsub_ps(__A, __B, __C); +} +__m512 test_mm512_mask_fmaddsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_mask_fmaddsub_ps + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.ps.512 + return _mm512_mask_fmaddsub_ps(__A, __U, __B, __C); +} +__m512 test_mm512_mask3_fmaddsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmaddsub_ps + // CHECK: @llvm.x86.avx512.mask3.vfmaddsub.ps.512 + return _mm512_mask3_fmaddsub_ps(__A, __B, __C, __U); +} +__m512 test_mm512_maskz_fmaddsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_maskz_fmaddsub_ps + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.ps.512 + return _mm512_maskz_fmaddsub_ps(__U, __A, __B, __C); +} +__m512 test_mm512_fmsubadd_ps(__m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_fmsubadd_ps + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.ps.512 + return _mm512_fmsubadd_ps(__A, __B, __C); +} +__m512 test_mm512_mask_fmsubadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_mask_fmsubadd_ps + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.ps.512 + return _mm512_mask_fmsubadd_ps(__A, __U, __B, __C); +} +__m512 test_mm512_maskz_fmsubadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_maskz_fmsubadd_ps + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.ps.512 + return _mm512_maskz_fmsubadd_ps(__U, __A, __B, __C); +} +__m512d test_mm512_mask3_fmsub_round_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmsub_round_pd + // CHECK: @llvm.x86.avx512.mask3.vfmsub.pd.512 + return _mm512_mask3_fmsub_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_mask3_fmsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmsub_pd + // CHECK: @llvm.x86.avx512.mask3.vfmsub.pd.512 + return _mm512_mask3_fmsub_pd(__A, __B, __C, __U); +} +__m512 test_mm512_mask3_fmsub_round_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmsub_round_ps + // CHECK: @llvm.x86.avx512.mask3.vfmsub.ps.512 + return _mm512_mask3_fmsub_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_mask3_fmsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmsub_ps + // CHECK: @llvm.x86.avx512.mask3.vfmsub.ps.512 + return _mm512_mask3_fmsub_ps(__A, __B, __C, __U); +} +__m512d test_mm512_mask3_fmsubadd_round_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmsubadd_round_pd + // CHECK: @llvm.x86.avx512.mask3.vfmsubadd.pd.512 + return _mm512_mask3_fmsubadd_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_mask3_fmsubadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmsubadd_pd + // CHECK: @llvm.x86.avx512.mask3.vfmsubadd.pd.512 + return _mm512_mask3_fmsubadd_pd(__A, __B, __C, __U); +} +__m512 test_mm512_mask3_fmsubadd_round_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmsubadd_round_ps + // CHECK: @llvm.x86.avx512.mask3.vfmsubadd.ps.512 + return _mm512_mask3_fmsubadd_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_mask3_fmsubadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { + // CHECK-LABEL: @test_mm512_mask3_fmsubadd_ps + // CHECK: @llvm.x86.avx512.mask3.vfmsubadd.ps.512 + return _mm512_mask3_fmsubadd_ps(__A, __B, __C, __U); +} +__m512d test_mm512_mask_fnmadd_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_mask_fnmadd_round_pd + // CHECK: @llvm.x86.avx512.mask.vfnmadd.pd.512 + return _mm512_mask_fnmadd_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_mask_fnmadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_mask_fnmadd_pd + // CHECK: @llvm.x86.avx512.mask.vfnmadd.pd.512 + return _mm512_mask_fnmadd_pd(__A, __U, __B, __C); +} +__m512 test_mm512_mask_fnmadd_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_mask_fnmadd_round_ps + // CHECK: @llvm.x86.avx512.mask.vfnmadd.ps.512 + return _mm512_mask_fnmadd_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_mask_fnmadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_mask_fnmadd_ps + // CHECK: @llvm.x86.avx512.mask.vfnmadd.ps.512 + return _mm512_mask_fnmadd_ps(__A, __U, __B, __C); +} +__m512d test_mm512_mask_fnmsub_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_mask_fnmsub_round_pd + // CHECK: @llvm.x86.avx512.mask.vfnmsub.pd.512 + return _mm512_mask_fnmsub_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_mask3_fnmsub_round_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm512_mask3_fnmsub_round_pd + // CHECK: @llvm.x86.avx512.mask3.vfnmsub.pd.512 + return _mm512_mask3_fnmsub_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_NEAREST_INT); +} +__m512d test_mm512_mask_fnmsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { + // CHECK-LABEL: @test_mm512_mask_fnmsub_pd + // CHECK: @llvm.x86.avx512.mask.vfnmsub.pd.512 + return _mm512_mask_fnmsub_pd(__A, __U, __B, __C); +} +__m512d test_mm512_mask3_fnmsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm512_mask3_fnmsub_pd + // CHECK: @llvm.x86.avx512.mask3.vfnmsub.pd.512 + return _mm512_mask3_fnmsub_pd(__A, __B, __C, __U); +} +__m512 test_mm512_mask_fnmsub_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_mask_fnmsub_round_ps + // CHECK: @llvm.x86.avx512.mask.vfnmsub.ps.512 + return _mm512_mask_fnmsub_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_mask3_fnmsub_round_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { + // CHECK-LABEL: @test_mm512_mask3_fnmsub_round_ps + // CHECK: @llvm.x86.avx512.mask3.vfnmsub.ps.512 + return _mm512_mask3_fnmsub_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_NEAREST_INT); +} +__m512 test_mm512_mask_fnmsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { + // CHECK-LABEL: @test_mm512_mask_fnmsub_ps + // CHECK: @llvm.x86.avx512.mask.vfnmsub.ps.512 + return _mm512_mask_fnmsub_ps(__A, __U, __B, __C); +} +__m512 test_mm512_mask3_fnmsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { + // CHECK-LABEL: @test_mm512_mask3_fnmsub_ps + // CHECK: @llvm.x86.avx512.mask3.vfnmsub.ps.512 + return _mm512_mask3_fnmsub_ps(__A, __B, __C, __U); } __mmask16 test_mm512_cmpeq_epi32_mask(__m512i __a, __m512i __b) { diff --git a/test/CodeGen/avx512vl-builtins.c b/test/CodeGen/avx512vl-builtins.c index 9446d467f78e..00b0d5d90bc1 100644 --- a/test/CodeGen/avx512vl-builtins.c +++ b/test/CodeGen/avx512vl-builtins.c @@ -1121,3 +1121,439 @@ __mmask8 test_mm128_mask_cmp_pd_mask(__mmask8 m, __m128d __A, __m128d __B) { // CHECK: @llvm.x86.avx512.mask.cmp.pd.128 return _mm128_mask_cmp_pd_mask(m, __A, __B, 0); } + + +//igorb + +__m128d test_mm_mask_fmadd_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) { + // CHECK-LABEL: @test_mm_mask_fmadd_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.128 + return _mm_mask_fmadd_pd(__A, __U, __B, __C); +} + +__m128d test_mm_mask_fmsub_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) { + // CHECK-LABEL: @test_mm_mask_fmsub_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.128 + return _mm_mask_fmsub_pd(__A, __U, __B, __C); +} + +__m128d test_mm_mask3_fmadd_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm_mask3_fmadd_pd + // CHECK: @llvm.x86.avx512.mask3.vfmadd.pd.128 + return _mm_mask3_fmadd_pd(__A, __B, __C, __U); +} + +__m128d test_mm_mask3_fnmadd_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm_mask3_fnmadd_pd + // CHECK: @llvm.x86.avx512.mask3.vfmadd.pd.128 + return _mm_mask3_fnmadd_pd(__A, __B, __C, __U); +} + +__m128d test_mm_maskz_fmadd_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) { + // CHECK-LABEL: @test_mm_maskz_fmadd_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.128 + return _mm_maskz_fmadd_pd(__U, __A, __B, __C); +} + +__m128d test_mm_maskz_fmsub_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) { + // CHECK-LABEL: @test_mm_maskz_fmsub_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.128 + return _mm_maskz_fmsub_pd(__U, __A, __B, __C); +} + +__m128d test_mm_maskz_fnmadd_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) { + // CHECK-LABEL: @test_mm_maskz_fnmadd_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.128 + return _mm_maskz_fnmadd_pd(__U, __A, __B, __C); +} + +__m128d test_mm_maskz_fnmsub_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) { + // CHECK-LABEL: @test_mm_maskz_fnmsub_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.128 + return _mm_maskz_fnmsub_pd(__U, __A, __B, __C); +} + +__m256d test_mm256_mask_fmadd_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) { + // CHECK-LABEL: @test_mm256_mask_fmadd_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.256 + return _mm256_mask_fmadd_pd(__A, __U, __B, __C); +} + +__m256d test_mm256_mask_fmsub_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) { + // CHECK-LABEL: @test_mm256_mask_fmsub_pd + // CHECK: @llvm.x86.avx512.mask.vfmadd.pd.256 + return _mm256_mask_fmsub_pd(__A, __U, __B, __C); +} + +__m256d test_mm256_mask3_fmadd_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm256_mask3_fmadd_pd + // CHECK: @llvm.x86.avx512.mask3.vfmadd.pd.256 + return _mm256_mask3_fmadd_pd(__A, __B, __C, __U); +} + +__m256d test_mm256_mask3_fnmadd_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm256_mask3_fnmadd_pd + // CHECK: @llvm.x86.avx512.mask3.vfmadd.pd.256 + return _mm256_mask3_fnmadd_pd(__A, __B, __C, __U); +} + +__m256d test_mm256_maskz_fmadd_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) { + // CHECK-LABEL: @test_mm256_maskz_fmadd_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.256 + return _mm256_maskz_fmadd_pd(__U, __A, __B, __C); +} + +__m256d test_mm256_maskz_fmsub_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) { + // CHECK-LABEL: @test_mm256_maskz_fmsub_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.256 + return _mm256_maskz_fmsub_pd(__U, __A, __B, __C); +} + +__m256d test_mm256_maskz_fnmadd_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) { + // CHECK-LABEL: @test_mm256_maskz_fnmadd_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.256 + return _mm256_maskz_fnmadd_pd(__U, __A, __B, __C); +} + +__m256d test_mm256_maskz_fnmsub_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) { + // CHECK-LABEL: @test_mm256_maskz_fnmsub_pd + // CHECK: @llvm.x86.avx512.maskz.vfmadd.pd.256 + return _mm256_maskz_fnmsub_pd(__U, __A, __B, __C); +} + +__m128 test_mm_mask_fmadd_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) { + // CHECK-LABEL: @test_mm_mask_fmadd_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.128 + return _mm_mask_fmadd_ps(__A, __U, __B, __C); +} + +__m128 test_mm_mask_fmsub_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) { + // CHECK-LABEL: @test_mm_mask_fmsub_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.128 + return _mm_mask_fmsub_ps(__A, __U, __B, __C); +} + +__m128 test_mm_mask3_fmadd_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm_mask3_fmadd_ps + // CHECK: @llvm.x86.avx512.mask3.vfmadd.ps.128 + return _mm_mask3_fmadd_ps(__A, __B, __C, __U); +} + +__m128 test_mm_mask3_fnmadd_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm_mask3_fnmadd_ps + // CHECK: @llvm.x86.avx512.mask3.vfmadd.ps.128 + return _mm_mask3_fnmadd_ps(__A, __B, __C, __U); +} + +__m128 test_mm_maskz_fmadd_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) { + // CHECK-LABEL: @test_mm_maskz_fmadd_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.128 + return _mm_maskz_fmadd_ps(__U, __A, __B, __C); +} + +__m128 test_mm_maskz_fmsub_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) { + // CHECK-LABEL: @test_mm_maskz_fmsub_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.128 + return _mm_maskz_fmsub_ps(__U, __A, __B, __C); +} + +__m128 test_mm_maskz_fnmadd_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) { + // CHECK-LABEL: @test_mm_maskz_fnmadd_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.128 + return _mm_maskz_fnmadd_ps(__U, __A, __B, __C); +} + +__m128 test_mm_maskz_fnmsub_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) { + // CHECK-LABEL: @test_mm_maskz_fnmsub_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.128 + return _mm_maskz_fnmsub_ps(__U, __A, __B, __C); +} + +__m256 test_mm256_mask_fmadd_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) { + // CHECK-LABEL: @test_mm256_mask_fmadd_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.256 + return _mm256_mask_fmadd_ps(__A, __U, __B, __C); +} + +__m256 test_mm256_mask_fmsub_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) { + // CHECK-LABEL: @test_mm256_mask_fmsub_ps + // CHECK: @llvm.x86.avx512.mask.vfmadd.ps.256 + return _mm256_mask_fmsub_ps(__A, __U, __B, __C); +} + +__m256 test_mm256_mask3_fmadd_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm256_mask3_fmadd_ps + // CHECK: @llvm.x86.avx512.mask3.vfmadd.ps.256 + return _mm256_mask3_fmadd_ps(__A, __B, __C, __U); +} + +__m256 test_mm256_mask3_fnmadd_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm256_mask3_fnmadd_ps + // CHECK: @llvm.x86.avx512.mask3.vfmadd.ps.256 + return _mm256_mask3_fnmadd_ps(__A, __B, __C, __U); +} + +__m256 test_mm256_maskz_fmadd_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) { + // CHECK-LABEL: @test_mm256_maskz_fmadd_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.256 + return _mm256_maskz_fmadd_ps(__U, __A, __B, __C); +} + +__m256 test_mm256_maskz_fmsub_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) { + // CHECK-LABEL: @test_mm256_maskz_fmsub_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.256 + return _mm256_maskz_fmsub_ps(__U, __A, __B, __C); +} + +__m256 test_mm256_maskz_fnmadd_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) { + // CHECK-LABEL: @test_mm256_maskz_fnmadd_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.256 + return _mm256_maskz_fnmadd_ps(__U, __A, __B, __C); +} + +__m256 test_mm256_maskz_fnmsub_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) { + // CHECK-LABEL: @test_mm256_maskz_fnmsub_ps + // CHECK: @llvm.x86.avx512.maskz.vfmadd.ps.256 + return _mm256_maskz_fnmsub_ps(__U, __A, __B, __C); +} + +__m128d test_mm_mask_fmaddsub_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) { + // CHECK-LABEL: @test_mm_mask_fmaddsub_pd + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.pd.128 + return _mm_mask_fmaddsub_pd(__A, __U, __B, __C); +} + +__m128d test_mm_mask_fmsubadd_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) { + // CHECK-LABEL: @test_mm_mask_fmsubadd_pd + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.pd.128 + return _mm_mask_fmsubadd_pd(__A, __U, __B, __C); +} + +__m128d test_mm_mask3_fmaddsub_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm_mask3_fmaddsub_pd + // CHECK: @llvm.x86.avx512.mask3.vfmaddsub.pd.128 + return _mm_mask3_fmaddsub_pd(__A, __B, __C, __U); +} + +__m128d test_mm_maskz_fmaddsub_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) { + // CHECK-LABEL: @test_mm_maskz_fmaddsub_pd + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.pd.128 + return _mm_maskz_fmaddsub_pd(__U, __A, __B, __C); +} + +__m128d test_mm_maskz_fmsubadd_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) { + // CHECK-LABEL: @test_mm_maskz_fmsubadd_pd + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.pd.128 + return _mm_maskz_fmsubadd_pd(__U, __A, __B, __C); +} + +__m256d test_mm256_mask_fmaddsub_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) { + // CHECK-LABEL: @test_mm256_mask_fmaddsub_pd + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.pd.256 + return _mm256_mask_fmaddsub_pd(__A, __U, __B, __C); +} + +__m256d test_mm256_mask_fmsubadd_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) { + // CHECK-LABEL: @test_mm256_mask_fmsubadd_pd + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.pd.256 + return _mm256_mask_fmsubadd_pd(__A, __U, __B, __C); +} + +__m256d test_mm256_mask3_fmaddsub_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm256_mask3_fmaddsub_pd + // CHECK: @llvm.x86.avx512.mask3.vfmaddsub.pd.256 + return _mm256_mask3_fmaddsub_pd(__A, __B, __C, __U); +} + +__m256d test_mm256_maskz_fmaddsub_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) { + // CHECK-LABEL: @test_mm256_maskz_fmaddsub_pd + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.pd.256 + return _mm256_maskz_fmaddsub_pd(__U, __A, __B, __C); +} + +__m256d test_mm256_maskz_fmsubadd_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) { + // CHECK-LABEL: @test_mm256_maskz_fmsubadd_pd + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.pd.256 + return _mm256_maskz_fmsubadd_pd(__U, __A, __B, __C); +} + +__m128 test_mm_mask_fmaddsub_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) { + // CHECK-LABEL: @test_mm_mask_fmaddsub_ps + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.ps.128 + return _mm_mask_fmaddsub_ps(__A, __U, __B, __C); +} + +__m128 test_mm_mask_fmsubadd_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) { + // CHECK-LABEL: @test_mm_mask_fmsubadd_ps + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.ps.128 + return _mm_mask_fmsubadd_ps(__A, __U, __B, __C); +} + +__m128 test_mm_mask3_fmaddsub_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm_mask3_fmaddsub_ps + // CHECK: @llvm.x86.avx512.mask3.vfmaddsub.ps.128 + return _mm_mask3_fmaddsub_ps(__A, __B, __C, __U); +} + +__m128 test_mm_maskz_fmaddsub_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) { + // CHECK-LABEL: @test_mm_maskz_fmaddsub_ps + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.ps.128 + return _mm_maskz_fmaddsub_ps(__U, __A, __B, __C); +} + +__m128 test_mm_maskz_fmsubadd_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) { + // CHECK-LABEL: @test_mm_maskz_fmsubadd_ps + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.ps.128 + return _mm_maskz_fmsubadd_ps(__U, __A, __B, __C); +} + +__m256 test_mm256_mask_fmaddsub_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) { + // CHECK-LABEL: @test_mm256_mask_fmaddsub_ps + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.ps.256 + return _mm256_mask_fmaddsub_ps(__A, __U, __B, __C); +} + +__m256 test_mm256_mask_fmsubadd_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) { + // CHECK-LABEL: @test_mm256_mask_fmsubadd_ps + // CHECK: @llvm.x86.avx512.mask.vfmaddsub.ps.256 + return _mm256_mask_fmsubadd_ps(__A, __U, __B, __C); +} + +__m256 test_mm256_mask3_fmaddsub_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm256_mask3_fmaddsub_ps + // CHECK: @llvm.x86.avx512.mask3.vfmaddsub.ps.256 + return _mm256_mask3_fmaddsub_ps(__A, __B, __C, __U); +} + +__m256 test_mm256_maskz_fmaddsub_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) { + // CHECK-LABEL: @test_mm256_maskz_fmaddsub_ps + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.ps.256 + return _mm256_maskz_fmaddsub_ps(__U, __A, __B, __C); +} + +__m256 test_mm256_maskz_fmsubadd_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) { + // CHECK-LABEL: @test_mm256_maskz_fmsubadd_ps + // CHECK: @llvm.x86.avx512.maskz.vfmaddsub.ps.256 + return _mm256_maskz_fmsubadd_ps(__U, __A, __B, __C); +} + +__m128d test_mm_mask3_fmsub_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm_mask3_fmsub_pd + // CHECK: @llvm.x86.avx512.mask3.vfmsub.pd.128 + return _mm_mask3_fmsub_pd(__A, __B, __C, __U); +} + +__m256d test_mm256_mask3_fmsub_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm256_mask3_fmsub_pd + // CHECK: @llvm.x86.avx512.mask3.vfmsub.pd.256 + return _mm256_mask3_fmsub_pd(__A, __B, __C, __U); +} + +__m128 test_mm_mask3_fmsub_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm_mask3_fmsub_ps + // CHECK: @llvm.x86.avx512.mask3.vfmsub.ps.128 + return _mm_mask3_fmsub_ps(__A, __B, __C, __U); +} + +__m256 test_mm256_mask3_fmsub_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm256_mask3_fmsub_ps + // CHECK: @llvm.x86.avx512.mask3.vfmsub.ps.256 + return _mm256_mask3_fmsub_ps(__A, __B, __C, __U); +} + +__m128d test_mm_mask3_fmsubadd_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm_mask3_fmsubadd_pd + // CHECK: @llvm.x86.avx512.mask3.vfmsubadd.pd.128 + return _mm_mask3_fmsubadd_pd(__A, __B, __C, __U); +} + +__m256d test_mm256_mask3_fmsubadd_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm256_mask3_fmsubadd_pd + // CHECK: @llvm.x86.avx512.mask3.vfmsubadd.pd.256 + return _mm256_mask3_fmsubadd_pd(__A, __B, __C, __U); +} + +__m128 test_mm_mask3_fmsubadd_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm_mask3_fmsubadd_ps + // CHECK: @llvm.x86.avx512.mask3.vfmsubadd.ps.128 + return _mm_mask3_fmsubadd_ps(__A, __B, __C, __U); +} + +__m256 test_mm256_mask3_fmsubadd_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm256_mask3_fmsubadd_ps + // CHECK: @llvm.x86.avx512.mask3.vfmsubadd.ps.256 + return _mm256_mask3_fmsubadd_ps(__A, __B, __C, __U); +} + +__m128d test_mm_mask_fnmadd_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) { + // CHECK-LABEL: @test_mm_mask_fnmadd_pd + // CHECK: @llvm.x86.avx512.mask.vfnmadd.pd.128 + return _mm_mask_fnmadd_pd(__A, __U, __B, __C); +} + +__m256d test_mm256_mask_fnmadd_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) { + // CHECK-LABEL: @test_mm256_mask_fnmadd_pd + // CHECK: @llvm.x86.avx512.mask.vfnmadd.pd.256 + return _mm256_mask_fnmadd_pd(__A, __U, __B, __C); +} + +__m128 test_mm_mask_fnmadd_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) { + // CHECK-LABEL: @test_mm_mask_fnmadd_ps + // CHECK: @llvm.x86.avx512.mask.vfnmadd.ps.128 + return _mm_mask_fnmadd_ps(__A, __U, __B, __C); +} + +__m256 test_mm256_mask_fnmadd_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) { + // CHECK-LABEL: @test_mm256_mask_fnmadd_ps + // CHECK: @llvm.x86.avx512.mask.vfnmadd.ps.256 + return _mm256_mask_fnmadd_ps(__A, __U, __B, __C); +} + +__m128d test_mm_mask_fnmsub_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) { + // CHECK-LABEL: @test_mm_mask_fnmsub_pd + // CHECK: @llvm.x86.avx512.mask.vfnmsub.pd.128 + return _mm_mask_fnmsub_pd(__A, __U, __B, __C); +} + +__m128d test_mm_mask3_fnmsub_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm_mask3_fnmsub_pd + // CHECK: @llvm.x86.avx512.mask3.vfnmsub.pd.128 + return _mm_mask3_fnmsub_pd(__A, __B, __C, __U); +} + +__m256d test_mm256_mask_fnmsub_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) { + // CHECK-LABEL: @test_mm256_mask_fnmsub_pd + // CHECK: @llvm.x86.avx512.mask.vfnmsub.pd.256 + return _mm256_mask_fnmsub_pd(__A, __U, __B, __C); +} + +__m256d test_mm256_mask3_fnmsub_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm256_mask3_fnmsub_pd + // CHECK: @llvm.x86.avx512.mask3.vfnmsub.pd.256 + return _mm256_mask3_fnmsub_pd(__A, __B, __C, __U); +} + +__m128 test_mm_mask_fnmsub_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) { + // CHECK-LABEL: @test_mm_mask_fnmsub_ps + // CHECK: @llvm.x86.avx512.mask.vfnmsub.ps.128 + return _mm_mask_fnmsub_ps(__A, __U, __B, __C); +} + +__m128 test_mm_mask3_fnmsub_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm_mask3_fnmsub_ps + // CHECK: @llvm.x86.avx512.mask3.vfnmsub.ps.128 + return _mm_mask3_fnmsub_ps(__A, __B, __C, __U); +} + +__m256 test_mm256_mask_fnmsub_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) { + // CHECK-LABEL: @test_mm256_mask_fnmsub_ps + // CHECK: @llvm.x86.avx512.mask.vfnmsub.ps.256 + return _mm256_mask_fnmsub_ps(__A, __U, __B, __C); +} + +__m256 test_mm256_mask3_fnmsub_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) { + // CHECK-LABEL: @test_mm256_mask3_fnmsub_ps + // CHECK: @llvm.x86.avx512.mask3.vfnmsub.ps.256 + return _mm256_mask3_fnmsub_ps(__A, __B, __C, __U); +} + diff --git a/test/CodeGen/builtin-cpu-supports.c b/test/CodeGen/builtin-cpu-supports.c new file mode 100644 index 000000000000..2252b3e2b8cd --- /dev/null +++ b/test/CodeGen/builtin-cpu-supports.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -emit-llvm < %s| FileCheck %s + +// Test that we have the structure definition, the gep offsets, the name of the +// global, the bit grab, and the icmp correct. +extern void a(const char *); + +int main() { + if (__builtin_cpu_supports("sse4.2")) + a("sse4.2"); + + // CHECK: [[LOAD:%[^ ]+]] = load i32, i32* getelementptr inbounds ({ i32, i32, i32, [1 x i32] }, { i32, i32, i32, [1 x i32] }* @__cpu_model, i32 0, i32 3, i32 0) + // CHECK: [[AND:%[^ ]+]] = and i32 [[LOAD]], 256 + // CHECK = icmp ne i32 [[AND]], 0 + + return 0; +} diff --git a/test/CodeGen/builtins-nvptx.c b/test/CodeGen/builtins-nvptx.c index 5f91f7ad3b0b..ebf20673ddb4 100644 --- a/test/CodeGen/builtins-nvptx.c +++ b/test/CodeGen/builtins-nvptx.c @@ -1,8 +1,13 @@ // REQUIRES: nvptx-registered-target -// RUN: %clang_cc1 -triple nvptx-unknown-unknown -S -emit-llvm -o - %s | FileCheck %s -// RUN: %clang_cc1 -triple nvptx64-unknown-unknown -S -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple nvptx-unknown-unknown -fcuda-is-device -S -emit-llvm -o - -x cuda %s | FileCheck %s +// RUN: %clang_cc1 -triple nvptx64-unknown-unknown -fcuda-is-device -S -emit-llvm -o - -x cuda %s | FileCheck %s -int read_tid() { +#define __device__ __attribute__((device)) +#define __global__ __attribute__((global)) +#define __shared__ __attribute__((shared)) +#define __constant__ __attribute__((constant)) + +__device__ int read_tid() { // CHECK: call i32 @llvm.ptx.read.tid.x() // CHECK: call i32 @llvm.ptx.read.tid.y() @@ -18,7 +23,7 @@ int read_tid() { } -int read_ntid() { +__device__ int read_ntid() { // CHECK: call i32 @llvm.ptx.read.ntid.x() // CHECK: call i32 @llvm.ptx.read.ntid.y() @@ -34,7 +39,7 @@ int read_ntid() { } -int read_ctaid() { +__device__ int read_ctaid() { // CHECK: call i32 @llvm.ptx.read.ctaid.x() // CHECK: call i32 @llvm.ptx.read.ctaid.y() @@ -50,7 +55,7 @@ int read_ctaid() { } -int read_nctaid() { +__device__ int read_nctaid() { // CHECK: call i32 @llvm.ptx.read.nctaid.x() // CHECK: call i32 @llvm.ptx.read.nctaid.y() @@ -66,7 +71,7 @@ int read_nctaid() { } -int read_ids() { +__device__ int read_ids() { // CHECK: call i32 @llvm.ptx.read.laneid() // CHECK: call i32 @llvm.ptx.read.warpid() @@ -86,7 +91,7 @@ int read_ids() { } -int read_lanemasks() { +__device__ int read_lanemasks() { // CHECK: call i32 @llvm.ptx.read.lanemask.eq() // CHECK: call i32 @llvm.ptx.read.lanemask.le() @@ -104,8 +109,7 @@ int read_lanemasks() { } - -long read_clocks() { +__device__ long read_clocks() { // CHECK: call i32 @llvm.ptx.read.clock() // CHECK: call i64 @llvm.ptx.read.clock64() @@ -117,7 +121,7 @@ long read_clocks() { } -int read_pms() { +__device__ int read_pms() { // CHECK: call i32 @llvm.ptx.read.pm0() // CHECK: call i32 @llvm.ptx.read.pm1() @@ -133,7 +137,7 @@ int read_pms() { } -void sync() { +__device__ void sync() { // CHECK: call void @llvm.ptx.bar.sync(i32 0) @@ -146,7 +150,7 @@ void sync() { // The idea is not to test all intrinsics, just that Clang is recognizing the // builtins defined in BuiltinsNVPTX.def -void nvvm_math(float f1, float f2, double d1, double d2) { +__device__ void nvvm_math(float f1, float f2, double d1, double d2) { // CHECK: call float @llvm.nvvm.fmax.f float t1 = __nvvm_fmax_f(f1, f2); // CHECK: call float @llvm.nvvm.fmin.f @@ -176,3 +180,95 @@ void nvvm_math(float f1, float f2, double d1, double d2) { // CHECK: call void @llvm.nvvm.barrier0() __nvvm_bar0(); } + +__device__ int di; +__shared__ int si; +__device__ long dl; +__shared__ long sl; +__device__ long long dll; +__shared__ long long sll; + +// Check for atomic intrinsics +// CHECK-LABEL: nvvm_atom +__device__ void nvvm_atom(float *fp, float f, int *ip, int i, long *lp, long l, + long long *llp, long long ll) { + // CHECK: atomicrmw add + __nvvm_atom_add_gen_i(ip, i); + // CHECK: atomicrmw add + __nvvm_atom_add_gen_l(&dl, l); + // CHECK: atomicrmw add + __nvvm_atom_add_gen_ll(&sll, ll); + + // CHECK: atomicrmw sub + __nvvm_atom_sub_gen_i(ip, i); + // CHECK: atomicrmw sub + __nvvm_atom_sub_gen_l(&dl, l); + // CHECK: atomicrmw sub + __nvvm_atom_sub_gen_ll(&sll, ll); + + // CHECK: atomicrmw and + __nvvm_atom_and_gen_i(ip, i); + // CHECK: atomicrmw and + __nvvm_atom_and_gen_l(&dl, l); + // CHECK: atomicrmw and + __nvvm_atom_and_gen_ll(&sll, ll); + + // CHECK: atomicrmw or + __nvvm_atom_or_gen_i(ip, i); + // CHECK: atomicrmw or + __nvvm_atom_or_gen_l(&dl, l); + // CHECK: atomicrmw or + __nvvm_atom_or_gen_ll(&sll, ll); + + // CHECK: atomicrmw xor + __nvvm_atom_xor_gen_i(ip, i); + // CHECK: atomicrmw xor + __nvvm_atom_xor_gen_l(&dl, l); + // CHECK: atomicrmw xor + __nvvm_atom_xor_gen_ll(&sll, ll); + + // CHECK: atomicrmw xchg + __nvvm_atom_xchg_gen_i(ip, i); + // CHECK: atomicrmw xchg + __nvvm_atom_xchg_gen_l(&dl, l); + // CHECK: atomicrmw xchg + __nvvm_atom_xchg_gen_ll(&sll, ll); + + // CHECK: atomicrmw max + __nvvm_atom_max_gen_i(ip, i); + // CHECK: atomicrmw max + __nvvm_atom_max_gen_ui((unsigned int *)ip, i); + // CHECK: atomicrmw max + __nvvm_atom_max_gen_l(&dl, l); + // CHECK: atomicrmw max + __nvvm_atom_max_gen_ul((unsigned long *)&dl, l); + // CHECK: atomicrmw max + __nvvm_atom_max_gen_ll(&sll, ll); + // CHECK: atomicrmw max + __nvvm_atom_max_gen_ull((unsigned long long *)&sll, ll); + + // CHECK: atomicrmw min + __nvvm_atom_min_gen_i(ip, i); + // CHECK: atomicrmw min + __nvvm_atom_min_gen_ui((unsigned int *)ip, i); + // CHECK: atomicrmw min + __nvvm_atom_min_gen_l(&dl, l); + // CHECK: atomicrmw min + __nvvm_atom_min_gen_ul((unsigned long *)&dl, l); + // CHECK: atomicrmw min + __nvvm_atom_min_gen_ll(&sll, ll); + // CHECK: atomicrmw min + __nvvm_atom_min_gen_ull((unsigned long long *)&sll, ll); + + // CHECK: cmpxchg + __nvvm_atom_cas_gen_i(ip, 0, i); + // CHECK: cmpxchg + __nvvm_atom_cas_gen_l(&dl, 0, l); + // CHECK: cmpxchg + __nvvm_atom_cas_gen_ll(&sll, 0, ll); + + // CHECK: call float @llvm.nvvm.atomic.load.add.f32.p0f32 + __nvvm_atom_add_gen_f(fp, f); + + // CHECK: ret +} diff --git a/test/CodeGen/builtins-ppc-p8vector.c b/test/CodeGen/builtins-ppc-p8vector.c index ac4079016aee..61e14ba283d2 100644 --- a/test/CodeGen/builtins-ppc-p8vector.c +++ b/test/CodeGen/builtins-ppc-p8vector.c @@ -1,7 +1,11 @@ // REQUIRES: powerpc-registered-target // RUN: %clang_cc1 -faltivec -target-feature +power8-vector -triple powerpc64-unknown-unknown -emit-llvm %s -o - | FileCheck %s // 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 +// RUN: not %clang_cc1 -faltivec -target-feature +vsx -triple powerpc64-unknown-unknown -emit-llvm %s -o - 2>&1 | FileCheck %s -check-prefix=CHECK-PPC +// Added -target-feature +vsx above to avoid errors about "vector double" and to +// generate the correct errors for functions that are only overloaded with VSX +// (vec_cmpge, vec_cmple). Without this option, there is only one overload so +// it is selected. 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 }; @@ -11,6 +15,7 @@ vector bool int vbi = {0, -1, -1, 0}; vector bool long long vbll = { 1, 0 }; vector signed long long vsll = { 1, 2 }; vector unsigned long long vull = { 1, 2 }; +vector double vda = { 1.e-11, -132.23e10 }; int res_i; vector signed char res_vsc; @@ -21,10 +26,63 @@ vector bool int res_vbi; vector bool long long res_vbll; vector signed long long res_vsll; vector unsigned long long res_vull; +vector double res_vd; // CHECK-LABEL: define void @test1 void test1() { + /* vec_abs */ + res_vsll = vec_abs(vsll); +// CHECK: call <2 x i64> @llvm.ppc.altivec.vmaxsd(<2 x i64> %{{[0-9]*}}, <2 x i64> +// CHECK-LE: call <2 x i64> @llvm.ppc.altivec.vmaxsd(<2 x i64> %{{[0-9]*}}, <2 x i64> +// CHECK-PPC: error: call to 'vec_abs' is ambiguous + + res_vd = vec_abs(vda); +// CHECK: store <2 x i64> <i64 9223372036854775807, i64 9223372036854775807>, <2 x i64>* +// CHECK: and <2 x i64> +// CHECK-LE: store <2 x i64> <i64 9223372036854775807, i64 9223372036854775807>, <2 x i64>* +// CHECK-LE: and <2 x i64> +// CHECK-PPC: error: call to 'vec_abs' is ambiguous + + /* vec_add */ + res_vsll = vec_add(vsll, vsll); +// CHECK: add <2 x i64> +// CHECK-LE: add <2 x i64> +// CHECK-PPC: error: call to 'vec_add' is ambiguous + + res_vull = vec_add(vull, vull); +// CHECK: add <2 x i64> +// CHECK-LE: add <2 x i64> +// CHECK-PPC: error: call to 'vec_add' is ambiguous + + /* vec_mergee */ + res_vbi = vec_mergee(vbi, vbi); +// CHECK: @llvm.ppc.altivec.vperm +// CHECK-LE: @llvm.ppc.altivec.vperm + + res_vi = vec_mergee(vi, vi); +// CHECK: @llvm.ppc.altivec.vperm +// CHECK-LE: @llvm.ppc.altivec.vperm + + res_vui = vec_mergee(vui, vui); +// CHECK: @llvm.ppc.altivec.vperm +// CHECK-LE: @llvm.ppc.altivec.vperm +// CHECK-PPC: warning: implicit declaration of function 'vec_mergee' + + /* vec_mergeo */ + res_vbi = vec_mergeo(vbi, vbi); +// CHECK: @llvm.ppc.altivec.vperm +// CHECK-LE: @llvm.ppc.altivec.vperm + + res_vi = vec_mergeo(vi, vi); +// CHECK: @llvm.ppc.altivec.vperm +// CHECK-LE: @llvm.ppc.altivec.vperm + + res_vui = vec_mergeo(vui, vui); +// CHECK: @llvm.ppc.altivec.vperm +// CHECK-LE: @llvm.ppc.altivec.vperm +// CHECK-PPC: warning: implicit declaration of function 'vec_mergeo' + /* vec_cmpeq */ res_vbll = vec_cmpeq(vsll, vsll); // CHECK: @llvm.ppc.altivec.vcmpequd @@ -36,6 +94,28 @@ void test1() { // CHECK-LE: @llvm.ppc.altivec.vcmpequd // CHECK-PPC: error: call to 'vec_cmpeq' is ambiguous + /* vec_cmpge */ + res_vbll = vec_cmpge(vsll, vsll); +// CHECK: @llvm.ppc.altivec.vcmpgtsd +// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd +// CHECK-PPC: error: call to 'vec_cmpge' is ambiguous + + res_vbll = vec_cmpge(vull, vull); +// CHECK: @llvm.ppc.altivec.vcmpgtud +// CHECK-LE: @llvm.ppc.altivec.vcmpgtud +// CHECK-PPC: error: call to 'vec_cmpge' is ambiguous + + /* vec_cmple */ + res_vbll = vec_cmple(vsll, vsll); +// CHECK: @llvm.ppc.altivec.vcmpgtsd +// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd +// CHECK-PPC: error: call to 'vec_cmple' is ambiguous + + res_vbll = vec_cmple(vull, vull); +// CHECK: @llvm.ppc.altivec.vcmpgtud +// CHECK-LE: @llvm.ppc.altivec.vcmpgtud +// CHECK-PPC: error: call to 'vec_cmple' is ambiguous + /* vec_cmpgt */ res_vbll = vec_cmpgt(vsll, vsll); // CHECK: @llvm.ppc.altivec.vcmpgtsd @@ -47,6 +127,17 @@ void test1() { // CHECK-LE: @llvm.ppc.altivec.vcmpgtud // CHECK-PPC: error: call to 'vec_cmpgt' is ambiguous + /* vec_cmplt */ + res_vbll = vec_cmplt(vsll, vsll); +// CHECK: call <2 x i64> @llvm.ppc.altivec.vcmpgtsd(<2 x i64> %{{[0-9]*}}, <2 x i64> %{{[0-9]*}}) +// CHECK-LE: call <2 x i64> @llvm.ppc.altivec.vcmpgtsd(<2 x i64> %{{[0-9]*}}, <2 x i64> %{{[0-9]*}}) +// CHECK-PPC: error: call to 'vec_cmplt' is ambiguous + + res_vbll = vec_cmplt(vull, vull); +// CHECK: call <2 x i64> @llvm.ppc.altivec.vcmpgtud(<2 x i64> %{{[0-9]*}}, <2 x i64> %{{[0-9]*}}) +// CHECK-LE: call <2 x i64> @llvm.ppc.altivec.vcmpgtud(<2 x i64> %{{[0-9]*}}, <2 x i64> %{{[0-9]*}}) +// CHECK-PPC: error: call to 'vec_cmplt' is ambiguous + /* ----------------------- predicates --------------------------- */ /* vec_all_eq */ res_i = vec_all_eq(vsll, vsll); diff --git a/test/CodeGen/builtins-ppc-vsx.c b/test/CodeGen/builtins-ppc-vsx.c index 631cb6ccafbe..99362133dd9a 100644 --- a/test/CodeGen/builtins-ppc-vsx.c +++ b/test/CodeGen/builtins-ppc-vsx.c @@ -1,5 +1,6 @@ // REQUIRES: powerpc-registered-target // RUN: %clang_cc1 -faltivec -target-feature +vsx -triple powerpc64-unknown-unknown -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -faltivec -target-feature +vsx -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s vector unsigned char vuc = { 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7}; @@ -16,14 +17,98 @@ vector float res_vf; vector double res_vd; vector signed int res_vsi; vector unsigned int res_vui; +vector bool int res_vbi; vector bool long long res_vbll; vector signed long long res_vsll; vector unsigned long long res_vull; double res_d; +void dummy() { } + void test1() { // CHECK-LABEL: define void @test1 + res_vd = vec_add(vd, vd); +// CHECK: fadd <2 x double> + + res_vd = vec_and(vbll, vd); +// CHECK: and <2 x i64> +// CHECK: bitcast <2 x i64> %{{[0-9]*}} to <2 x double> + + res_vd = vec_and(vd, vbll); +// CHECK: and <2 x i64> +// CHECK: bitcast <2 x i64> %{{[0-9]*}} to <2 x double> + + res_vd = vec_and(vd, vd); +// CHECK: and <2 x i64> +// CHECK: bitcast <2 x i64> %{{[0-9]*}} to <2 x double> + + dummy(); +// CHECK: call void @dummy() + + res_vd = vec_andc(vbll, vd); +// CHECK: bitcast <2 x double> %{{[0-9]*}} to <2 x i64> +// CHECK: xor <2 x i64> %{{[0-9]*}}, <i64 -1, i64 -1> +// CHECK: and <2 x i64> +// CHECK: bitcast <2 x i64> %{{[0-9]*}} to <2 x double> + + dummy(); +// CHECK: call void @dummy() + + res_vd = vec_andc(vd, vbll); +// CHECK: bitcast <2 x double> %{{[0-9]*}} to <2 x i64> +// CHECK: xor <2 x i64> %{{[0-9]*}}, <i64 -1, i64 -1> +// CHECK: and <2 x i64> +// CHECK: bitcast <2 x i64> %{{[0-9]*}} to <2 x double> + + dummy(); +// CHECK: call void @dummy() + + res_vd = vec_andc(vd, vd); +// CHECK: bitcast <2 x double> %{{[0-9]*}} to <2 x i64> +// CHECK: xor <2 x i64> %{{[0-9]*}}, <i64 -1, i64 -1> +// CHECK: and <2 x i64> +// CHECK: bitcast <2 x i64> %{{[0-9]*}} to <2 x double> + + dummy(); +// CHECK: call void @dummy() + + res_vd = vec_ceil(vd); +// CHECK: call <2 x double> @llvm.ceil.v2f64(<2 x double> %{{[0-9]*}}) + + res_vf = vec_ceil(vf); +// CHECK: call <4 x float> @llvm.ceil.v4f32(<4 x float> %{{[0-9]*}}) + + res_vbll = vec_cmpeq(vd, vd); +// CHECK: call <2 x i64> @llvm.ppc.vsx.xvcmpeqdp(<2 x double> %{{[0-9]*}}, <2 x double> %{{[0-9]*}}) + + res_vbi = vec_cmpeq(vf, vf); +// CHECK: call <4 x i32> @llvm.ppc.vsx.xvcmpeqsp(<4 x float> %{{[0-9]*}}, <4 x float> %{{[0-9]*}}) + + res_vbll = vec_cmpge(vd, vd); +// CHECK: call <2 x i64> @llvm.ppc.vsx.xvcmpgedp(<2 x double> %{{[0-9]*}}, <2 x double> %{{[0-9]*}}) + + res_vbi = vec_cmpge(vf, vf); +// CHECK: call <4 x i32> @llvm.ppc.vsx.xvcmpgesp(<4 x float> %{{[0-9]*}}, <4 x float> %{{[0-9]*}}) + + res_vbll = vec_cmpgt(vd, vd); +// CHECK: call <2 x i64> @llvm.ppc.vsx.xvcmpgtdp(<2 x double> %{{[0-9]*}}, <2 x double> %{{[0-9]*}}) + + res_vbi = vec_cmpgt(vf, vf); +// CHECK: call <4 x i32> @llvm.ppc.vsx.xvcmpgtsp(<4 x float> %{{[0-9]*}}, <4 x float> %{{[0-9]*}}) + + res_vbll = vec_cmple(vd, vd); +// CHECK: call <2 x i64> @llvm.ppc.vsx.xvcmpgedp(<2 x double> %{{[0-9]*}}, <2 x double> %{{[0-9]*}}) + + res_vbi = vec_cmple(vf, vf); +// CHECK: call <4 x i32> @llvm.ppc.vsx.xvcmpgesp(<4 x float> %{{[0-9]*}}, <4 x float> %{{[0-9]*}}) + + res_vbll = vec_cmplt(vd, vd); +// CHECK: call <2 x i64> @llvm.ppc.vsx.xvcmpgtdp(<2 x double> %{{[0-9]*}}, <2 x double> %{{[0-9]*}}) + + res_vbi = vec_cmplt(vf, vf); +// CHECK: call <4 x i32> @llvm.ppc.vsx.xvcmpgtsp(<4 x float> %{{[0-9]*}}, <4 x float> %{{[0-9]*}}) + /* vec_div */ res_vf = vec_div(vf, vf); // CHECK: @llvm.ppc.vsx.xvdivsp diff --git a/test/CodeGen/builtins-x86.c b/test/CodeGen/builtins-x86.c index 8a5b5a272d4c..a239889e2b49 100644 --- a/test/CodeGen/builtins-x86.c +++ b/test/CodeGen/builtins-x86.c @@ -260,6 +260,10 @@ void f0() { (void) __builtin_ia32_ldmxcsr(tmp_Ui); tmp_Ui = __builtin_ia32_stmxcsr(); + (void)__builtin_ia32_fxsave(tmp_vp); + (void)__builtin_ia32_fxsave64(tmp_vp); + (void)__builtin_ia32_fxrstor(tmp_vp); + (void)__builtin_ia32_fxrstor64(tmp_vp); tmp_V4f = __builtin_ia32_cvtpi2ps(tmp_V4f, tmp_V2i); tmp_V2i = __builtin_ia32_cvtps2pi(tmp_V4f); tmp_i = __builtin_ia32_cvtss2si(tmp_V4f); diff --git a/test/CodeGen/builtinshufflevector2.c b/test/CodeGen/builtinshufflevector2.c index 8712c991fe18..0e7b2ecd6871 100644 --- a/test/CodeGen/builtinshufflevector2.c +++ b/test/CodeGen/builtinshufflevector2.c @@ -3,7 +3,7 @@ typedef float float4 __attribute__((ext_vector_type(4))); typedef unsigned int uint4 __attribute__((ext_vector_type(4))); -// CHECK-LABEL: define void @clang_shufflevector_v_v( +// CHECK-LABEL: define {{.*}}void @clang_shufflevector_v_v( void clang_shufflevector_v_v( float4* A, float4 x, uint4 mask ) { // CHECK: [[MASK:%.*]] = and <4 x i32> {{%.*}}, <i32 3, i32 3, i32 3, i32 3> // CHECK: [[I:%.*]] = extractelement <4 x i32> [[MASK]], i{{[0-9]+}} 0 @@ -27,14 +27,14 @@ void clang_shufflevector_v_v( float4* A, float4 x, uint4 mask ) { *A = __builtin_shufflevector( x, mask ); } -// CHECK-LABEL: define void @clang_shufflevector_v_v_c( +// CHECK-LABEL: define {{.*}}void @clang_shufflevector_v_v_c( void clang_shufflevector_v_v_c( float4* A, float4 x, float4 y) { // CHECK: [[V:%.*]] = shufflevector <4 x float> {{%.*}}, <4 x float> {{%.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5> // CHECK: store <4 x float> [[V]], <4 x float>* {{%.*}} *A = __builtin_shufflevector( x, y, 0, 4, 1, 5 ); } -// CHECK-LABEL: define void @clang_shufflevector_v_v_undef( +// CHECK-LABEL: define {{.*}}void @clang_shufflevector_v_v_undef( void clang_shufflevector_v_v_undef( float4* A, float4 x, float4 y) { // CHECK: [[V:%.*]] = shufflevector <4 x float> {{%.*}}, <4 x float> {{%.*}}, <4 x i32> <i32 0, i32 4, i32 undef, i32 5> // CHECK: store <4 x float> [[V]], <4 x float>* {{%.*}} diff --git a/test/CodeGen/c-strings.c b/test/CodeGen/c-strings.c index 588a716a16a4..974eeea87677 100644 --- a/test/CodeGen/c-strings.c +++ b/test/CodeGen/c-strings.c @@ -23,44 +23,44 @@ unsigned char align = 1; void bar(const char *); -// CHECK-LABEL: define void @f0() +// CHECK-LABEL: define {{.*}}void @f0() void f0() { bar("hello"); - // ITANIUM: call void @bar({{.*}} @.str - // MSABI: call void @bar({{.*}} @"\01??_C@_05CJBACGMB@hello?$AA@" + // ITANIUM: call {{.*}}void @bar({{.*}} @.str + // MSABI: call {{.*}}void @bar({{.*}} @"\01??_C@_05CJBACGMB@hello?$AA@" } -// CHECK-LABEL: define void @f1() +// CHECK-LABEL: define {{.*}}void @f1() void f1() { static char *x = "hello"; bar(x); // CHECK: [[T1:%.*]] = load i8*, i8** @f1.x - // CHECK: call void @bar(i8* [[T1:%.*]]) + // CHECK: call {{.*}}void @bar(i8* [[T1:%.*]]) } -// CHECK-LABEL: define void @f2() +// CHECK-LABEL: define {{.*}}void @f2() void f2() { static char x[] = "hello"; bar(x); - // CHECK: call void @bar({{.*}} @f2.x + // CHECK: call {{.*}}void @bar({{.*}} @f2.x } -// CHECK-LABEL: define void @f3() +// CHECK-LABEL: define {{.*}}void @f3() void f3() { static char x[8] = "hello"; bar(x); - // CHECK: call void @bar({{.*}} @f3.x + // CHECK: call {{.*}}void @bar({{.*}} @f3.x } void gaz(void *); -// CHECK-LABEL: define void @f4() +// CHECK-LABEL: define {{.*}}void @f4() void f4() { static struct s { char *name; } x = { "hello" }; gaz(&x); - // CHECK: call void @gaz({{.*}} @f4.x + // CHECK: call {{.*}}void @gaz({{.*}} @f4.x } char x[3] = "ola"; diff --git a/test/CodeGen/c11atomics.c b/test/CodeGen/c11atomics.c index a35eef942648..d1e4478d7ecd 100644 --- a/test/CodeGen/c11atomics.c +++ b/test/CodeGen/c11atomics.c @@ -12,8 +12,24 @@ // they're sufficiently rare that it's not worth making sure that the semantics // are correct. -// CHECK: @testStructGlobal = global {{.*}} { i16 1, i16 2, i16 3, i16 4 } -// CHECK: @testPromotedStructGlobal = global {{.*}} { %{{.*}} { i16 1, i16 2, i16 3 }, [2 x i8] zeroinitializer } +struct elem; + +struct ptr { + struct elem *ptr; +}; +// CHECK-DAG: %struct.ptr = type { %struct.elem* } + +struct elem { + _Atomic(struct ptr) link; +}; +// CHECK-DAG: %struct.elem = type { %struct.ptr } + +struct ptr object; +// CHECK-DAG: @object = common global %struct.ptr zeroinitializer + +// CHECK-DAG: @testStructGlobal = global {{.*}} { i16 1, i16 2, i16 3, i16 4 } +// CHECK-DAG: @testPromotedStructGlobal = global {{.*}} { %{{.*}} { i16 1, i16 2, i16 3 }, [2 x i8] zeroinitializer } + typedef int __attribute__((vector_size(16))) vector; diff --git a/test/CodeGen/call.c b/test/CodeGen/call.c index 723911158c05..eec6e52b72f2 100644 --- a/test/CodeGen/call.c +++ b/test/CodeGen/call.c @@ -18,7 +18,7 @@ void JS_ReportErrorNumber(JSErrorCallback errorCallback, ...); void Interpret() { JS_ReportErrorNumber(js_GetErrorMessage, 0); - // CHECK: call void ({{.*}}, ...) @JS_ReportErrorNumber({{.*}}@js_GetErrorMessage + // CHECK: call {{.*}}void ({{.*}}, ...) @JS_ReportErrorNumber({{.*}}@js_GetErrorMessage } diff --git a/test/CodeGen/captured-statements-nested.c b/test/CodeGen/captured-statements-nested.c index 646424339b7f..b81705b8ad89 100644 --- a/test/CodeGen/captured-statements-nested.c +++ b/test/CodeGen/captured-statements-nested.c @@ -30,7 +30,7 @@ void test_nest_captured_stmt(int param, int size, int param_arr[size]) { param_arr[size - 1] = 2; arr[10][z.a] = 12; - // CHECK1: define internal void @__captured_stmt{{.*}}([[T]] + // CHECK1: define internal {{.*}}void @__captured_stmt{{.*}}([[T]] // CHECK1: [[PARAM_ARR_SIZE_REF:%.+]] = getelementptr inbounds [[T]], [[T]]* {{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 5 // CHECK1: [[PARAM_ARR_SIZE:%.+]] = load [[SIZE_TYPE]], [[SIZE_TYPE]]* [[PARAM_ARR_SIZE_REF]] // CHECK1: [[ARR_SIZE1_REF:%.+]] = getelementptr inbounds [[T]], [[T]]* {{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 8 @@ -106,7 +106,7 @@ void test_nest_block() { } }(); - // CHECK2: define internal void @{{.*}}test_nest_block_block_invoke + // CHECK2: define internal {{.*}}void @{{.*}}test_nest_block_block_invoke // // CHECK2: [[Z:%[0-9a-z_]*]] = alloca i{{[0-9]+}}, // CHECK2: alloca %struct.anon{{.*}} diff --git a/test/CodeGen/captured-statements.c b/test/CodeGen/captured-statements.c index b4fbfd43d5ca..53632ac45d72 100644 --- a/test/CodeGen/captured-statements.c +++ b/test/CodeGen/captured-statements.c @@ -28,7 +28,7 @@ void test1() { // CHECK-1: call void @[[HelperName:__captured_stmt[\.0-9]+]] } -// CHECK-1: define internal void @[[HelperName]](%struct.anon +// CHECK-1: define internal {{.*}}void @[[HelperName]](%struct.anon // CHECK-1: getelementptr inbounds %struct.anon{{.*}}, i32 0, i32 0 // CHECK-1: load i32*, i32** // CHECK-1: load i32, i32* @@ -48,7 +48,7 @@ void test2(int x) { // CHECK-2: call void @[[HelperName:__captured_stmt[\.0-9]+]] } -// CHECK-2: define internal void @[[HelperName]] +// CHECK-2: define internal {{.*}}void @[[HelperName]] // CHECK-2-NOT: } // CHECK-2: %i = alloca i32 @@ -93,7 +93,7 @@ void dont_capture_global() { // CHECK-GLOBALS: call void @__captured_stmt[[HelperName:[\.0-9]+]](%[[Capture]] } -// CHECK-GLOBALS: define internal void @__captured_stmt[[HelperName]] +// CHECK-GLOBALS: define internal {{.*}}void @__captured_stmt[[HelperName]] // CHECK-GLOBALS-NOT: ret // CHECK-GLOBALS: load i32, i32* @global // CHECK-GLOBALS: load i32, i32* @ diff --git a/test/CodeGen/complex-convert.c b/test/CodeGen/complex-convert.c index 0db258840577..c65a98cec2be 100644 --- a/test/CodeGen/complex-convert.c +++ b/test/CodeGen/complex-convert.c @@ -21,7 +21,7 @@ void foo(signed char sc, unsigned char uc, signed long long sll, _Complex unsigned char cuc1; _Complex signed long long csll1; _Complex unsigned long long cull1; - // CHECK-LABEL: define void @foo( + // CHECK-LABEL: define {{.*}}void @foo( // Match the prototype to pick up the size of sc and sll. // CHECK: i[[CHSIZE:[0-9]+]]{{[^,]*}}, // CHECK: i[[CHSIZE]]{{[^,]*}}, diff --git a/test/CodeGen/debug-info-packed-struct.c b/test/CodeGen/debug-info-packed-struct.c new file mode 100644 index 000000000000..0b5226bf1131 --- /dev/null +++ b/test/CodeGen/debug-info-packed-struct.c @@ -0,0 +1,91 @@ +// RUN: %clang_cc1 -x c -g -emit-llvm -triple x86_64-apple-darwin -o - %s | FileCheck %s + +// CHECK: %struct.layout0 = type { i8, %struct.size8, i8 } +// CHECK: %struct.layout1 = type <{ i8, %struct.size8_anon, i8, [2 x i8] }> +// CHECK: %struct.layout2 = type <{ i8, %struct.size8_pack1, i8 }> +// CHECK: %struct.layout3 = type <{ i8, [3 x i8], %struct.size8_pack4, i8, [3 x i8] }> + +// --------------------------------------------------------------------- +// Not packed. +// --------------------------------------------------------------------- +struct size8 { + int i : 4; + long long l : 60; +}; +struct layout0 { + char l0_ofs0; + struct size8 l0_ofs8; + int l0_ofs16 : 1; +}; +// CHECK: l0_ofs0 +// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "l0_ofs8", +// CHECK-SAME: {{.*}}size: 64, align: 64, offset: 64) +// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "l0_ofs16", +// CHECK-SAME: {{.*}}size: 1, align: 32, offset: 128) + + +// --------------------------------------------------------------------- +// Implicitly packed. +// --------------------------------------------------------------------- +struct size8_anon { + int : 4; + long long : 60; +}; +struct layout1 { + char l1_ofs0; + struct size8_anon l1_ofs1; + int l1_ofs9 : 1; +}; +// CHECK: l1_ofs0 +// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "l1_ofs1", +// CHECK-SAME: {{.*}}size: 64, align: 8, offset: 8) +// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "l1_ofs9", +// CHECK-SAME: {{.*}}size: 1, align: 32, offset: 72) + + +// --------------------------------------------------------------------- +// Explicitly packed. +// --------------------------------------------------------------------- +#pragma pack(1) +struct size8_pack1 { + int i : 4; + long long l : 60; +}; +struct layout2 { + char l2_ofs0; + struct size8_pack1 l2_ofs1; + int l2_ofs9 : 1; +}; +#pragma pack() +// CHECK: l2_ofs0 +// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "l2_ofs1", +// CHECK-SAME: {{.*}}size: 64, align: 8, offset: 8) +// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "l2_ofs9", +// CHECK-SAME: {{.*}}size: 1, align: 32, offset: 72) + + + +// --------------------------------------------------------------------- +// Explicitly packed with different alignment. +// --------------------------------------------------------------------- +#pragma pack(4) +struct size8_pack4 { + int i : 4; + long long l : 60; +}; +struct layout3 { + char l3_ofs0; + struct size8_pack4 l3_ofs4; + int l3_ofs12 : 1; +}; +#pragma pack() +// CHECK: l3_ofs0 +// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "l3_ofs4", +// CHECK-SAME: {{.*}}size: 64, align: 32, offset: 32) +// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "l3_ofs12", +// CHECK-SAME: {{.*}}size: 1, align: 32, offset: 96) + +struct layout0 l0; +struct layout1 l1; +struct layout2 l2; +struct layout3 l3; diff --git a/test/CodeGen/dostmt.c b/test/CodeGen/dostmt.c index 54973dc99b6e..67ef64e42d4c 100644 --- a/test/CodeGen/dostmt.c +++ b/test/CodeGen/dostmt.c @@ -71,6 +71,6 @@ void test6f(void); void test6() { do { } while (test6f(), 0); - // CHECK: call void @test6f() + // CHECK: call {{.*}}void @test6f() } diff --git a/test/CodeGen/fast-math.c b/test/CodeGen/fast-math.c index 4a513589ef4c..6f98b8432746 100644 --- a/test/CodeGen/fast-math.c +++ b/test/CodeGen/fast-math.c @@ -2,7 +2,7 @@ float f0, f1, f2; void foo(void) { - // CHECK-LABEL: define void @foo() + // CHECK-LABEL: define {{.*}}void @foo() // CHECK: fadd fast f0 = f1 + f2; diff --git a/test/CodeGen/finite-math.c b/test/CodeGen/finite-math.c index 8365b56fe56b..90a83fa30958 100644 --- a/test/CodeGen/finite-math.c +++ b/test/CodeGen/finite-math.c @@ -5,7 +5,7 @@ float f0, f1, f2; void foo(void) { - // CHECK-LABEL: define void @foo() + // CHECK-LABEL: define {{.*}}void @foo() // FINITE: fadd nnan ninf // NSZ: fadd nsz diff --git a/test/CodeGen/linkage-redecl.c b/test/CodeGen/linkage-redecl.c index 58993f349f81..4767a94a45f6 100644 --- a/test/CodeGen/linkage-redecl.c +++ b/test/CodeGen/linkage-redecl.c @@ -16,4 +16,4 @@ void g0() { } extern void f(int x) { } // still has internal linkage -// CHECK-LABEL: define internal void @f +// CHECK-LABEL: define internal {{.*}}void @f diff --git a/test/CodeGen/nomathbuiltin.c b/test/CodeGen/nomathbuiltin.c index f80cd91de9d4..35e7c567e68d 100644 --- a/test/CodeGen/nomathbuiltin.c +++ b/test/CodeGen/nomathbuiltin.c @@ -7,6 +7,6 @@ double pow(double, double); double foo(double a, double b) { return pow(a, b); -// CHECK: call double @pow +// CHECK: call {{.*}}double @pow } diff --git a/test/CodeGen/openmp_default_simd_align.c b/test/CodeGen/openmp_default_simd_align.c new file mode 100644 index 000000000000..dcab5abf8fcc --- /dev/null +++ b/test/CodeGen/openmp_default_simd_align.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -O1 -emit-llvm -o - %s | FileCheck %s + +enum e0 { E0 }; +struct s0 { + enum e0 a:31; +}; + +int f0() { + return __builtin_omp_required_simd_align(struct s0); + // CHECK: ret i32 16 +} diff --git a/test/CodeGen/pr9614.c b/test/CodeGen/pr9614.c index 53abef1801d9..63cb5af1868c 100644 --- a/test/CodeGen/pr9614.c +++ b/test/CodeGen/pr9614.c @@ -4,26 +4,42 @@ extern void foo_alias (void) __asm ("foo"); inline void foo (void) { return foo_alias (); } -extern void bar_alias (void) __asm ("bar"); -inline __attribute__ ((__always_inline__)) void bar (void) { - return bar_alias (); +extern int abs_alias (int) __asm ("abs"); +inline __attribute__ ((__always_inline__)) int abs (int x) { + return abs_alias(x); } extern char *strrchr_foo (const char *__s, int __c) __asm ("strrchr"); extern inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * strrchr_foo (const char *__s, int __c) { return __builtin_strrchr (__s, __c); } + +extern inline void __attribute__((always_inline, __gnu_inline__)) +prefetch(void) { + __builtin_prefetch(0, 0, 1); +} + +extern inline __attribute__((__always_inline__, __gnu_inline__)) void *memchr(void *__s, int __c, __SIZE_TYPE__ __n) { + return __builtin_memchr(__s, __c, __n); +} + void f(void) { foo(); - bar(); + abs(0); strrchr_foo("", '.'); + prefetch(); + memchr("", '.', 0); } // CHECK-LABEL: define void @f() // CHECK: call void @foo() -// CHECK-NEXT: call void @bar() -// CHECK-NEXT: call i8* @strrchr( -// CHECK-NEXT: ret void +// CHECK: call i32 @abs(i32 0) +// CHECK: call i8* @strrchr( +// CHECK: call void @llvm.prefetch( +// CHECK: call i8* @memchr( +// CHECK: ret void // CHECK: declare void @foo() -// CHECK: declare void @bar() +// CHECK: declare i32 @abs(i32 // CHECK: declare i8* @strrchr(i8*, i32) +// CHECK: declare i8* @memchr( +// CHECK: declare void @llvm.prefetch( diff --git a/test/CodeGen/redefine_extname.c b/test/CodeGen/redefine_extname.c index a91e5b836ae6..ad4106dd4535 100644 --- a/test/CodeGen/redefine_extname.c +++ b/test/CodeGen/redefine_extname.c @@ -13,3 +13,14 @@ int fish() { return fake() + __PRAGMA_REDEFINE_EXTNAME + name; } // CHECK: call i32 @real() // Check that this also works with variables names // CHECK: load i32, i32* @alias + +// This is a case when redefenition is deferred *and* we have a local of the +// same name. PR23923. +#pragma redefine_extname foo bar +int f() { + int foo = 0; + return foo; +} +extern int foo() { return 1; } +// CHECK: define i32 @bar() + diff --git a/test/CodeGen/stack-protector.c b/test/CodeGen/stack-protector.c index 8039b6059efd..ecfbc90faa28 100644 --- a/test/CodeGen/stack-protector.c +++ b/test/CodeGen/stack-protector.c @@ -1,13 +1,13 @@ // RUN: %clang_cc1 -emit-llvm -o - %s -stack-protector 0 | FileCheck -check-prefix=NOSSP %s -// NOSSP: define void @test1(i8* %msg) #0 { +// NOSSP: define {{.*}}void @test1(i8* %msg) #0 { // RUN: %clang_cc1 -emit-llvm -o - %s -stack-protector 1 | FileCheck -check-prefix=WITHSSP %s -// WITHSSP: define void @test1(i8* %msg) #0 { +// WITHSSP: define {{.*}}void @test1(i8* %msg) #0 { // RUN: %clang_cc1 -emit-llvm -o - %s -stack-protector 2 | FileCheck -check-prefix=SSPSTRONG %s -// SSPSTRONG: define void @test1(i8* %msg) #0 { +// 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 { +// 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 { +// SAFESTACK: define {{.*}}void @test1(i8* %msg) #0 { typedef __SIZE_TYPE__ size_t; diff --git a/test/CodeGen/static-order.c b/test/CodeGen/static-order.c index 58aabbebd57e..20277d7b6583 100644 --- a/test/CodeGen/static-order.c +++ b/test/CodeGen/static-order.c @@ -1,7 +1,7 @@ // RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s // CHECK: ModuleID // CHECK-NOT: zeroinitializer -// CHECK-LABEL: define i8* @f +// CHECK-LABEL: define {{.*}}i8* @f struct s { int a; diff --git a/test/CodeGen/ubsan-blacklist.c b/test/CodeGen/ubsan-blacklist.c index 6c67f027e922..f6e38822bff8 100644 --- a/test/CodeGen/ubsan-blacklist.c +++ b/test/CodeGen/ubsan-blacklist.c @@ -14,9 +14,9 @@ unsigned i; // FUNC: @hash // FILE: @hash unsigned hash() { -// DEFAULT: call void @__ubsan -// FUNC-NOT: call void @__ubsan -// FILE-NOT: call void @__ubsan +// DEFAULT: call {{.*}}void @__ubsan +// FUNC-NOT: call {{.*}}void @__ubsan +// FILE-NOT: call {{.*}}void @__ubsan return i * 37; } @@ -24,8 +24,8 @@ unsigned hash() { // FUNC: @add // FILE: @add unsigned add() { -// DEFAULT: call void @__ubsan -// FUNC: call void @__ubsan -// FILE-NOT: call void @__ubsan +// DEFAULT: call {{.*}}void @__ubsan +// FUNC: call {{.*}}void @__ubsan +// FILE-NOT: call {{.*}}void @__ubsan return i + 1; } diff --git a/test/CodeGen/volatile-1.c b/test/CodeGen/volatile-1.c index 71cd5f8d1b24..f63274b37f61 100644 --- a/test/CodeGen/volatile-1.c +++ b/test/CodeGen/volatile-1.c @@ -22,7 +22,7 @@ int printf(const char *, ...); // that do implicit lvalue-to-rvalue conversion are substantially // reduced. -// CHECK-LABEL: define void @test() +// CHECK-LABEL: define {{.*}}void @test() void test() { // CHECK: load volatile [[INT]], [[INT]]* @i i; @@ -303,11 +303,11 @@ void test() { } extern volatile enum X x; -// CHECK-LABEL: define void @test1() +// CHECK-LABEL: define {{.*}}void @test1() void test1() { extern void test1_helper(void); test1_helper(); - // CHECK: call void @test1_helper() + // CHECK: call {{.*}}void @test1_helper() // CHECK-NEXT: ret void x; (void) x; diff --git a/test/CodeGen/x86_64-arguments.c b/test/CodeGen/x86_64-arguments.c index c412e3c06e86..bb9fba190262 100644 --- a/test/CodeGen/x86_64-arguments.c +++ b/test/CodeGen/x86_64-arguments.c @@ -1,7 +1,9 @@ // RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | \ -// RUN: FileCheck %s -check-prefix=CHECK -check-prefix=SSE +// RUN: FileCheck %s -check-prefix=CHECK -check-prefix=SSE -check-prefix=NO-AVX512 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s -target-feature +avx | \ -// RUN: FileCheck %s -check-prefix=CHECK -check-prefix=AVX +// RUN: FileCheck %s -check-prefix=CHECK -check-prefix=AVX -check-prefix=NO-AVX512 +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s -target-feature +avx512f | \ +// RUN: FileCheck %s -check-prefix=CHECK -check-prefix=AVX -check-prefix=AVX512 #include <stdarg.h> // CHECK-LABEL: define signext i8 @f0() @@ -458,3 +460,77 @@ void test54() { } // AVX: @test54_helper(<8 x float> {{%[a-zA-Z0-9]+}}, <8 x float> {{%[a-zA-Z0-9]+}}, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double {{%[a-zA-Z0-9]+}}, double {{%[a-zA-Z0-9]+}}) // AVX: @test54_helper(<8 x float> {{%[a-zA-Z0-9]+}}, <8 x float> {{%[a-zA-Z0-9]+}}, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, { double, double }* byval align 8 {{%[a-zA-Z0-9]+}}) + +typedef float __m512 __attribute__ ((__vector_size__ (64))); +typedef struct { + __m512 m; +} s512; + +s512 x55; +__m512 x56; + +// Even on AVX512, aggregates of size larger than four eightbytes have class +// MEMORY (AVX512 draft 0.3 3.2.3p2 Rule 1). +// +// CHECK: declare void @f55(%struct.s512* byval align 64) +void f55(s512 x); + +// However, __m512 has type SSE/SSEUP on AVX512. +// +// AVX512: declare void @f56(<16 x float>) +// NO-AVX512: declare void @f56(<16 x float>* byval align 64) +void f56(__m512 x); +void f57() { f55(x55); f56(x56); } + +// Like for __m128 on AVX, check that the struct below is passed +// in the same way regardless of AVX512 being used. +// +// CHECK: declare void @f58(%struct.t256* byval align 32) +typedef struct t256 { + __m256 m; + __m256 n; +} two256; + +extern void f58(two256 s); +void f59(two256 s) { + f58(s); +} + +// CHECK: declare void @f60(%struct.sat256* byval align 32) +typedef struct at256 { + __m256 array[2]; +} Atwo256; +typedef struct sat256 { + Atwo256 x; +} SAtwo256; + +extern void f60(SAtwo256 s); +void f61(SAtwo256 s) { + f60(s); +} + +// AVX512: @f62_helper(i32 0, <16 x float> {{%[a-zA-Z0-9]+}}, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double {{%[a-zA-Z0-9]+}}, double {{%[a-zA-Z0-9]+}}) +void f62_helper(int, ...); +__m512 x62; +void f62() { + f62_helper(0, x62, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0i); +} + +// Like for __m256 on AVX, we always pass __m512 in memory, and don't +// need to use the register save area. +// +// AVX512-LABEL: define void @f63 +// AVX512-NOT: br i1 +// AVX512: ret void +void f63(__m512 *m, __builtin_va_list argList) { + *m = __builtin_va_arg(argList, __m512); +} + +// AVX512: @f64_helper(<16 x float> {{%[a-zA-Z0-9]+}}, <16 x float> {{%[a-zA-Z0-9]+}}, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double {{%[a-zA-Z0-9]+}}, double {{%[a-zA-Z0-9]+}}) +// AVX512: @f64_helper(<16 x float> {{%[a-zA-Z0-9]+}}, <16 x float> {{%[a-zA-Z0-9]+}}, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, { double, double }* byval align 8 {{%[a-zA-Z0-9]+}}) +void f64_helper(__m512, ...); +__m512 x64; +void f64() { + f64_helper(x64, x64, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0i); + f64_helper(x64, x64, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0i); +} diff --git a/test/CodeGenCXX/PR5093-static-member-function.cpp b/test/CodeGenCXX/PR5093-static-member-function.cpp index d61a87ac16dc..681135182bf2 100644 --- a/test/CodeGenCXX/PR5093-static-member-function.cpp +++ b/test/CodeGenCXX/PR5093-static-member-function.cpp @@ -4,6 +4,6 @@ struct a { }; void g(a *a) { - // CHECK: call void @_ZN1a1fEv() + // CHECK: call {{.*}}void @_ZN1a1fEv() a->f(); } diff --git a/test/CodeGenCXX/address-of-fntemplate.cpp b/test/CodeGenCXX/address-of-fntemplate.cpp index 4ff597acb304..4840fe89edb8 100644 --- a/test/CodeGenCXX/address-of-fntemplate.cpp +++ b/test/CodeGenCXX/address-of-fntemplate.cpp @@ -9,8 +9,8 @@ void test() { // CHECK: @_Z1fIiEvv void (*p2)() = f<int>; } -// CHECK-LABEL: define linkonce_odr void @_Z1fIiEvT_ -// CHECK-LABEL: define linkonce_odr void @_Z1fIiEvv +// CHECK-LABEL: define linkonce_odr {{.*}}void @_Z1fIiEvT_ +// CHECK-LABEL: define linkonce_odr {{.*}}void @_Z1fIiEvv namespace PR6973 { template<typename T> diff --git a/test/CodeGenCXX/attr-cleanup.cpp b/test/CodeGenCXX/attr-cleanup.cpp index 18a7798481e9..5ece41a29947 100644 --- a/test/CodeGenCXX/attr-cleanup.cpp +++ b/test/CodeGenCXX/attr-cleanup.cpp @@ -5,7 +5,7 @@ namespace N { } int main(void) { - // CHECK: call void @_ZN1N4freeEPv + // CHECK: call {{.*}}void @_ZN1N4freeEPv void *fp __attribute__((cleanup(N::free))); return 0; } diff --git a/test/CodeGenCXX/block-byref-cxx-objc.cpp b/test/CodeGenCXX/block-byref-cxx-objc.cpp index 5c35ad72a20d..ce1ebd615ef8 100644 --- a/test/CodeGenCXX/block-byref-cxx-objc.cpp +++ b/test/CodeGenCXX/block-byref-cxx-objc.cpp @@ -20,9 +20,9 @@ int main() // CHECK-LABEL: define internal void @__Block_byref_object_dispose_ // CHECK: call {{.*}} @_ZN1AD1Ev // CHECK-LABEL: define internal void @__copy_helper_block_ -// CHECK: call void @_Block_object_assign +// CHECK: call {{.*}}void @_Block_object_assign // CHECK-LABEL: define internal void @__destroy_helper_block_ -// CHECK: call void @_Block_object_dispose +// CHECK: call {{.*}}void @_Block_object_dispose // rdar://problem/11135650 namespace test1 { diff --git a/test/CodeGenCXX/c-linkage.cpp b/test/CodeGenCXX/c-linkage.cpp index 2f8729e4971a..a70a22ef08c7 100644 --- a/test/CodeGenCXX/c-linkage.cpp +++ b/test/CodeGenCXX/c-linkage.cpp @@ -15,10 +15,10 @@ extern "C" { extern "C" { static void test2_f() { } - // CHECK-LABEL: define internal void @_Z7test2_fv + // CHECK-LABEL: define internal {{.*}}void @_Z7test2_fv static void test2_f(int x) { } - // CHECK-LABEL: define internal void @_Z7test2_fi + // CHECK-LABEL: define internal {{.*}}void @_Z7test2_fi void test2_use() { test2_f(); test2_f(42); diff --git a/test/CodeGenCXX/captured-statements.cpp b/test/CodeGenCXX/captured-statements.cpp index ebb38334d07c..fdda24fcf301 100644 --- a/test/CodeGenCXX/captured-statements.cpp +++ b/test/CodeGenCXX/captured-statements.cpp @@ -44,11 +44,11 @@ void test1() { // CHECK-1: ret } -// CHECK-1: define internal void @[[HelperName]] +// CHECK-1: define internal {{.*}}void @[[HelperName]] // CHECK-1: getelementptr inbounds %[[Capture]], %[[Capture]]* {{[^,]*}}, i32 0, i32 0 -// CHECK-1: call i32 @__cxa_guard_acquire( +// CHECK-1: call {{.*}}i32 @__cxa_guard_acquire( // CHECK-1: store double %{{.+}}, double* [[INNER]], -// CHECK-1: call void @__cxa_guard_release( +// CHECK-1: call {{.*}}void @__cxa_guard_release( // CHECK-1: getelementptr inbounds %struct.TestClass, %struct.TestClass* {{[^,]*}}, i32 0, i32 0 // CHECK-1: getelementptr inbounds %[[Capture]], %[[Capture]]* {{[^,]*}}, i32 0, i32 1 @@ -61,13 +61,13 @@ void test2(int x) { return x; }(); - // CHECK-2-LABEL: define void @_Z5test2i + // CHECK-2-LABEL: define {{.*}}void @_Z5test2i // CHECK-2: call {{.*}} @[[Lambda:["$\w]+]] // // CHECK-2: define internal {{.*}} @[[Lambda]] // CHECK-2: call void @[[HelperName:["$_A-Za-z0-9]+]](%[[Capture:.*]]* // - // CHECK-2: define internal void @[[HelperName]] + // CHECK-2: define internal {{.*}}void @[[HelperName]] // CHECK-2: getelementptr inbounds %[[Capture]], %[[Capture]]* // CHECK-2: load i32*, i32** // CHECK-2: load i32, i32* @@ -81,7 +81,7 @@ void test3(int x) { // CHECK-3: %[[Capture:struct\.anon[\.0-9]*]] = type { i32* } - // CHECK-3-LABEL: define void @_Z5test3i + // CHECK-3-LABEL: define {{.*}}void @_Z5test3i // CHECK-3: store i32* // CHECK-3: call void @{{.*}}__captured_stmt // CHECK-3: ret void @@ -93,11 +93,11 @@ void test4() { Foo f; f.x = 5; } - // CHECK-4-LABEL: define void @_Z5test4v + // CHECK-4-LABEL: define {{.*}}void @_Z5test4v // CHECK-4: call void @[[HelperName:[\."$_A-Za-z0-9]+]](%[[Capture:.*]]* // CHECK-4: ret void // - // CHECK-4: define internal void @[[HelperName]] + // CHECK-4: define internal {{.*}}void @[[HelperName]] // CHECK-4: store i32 5, i32* // CHECK-4: call {{.*}}FooD1Ev } diff --git a/test/CodeGenCXX/constructor-attr.cpp b/test/CodeGenCXX/constructor-attr.cpp index 468ce36688f7..ec27ed210ce7 100644 --- a/test/CodeGenCXX/constructor-attr.cpp +++ b/test/CodeGenCXX/constructor-attr.cpp @@ -5,7 +5,7 @@ // PR6521 void bar(); struct Foo { - // CHECK-LABEL: define linkonce_odr void @_ZN3Foo3fooEv + // CHECK-LABEL: define linkonce_odr {{.*}}void @_ZN3Foo3fooEv static void foo() __attribute__((constructor)) { bar(); } diff --git a/test/CodeGenCXX/ctor-globalopt.cpp b/test/CodeGenCXX/ctor-globalopt.cpp index 26ec523c553b..bcab60916aec 100644 --- a/test/CodeGenCXX/ctor-globalopt.cpp +++ b/test/CodeGenCXX/ctor-globalopt.cpp @@ -11,8 +11,8 @@ // CHECK: @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] // CHECK: [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_ctor_globalopt.cpp, i8* null }] -// CHECK-LABEL: define internal void @_GLOBAL__sub_I_ctor_globalopt.cpp() -// CHECK: call void @ +// CHECK-LABEL: define internal {{.*}}void @_GLOBAL__sub_I_ctor_globalopt.cpp() +// CHECK: call {{.*}}void @ // CHECK-NOT: call{{ }} // O1: @llvm.global_ctors = appending global [0 x { i32, void ()*, i8* }] zeroinitializer diff --git a/test/CodeGenCXX/debug-info-line.cpp b/test/CodeGenCXX/debug-info-line.cpp index 0b1b43b86f3c..7f8e117315c0 100644 --- a/test/CodeGenCXX/debug-info-line.cpp +++ b/test/CodeGenCXX/debug-info-line.cpp @@ -158,7 +158,7 @@ __complex double f11() { void f12() { int f12_1(); void f12_2(int = f12_1()); -// CHECK: call {{(signext )?}}i32 {{.*}} !dbg [[DBG_F12:!.*]] +// CHECK: call {{.*}}{{(signext )?}}i32 {{.*}} !dbg [[DBG_F12:!.*]] #line 1400 f12_2(); } diff --git a/test/CodeGenCXX/debug-info-method-nodebug.cpp b/test/CodeGenCXX/debug-info-method-nodebug.cpp new file mode 100644 index 000000000000..474053a4caa9 --- /dev/null +++ b/test/CodeGenCXX/debug-info-method-nodebug.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s + +class C { + void present(); + void absent() __attribute__((nodebug)); +}; + +C c; + +// CHECK-NOT: name: "absent" +// CHECK: name: "present" +// CHECK-NOT: name: "absent" diff --git a/test/CodeGenCXX/debug-info-namespace.cpp b/test/CodeGenCXX/debug-info-namespace.cpp index d59b778676c4..35b371ec9c9d 100644 --- a/test/CodeGenCXX/debug-info-namespace.cpp +++ b/test/CodeGenCXX/debug-info-namespace.cpp @@ -55,7 +55,7 @@ void B::func_fwd() {} // This should work even if 'i' and 'func' were declarations & not definitions, // but it doesn't yet. -// CHECK: [[CU:![0-9]+]] = !DICompileUnit( +// CHECK: [[CU:![0-9]+]] = distinct !DICompileUnit( // CHECK-SAME: imports: [[MODULES:![0-9]*]] // CHECK: [[FOO:![0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "foo", // CHECK-SAME: line: 5 @@ -102,7 +102,7 @@ void B::func_fwd() {} // CHECK: [[M16]] = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: [[FUNC]], entity: [[FUNC_FWD:![0-9]+]] // CHECK: [[M17]] = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: [[CTXT]], entity: [[I]] -// CHECK-GMLT: [[CU:![0-9]+]] = !DICompileUnit( +// CHECK-GMLT: [[CU:![0-9]+]] = distinct !DICompileUnit( // CHECK-GMLT-SAME: emissionKind: 2, // CHECK-GMLT-SAME: imports: [[MODULES:![0-9]+]] // CHECK-GMLT: [[MODULES]] = !{} diff --git a/test/CodeGenCXX/deferred-global-init.cpp b/test/CodeGenCXX/deferred-global-init.cpp index 920037c25356..e4c0d075568d 100644 --- a/test/CodeGenCXX/deferred-global-init.cpp +++ b/test/CodeGenCXX/deferred-global-init.cpp @@ -7,10 +7,10 @@ void* bar() { return a; } // CHECK: @_ZL1a = internal global i8* null -// CHECK-LABEL: define internal void @__cxx_global_var_init +// CHECK-LABEL: define internal {{.*}}void @__cxx_global_var_init // CHECK: load i8*, i8** @foo // CHECK: ret void -// CHECK-LABEL: define internal void @_GLOBAL__sub_I_deferred_global_init.cpp -// CHECK: call void @__cxx_global_var_init() +// CHECK-LABEL: define internal {{.*}}void @_GLOBAL__sub_I_deferred_global_init.cpp +// CHECK: call {{.*}}void @__cxx_global_var_init() // CHECK: ret void diff --git a/test/CodeGenCXX/derived-to-virtual-base-class-calls-final.cpp b/test/CodeGenCXX/derived-to-virtual-base-class-calls-final.cpp index dd64e8123081..3a4766de321a 100644 --- a/test/CodeGenCXX/derived-to-virtual-base-class-calls-final.cpp +++ b/test/CodeGenCXX/derived-to-virtual-base-class-calls-final.cpp @@ -9,7 +9,7 @@ struct D final : virtual C { virtual void f(); }; -// CHECK-LABEL: define dereferenceable({{[0-9]+}}) %struct.B* @_Z1fR1D +// CHECK-LABEL: define {{.*}}dereferenceable({{[0-9]+}}) %struct.B* @_Z1fR1D B &f(D &d) { // CHECK-NOT: load i8*, i8** return d; diff --git a/test/CodeGenCXX/destructor-crash.cpp b/test/CodeGenCXX/destructor-crash.cpp new file mode 100644 index 000000000000..43291986514d --- /dev/null +++ b/test/CodeGenCXX/destructor-crash.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 %s -emit-llvm -std=c++11 -o %t + +struct A { + ~A(); +}; + +struct B { + A a; +}; + +struct C { + union { + B b; + }; + + ~C() noexcept; +}; + +C::~C() noexcept {} diff --git a/test/CodeGenCXX/dllexport.cpp b/test/CodeGenCXX/dllexport.cpp index 0eb6476bd0ec..c598880b625e 100644 --- a/test/CodeGenCXX/dllexport.cpp +++ b/test/CodeGenCXX/dllexport.cpp @@ -486,7 +486,7 @@ struct S { struct CtorWithClosure { __declspec(dllexport) CtorWithClosure(...) {} -// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_FCtorWithClosure@@QAEXXZ" +// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_FCtorWithClosure@@QAEXXZ"({{.*}}) comdat // M32-DAG: %[[this_addr:.*]] = alloca %struct.CtorWithClosure*, align 4 // M32-DAG: store %struct.CtorWithClosure* %this, %struct.CtorWithClosure** %[[this_addr]], align 4 // M32-DAG: %[[this:.*]] = load %struct.CtorWithClosure*, %struct.CtorWithClosure** %[[this_addr]] @@ -503,7 +503,7 @@ struct CtorWithClosure { struct __declspec(dllexport) ClassWithClosure { DELETE_IMPLICIT_MEMBERS(ClassWithClosure); ClassWithClosure(...) {} -// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_FClassWithClosure@@QAEXXZ" +// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_FClassWithClosure@@QAEXXZ"({{.*}}) comdat // M32-DAG: %[[this_addr:.*]] = alloca %struct.ClassWithClosure*, align 4 // M32-DAG: store %struct.ClassWithClosure* %this, %struct.ClassWithClosure** %[[this_addr]], align 4 // M32-DAG: %[[this:.*]] = load %struct.ClassWithClosure*, %struct.ClassWithClosure** %[[this_addr]] @@ -520,8 +520,8 @@ struct __declspec(dllexport) NestedOuter { }; }; -// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_FNestedOuter@@QAEXXZ" -// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_FNestedInner@NestedOuter@@QAEXXZ" +// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_FNestedOuter@@QAEXXZ"({{.*}}) comdat +// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_FNestedInner@NestedOuter@@QAEXXZ"({{.*}}) comdat template <typename T> struct SomeTemplate { @@ -530,7 +530,7 @@ struct SomeTemplate { }; struct __declspec(dllexport) InheritFromTemplate : SomeTemplate<int> {}; -// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_F?$SomeTemplate@H@@QAEXXZ" +// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_F?$SomeTemplate@H@@QAEXXZ"({{.*}}) comdat namespace PR23801 { template <typename> @@ -546,7 +546,7 @@ struct __declspec(dllexport) B { }; } // -// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_FB@PR23801@@QAEXXZ" +// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??_FB@PR23801@@QAEXXZ"({{.*}}) comdat struct __declspec(dllexport) T { // Copy assignment operator: diff --git a/test/CodeGenCXX/dynamic_cast-no-rtti.cpp b/test/CodeGenCXX/dynamic_cast-no-rtti.cpp index cde03a3f4e09..58834a550be1 100644 --- a/test/CodeGenCXX/dynamic_cast-no-rtti.cpp +++ b/test/CodeGenCXX/dynamic_cast-no-rtti.cpp @@ -13,14 +13,14 @@ struct B : public A { // does not use runtime support. A *upcast(B *b) { return dynamic_cast<A *>(b); -// CHECK-LABEL: define %struct.A* @_Z6upcastP1B -// CHECK-NOT: call i8* @__dynamic_cast +// CHECK-LABEL: define {{.*}}%struct.A* @_Z6upcastP1B +// CHECK-NOT: call {{.*}}i8* @__dynamic_cast } // A NoOp dynamic_cast can be used with -fno-rtti iff it does not use // runtime support. B *samecast(B *b) { return dynamic_cast<B *>(b); -// CHECK-LABEL: define %struct.B* @_Z8samecastP1B -// CHECK-NOT: call i8* @__dynamic_cast +// CHECK-LABEL: define {{.*}}%struct.B* @_Z8samecastP1B +// CHECK-NOT: call {{.*}}i8* @__dynamic_cast } diff --git a/test/CodeGenCXX/extern-c.cpp b/test/CodeGenCXX/extern-c.cpp index 7852644d2b74..e68738b9db58 100644 --- a/test/CodeGenCXX/extern-c.cpp +++ b/test/CodeGenCXX/extern-c.cpp @@ -71,5 +71,5 @@ namespace PR19411 { struct A { void f(); }; extern "C" void A::f() { void g(); g(); } // CHECK-LABEL: @_ZN7PR194111A1fEv( - // CHECK: call void @g() + // CHECK: call {{.*}}void @g() } diff --git a/test/CodeGenCXX/function-template-explicit-specialization.cpp b/test/CodeGenCXX/function-template-explicit-specialization.cpp index 8ff065569757..ed6cf84c2be5 100644 --- a/test/CodeGenCXX/function-template-explicit-specialization.cpp +++ b/test/CodeGenCXX/function-template-explicit-specialization.cpp @@ -3,11 +3,11 @@ template<typename T> void a(T); template<> void a(int) {} -// CHECK-LABEL: define void @_Z1aIiEvT_ +// CHECK-LABEL: define {{.*}}void @_Z1aIiEvT_ namespace X { template<typename T> void b(T); template<> void b(int) {} } -// CHECK-LABEL: define void @_ZN1X1bIiEEvT_ +// CHECK-LABEL: define {{.*}}void @_ZN1X1bIiEEvT_ diff --git a/test/CodeGenCXX/globalinit-loc.cpp b/test/CodeGenCXX/globalinit-loc.cpp index 813a890ae5b6..27120526fc30 100644 --- a/test/CodeGenCXX/globalinit-loc.cpp +++ b/test/CodeGenCXX/globalinit-loc.cpp @@ -4,7 +4,7 @@ // Verify that the global init helper function does not get associated // with any source location. // -// CHECK: define internal void @_GLOBAL__sub_I_globalinit_loc.cpp +// CHECK: define internal {{.*}}void @_GLOBAL__sub_I_globalinit_loc.cpp // CHECK: !dbg ![[DBG:.*]] // CHECK: !DISubprogram(linkageName: "_GLOBAL__sub_I_globalinit_loc.cpp" // CHECK-NOT: line: diff --git a/test/CodeGenCXX/inline-dllexport-member.cpp b/test/CodeGenCXX/inline-dllexport-member.cpp index af9a5360674a..4bc1d4ce633a 100644 --- a/test/CodeGenCXX/inline-dllexport-member.cpp +++ b/test/CodeGenCXX/inline-dllexport-member.cpp @@ -5,7 +5,7 @@ struct __declspec(dllexport) s { static const unsigned int ui = 0; }; -// CHECK: ![[SCOPE:[0-9]+]] = !DICompileUnit( +// CHECK: ![[SCOPE:[0-9]+]] = distinct !DICompileUnit( // CHECK: !DIGlobalVariable(name: "ui", linkageName: "_ZN1s2uiE", scope: ![[SCOPE]], // CHECK-SAME: variable: i32* @_ZN1s2uiE diff --git a/test/CodeGenCXX/linetable-virtual-variadic.cpp b/test/CodeGenCXX/linetable-virtual-variadic.cpp index c16c5e354b5c..115f1ae71408 100644 --- a/test/CodeGenCXX/linetable-virtual-variadic.cpp +++ b/test/CodeGenCXX/linetable-virtual-variadic.cpp @@ -17,7 +17,7 @@ void Derived::VariadicFunction(...) { } // // CHECK: !llvm.dbg.cu = !{![[CU:[0-9]+]]} // -// CHECK: ![[CU]] = !DICompileUnit({{.*}} subprograms: ![[SPs:[0-9]+]] +// CHECK: ![[CU]] = distinct !DICompileUnit({{.*}} subprograms: ![[SPs:[0-9]+]] // CHECK: ![[SPs]] = !{![[SP:[0-9]+]]} // CHECK: ![[SP]] = !DISubprogram(name: "VariadicFunction",{{.*}} function: {{[^:]+}} @_ZN7Derived16VariadicFunctionEz // CHECK: ![[LOC]] = !DILocation({{.*}}scope: ![[SP]]) diff --git a/test/CodeGenCXX/mangle-address-space.cpp b/test/CodeGenCXX/mangle-address-space.cpp index a0b3c1aff224..f18480de83de 100644 --- a/test/CodeGenCXX/mangle-address-space.cpp +++ b/test/CodeGenCXX/mangle-address-space.cpp @@ -1,12 +1,12 @@ // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s -// CHECK-LABEL: define void @_Z2f0Pc +// CHECK-LABEL: define {{.*}}void @_Z2f0Pc void f0(char *p) { } -// CHECK-LABEL: define void @_Z2f0PU3AS1c +// CHECK-LABEL: define {{.*}}void @_Z2f0PU3AS1c void f0(char __attribute__((address_space(1))) *p) { } struct OpaqueType; typedef OpaqueType __attribute__((address_space(100))) * OpaqueTypePtr; -// CHECK-LABEL: define void @_Z2f0PU5AS10010OpaqueType +// CHECK-LABEL: define {{.*}}void @_Z2f0PU5AS10010OpaqueType void f0(OpaqueTypePtr) { } diff --git a/test/CodeGenCXX/mangle-ms-templates-memptrs-2.cpp b/test/CodeGenCXX/mangle-ms-templates-memptrs-2.cpp index e2cbe15dfa9f..b01d6099d8f7 100644 --- a/test/CodeGenCXX/mangle-ms-templates-memptrs-2.cpp +++ b/test/CodeGenCXX/mangle-ms-templates-memptrs-2.cpp @@ -3,22 +3,37 @@ template <typename T, int (T::*)() = nullptr> struct J {}; +template <typename T, int T::* = nullptr> +struct K {}; + struct __single_inheritance M; J<M> m; // CHECK-DAG: @"\01?m@@3U?$J@UM@@$0A@@@A" +K<M> m2; +// CHECK-DAG: @"\01?m2@@3U?$K@UM@@$0?0@@A" + struct __multiple_inheritance N; J<N> n; // CHECK-DAG: @"\01?n@@3U?$J@UN@@$HA@@@A" +K<N> n2; +// CHECK-DAG: @"\01?n2@@3U?$K@UN@@$0?0@@A" + struct __virtual_inheritance O; J<O> o; // CHECK-DAG: @"\01?o@@3U?$J@UO@@$IA@A@@@A" +K<O> o2; +// CHECK-DAG: @"\01?o2@@3U?$K@UO@@$FA@?0@@A" + struct P; J<P> p; // CHECK-DAG: @"\01?p@@3U?$J@UP@@$JA@A@?0@@A" +K<P> p2; +// CHECK-DAG: @"\01?p2@@3U?$K@UP@@$GA@A@?0@@A" + #pragma pointers_to_members(full_generality, virtual_inheritance) struct S { diff --git a/test/CodeGenCXX/mangle-ms-templates-memptrs.cpp b/test/CodeGenCXX/mangle-ms-templates-memptrs.cpp index 803cac3748b1..e710abe97e98 100644 --- a/test/CodeGenCXX/mangle-ms-templates-memptrs.cpp +++ b/test/CodeGenCXX/mangle-ms-templates-memptrs.cpp @@ -69,8 +69,8 @@ void ReadFields() { // them right in class templates. // CHECK: call {{.*}} @"\01??$ReadField@US@@$0A@@@YAHAAUS@@@Z" // CHECK: call {{.*}} @"\01??$ReadField@UM@@$0A@@@YAHAAUM@@@Z" -// CHECK: call {{.*}} @"\01??$ReadField@UV@@$FA@?0@@YAHAAUV@@@Z" -// CHECK: call {{.*}} @"\01??$ReadField@UU@@$GA@A@?0@@YAHAAUU@@@Z" +// CHECK: call {{.*}} @"\01??$ReadField@UV@@$0A@@@YAHAAUV@@@Z" +// CHECK: call {{.*}} @"\01??$ReadField@UU@@$0A@@@YAHAAUU@@@Z" // Non-polymorphic null data memptr vs first field memptr. MSVC mangles these // the same. @@ -141,3 +141,15 @@ void CallMethods() { // CHECK: call {{.*}} @"\01??$CallMethod@UM@@$0A@@@YAXAAUM@@@Z" // CHECK: call {{.*}} @"\01??$CallMethod@UV@@$0A@@@YAXAAUV@@@Z" // CHECK: call {{.*}} @"\01??$CallMethod@UU@@$0A@@@YAXAAUU@@@Z" + +namespace NegativeNVOffset { +struct A {}; +struct B : virtual A {}; +struct C : B { + virtual void f(); +}; +} + +template void CallMethod<NegativeNVOffset::C, &NegativeNVOffset::C::f>(NegativeNVOffset::C &); + +// CHECK-LABEL: define {{.*}} @"\01??$CallMethod@UC@NegativeNVOffset@@$I??_912@$BA@AEPPPPPPPM@A@@@YAXAAUC@NegativeNVOffset@@@Z" diff --git a/test/CodeGenCXX/mangle-nullptr-arg.cpp b/test/CodeGenCXX/mangle-nullptr-arg.cpp index 66ed7e5cfe34..e4ae3538c58e 100644 --- a/test/CodeGenCXX/mangle-nullptr-arg.cpp +++ b/test/CodeGenCXX/mangle-nullptr-arg.cpp @@ -2,15 +2,15 @@ template<int *ip> struct IP {}; -// CHECK-LABEL: define void @_Z5test12IPILPi0EE +// CHECK-LABEL: define {{.*}}void @_Z5test12IPILPi0EE void test1(IP<nullptr>) {} struct X{ }; template<int X::*pm> struct PM {}; -// CHECK-LABEL: define void @_Z5test22PMILM1Xi0EE +// CHECK-LABEL: define {{.*}}void @_Z5test22PMILM1Xi0EE void test2(PM<nullptr>) { } -// CHECK-LABEL: define void @_Z5test316DependentTypePtrIPiLS0_0EE +// CHECK-LABEL: define {{.*}}void @_Z5test316DependentTypePtrIPiLS0_0EE template<typename T, T x> struct DependentTypePtr {}; void test3(DependentTypePtr<int*,nullptr>) { } diff --git a/test/CodeGenCXX/mangle-template.cpp b/test/CodeGenCXX/mangle-template.cpp index aaae4b27f9a3..7fa300ae237b 100644 --- a/test/CodeGenCXX/mangle-template.cpp +++ b/test/CodeGenCXX/mangle-template.cpp @@ -98,7 +98,7 @@ namespace test8 { template<typename T> void f(int_c<meta<T>::type::value>) { } - // CHECK-LABEL: define weak_odr void @_ZN5test81fIiEEvNS_5int_cIXsr4metaIT_E4typeE5valueEEE( + // CHECK-LABEL: define weak_odr {{.*}}void @_ZN5test81fIiEEvNS_5int_cIXsr4metaIT_E4typeE5valueEEE( template void f<int>(int_c<sizeof(int)>); } @@ -157,13 +157,13 @@ namespace test12 { const int n = 10; template<typename T, T v> void test() {} void use() { - // CHECK-LABEL: define internal void @_ZN6test124testIFivEXadL_ZNS_L1fEvEEEEvv( + // CHECK-LABEL: define internal {{.*}}void @_ZN6test124testIFivEXadL_ZNS_L1fEvEEEEvv( test<int(), &f>(); - // CHECK-LABEL: define internal void @_ZN6test124testIRFivEL_ZNS_L1fEvEEEvv( + // CHECK-LABEL: define internal {{.*}}void @_ZN6test124testIRFivEL_ZNS_L1fEvEEEvv( test<int(&)(), f>(); - // CHECK-LABEL: define internal void @_ZN6test124testIPKiXadL_ZNS_L1nEEEEEvv( + // CHECK-LABEL: define internal {{.*}}void @_ZN6test124testIPKiXadL_ZNS_L1nEEEEEvv( test<const int*, &n>(); - // CHECK-LABEL: define internal void @_ZN6test124testIRKiL_ZNS_L1nEEEEvv( + // CHECK-LABEL: define internal {{.*}}void @_ZN6test124testIRKiL_ZNS_L1nEEEEvv( test<const int&, n>(); } } diff --git a/test/CodeGenCXX/microsoft-abi-array-cookies.cpp b/test/CodeGenCXX/microsoft-abi-array-cookies.cpp index 619b1b8a9489..62ead4fb69d3 100644 --- a/test/CodeGenCXX/microsoft-abi-array-cookies.cpp +++ b/test/CodeGenCXX/microsoft-abi-array-cookies.cpp @@ -58,4 +58,14 @@ void check_array_cookies_aligned() { // CHECK: getelementptr inbounds i8, i8* [[ARRAY_AS_CHAR]], i64 -8 } +namespace PR23990 { +struct S { + char x[42]; + void operator delete[](void *p, __SIZE_TYPE__); + // CHECK-LABEL: define void @"\01?delete_s@PR23990@@YAXPAUS@1@@Z"( + // CHECK: call void @"\01??_VS@PR23990@@SAXPAXI@Z"(i8* {{.*}}, i32 42) +}; +void delete_s(S *s) { delete[] s; } +} + // CHECK: attributes [[NUW]] = { nounwind{{.*}} } diff --git a/test/CodeGenCXX/microsoft-abi-member-pointers.cpp b/test/CodeGenCXX/microsoft-abi-member-pointers.cpp index 8cb4a1f8bd24..a509d57194f2 100755 --- a/test/CodeGenCXX/microsoft-abi-member-pointers.cpp +++ b/test/CodeGenCXX/microsoft-abi-member-pointers.cpp @@ -541,9 +541,13 @@ void (D::*convertCToD(void (C::*mp)()))() { // // memptr.convert: ; preds = %entry // CHECK: extractvalue { i8*, i32, i32 } %{{.*}}, 0 -// CHECK: extractvalue { i8*, i32, i32 } %{{.*}}, 1 -// CHECK: extractvalue { i8*, i32, i32 } %{{.*}}, 2 -// CHECK: %[[adj:.*]] = add nsw i32 %{{.*}}, 4 +// CHECK: %[[nvoff:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 1 +// CHECK: %[[vbidx:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 2 +// CHECK: %[[is_nvbase:.*]] = icmp eq i32 %[[vbidx]], 0 +// CHECK: %[[nv_disp:.*]] = add nsw i32 %[[nvoff]], 4 +// CHECK: %[[nv_adj:.*]] = select i1 %[[is_nvbase]], i32 %[[nv_disp]], i32 0 +// CHECK: %[[dst_adj:.*]] = select i1 %[[is_nvbase]], i32 4, i32 0 +// CHECK: %[[adj:.*]] = sub nsw i32 %[[nv_adj]], %[[dst_adj]] // CHECK: insertvalue { i8*, i32, i32 } undef, i8* {{.*}}, 0 // CHECK: insertvalue { i8*, i32, i32 } {{.*}}, i32 %[[adj]], 1 // CHECK: insertvalue { i8*, i32, i32 } {{.*}}, i32 {{.*}}, 2 @@ -712,3 +716,16 @@ int foo(A *a, int A::*mp) { } #endif #endif + +namespace pr23878 { +struct A { virtual void g(); }; +struct B { virtual void f(); }; +struct C : virtual B { void f(); }; +struct D : A, C {}; + +typedef void (D::*DMemPtrTy)(); + +// CHECK-LABEL: define void @"\01?get_memptr@pr23878@@YAP8D@1@AEXXZXZ" +// CHECK: @"\01??_9C@pr23878@@$BA@AE" to i8*), i32 0, i32 4 +DMemPtrTy get_memptr() { return &D::f; } +} diff --git a/test/CodeGenCXX/microsoft-abi-thunks.cpp b/test/CodeGenCXX/microsoft-abi-thunks.cpp index 8cbea5c4deeb..823033461612 100644 --- a/test/CodeGenCXX/microsoft-abi-thunks.cpp +++ b/test/CodeGenCXX/microsoft-abi-thunks.cpp @@ -91,7 +91,7 @@ struct E : D { E::E() {} // Emits vftable and forces thunk generation. -// CODEGEN-LABEL: define weak_odr x86_thiscallcc %struct.C* @"\01?goo@E@@QAEPAUB@@XZ" +// CODEGEN-LABEL: define weak_odr x86_thiscallcc %struct.C* @"\01?goo@E@@QAEPAUB@@XZ"{{.*}} comdat // CODEGEN: call x86_thiscallcc %struct.C* @"\01?goo@E@@UAEPAUC@@XZ" // CODEGEN: getelementptr inbounds i8, i8* {{.*}}, i32 4 // CODEGEN: ret @@ -124,7 +124,7 @@ struct I : D { I::I() {} // Emits vftable and forces thunk generation. -// CODEGEN-LABEL: define weak_odr x86_thiscallcc %struct.{{[BF]}}* @"\01?goo@I@@QAEPAUB@@XZ" +// CODEGEN-LABEL: define weak_odr x86_thiscallcc %struct.{{[BF]}}* @"\01?goo@I@@QAEPAUB@@XZ"{{.*}} comdat // CODEGEN: %[[ORIG_RET:.*]] = call x86_thiscallcc %struct.F* @"\01?goo@I@@UAEPAUF@@XZ" // CODEGEN: %[[ORIG_RET_i8:.*]] = bitcast %struct.F* %[[ORIG_RET]] to i8* // CODEGEN: %[[VBPTR_i8:.*]] = getelementptr inbounds i8, i8* %[[ORIG_RET_i8]], i32 4 diff --git a/test/CodeGenCXX/pr11797.cpp b/test/CodeGenCXX/pr11797.cpp index 2a31090e4218..3767b1d62d14 100644 --- a/test/CodeGenCXX/pr11797.cpp +++ b/test/CodeGenCXX/pr11797.cpp @@ -5,4 +5,4 @@ namespace std __attribute__ ((__visibility__ ("default"))) {} void foo() { } #pragma GCC visibility pop -// CHECK-LABEL: define void @_Z3foov() +// CHECK-LABEL: define {{.*}}void @_Z3foov() diff --git a/test/CodeGenCXX/pr18661.cpp b/test/CodeGenCXX/pr18661.cpp index 235867831e28..65ffd6f910c6 100644 --- a/test/CodeGenCXX/pr18661.cpp +++ b/test/CodeGenCXX/pr18661.cpp @@ -11,4 +11,4 @@ extern "C" { // PR18661: Clang would fail to emit function definition with mismatching // exception specification, even though it was just treated as a warning. -// CHECK: define void @f() +// CHECK: define {{.*}}void @f() diff --git a/test/CodeGenCXX/pr9965.cpp b/test/CodeGenCXX/pr9965.cpp index 46fd60914b0e..95ba2beb87fc 100644 --- a/test/CodeGenCXX/pr9965.cpp +++ b/test/CodeGenCXX/pr9965.cpp @@ -8,7 +8,7 @@ struct X : A // default constructor is not trivial }; X<int> x; -// CHECK-LABEL: define internal void @__cxx_global_var_init() +// CHECK-LABEL: define internal {{.*}}void @__cxx_global_var_init() // CHECK: call {{.*}} @_ZN1XIiEC1Ev // CHECK: define linkonce_odr {{.*}} @_ZN1XIiEC1Ev // CHECK: define linkonce_odr {{.*}} @_ZN1XIiEC2Ev diff --git a/test/CodeGenCXX/pragma-weak.cpp b/test/CodeGenCXX/pragma-weak.cpp index e2d464818edb..caab2662a9f5 100644 --- a/test/CodeGenCXX/pragma-weak.cpp +++ b/test/CodeGenCXX/pragma-weak.cpp @@ -14,18 +14,18 @@ void S::foo() {} #pragma weak zed namespace bar { void zed() {} } -// CHECK-LABEL: define void @_ZN3bar3zedEv( +// CHECK-LABEL: define {{.*}}void @_ZN3bar3zedEv( #pragma weak bah void bah() {} -// CHECK-LABEL: define void @_Z3bahv( +// CHECK-LABEL: define {{.*}}void @_Z3bahv( #pragma weak baz extern "C" void baz() {} -// CHECK-LABEL: define weak void @baz( +// CHECK-LABEL: define weak {{.*}}void @baz( #pragma weak _Z3baxv void bax() {} // GCC produces a weak symbol for this one, but it doesn't look like a good // idea to expose the mangling to the pragma unless we really have to. -// CHECK-LABEL: define void @_Z3baxv( +// CHECK-LABEL: define {{.*}}void @_Z3baxv( diff --git a/test/CodeGenCXX/predefined-expr.cpp b/test/CodeGenCXX/predefined-expr.cpp index 4c0a8861b996..21cceddf19e6 100644 --- a/test/CodeGenCXX/predefined-expr.cpp +++ b/test/CodeGenCXX/predefined-expr.cpp @@ -559,11 +559,11 @@ XXX::XXX() _dispatch_once(^{ notify_register_dispatch( ^(int token) { XXLog(__FUNCTION__); }); }); } -// CHECK: define internal void @___ZN3XXXC2Ev_block_invoke_ +// CHECK: define internal {{.*}}void @___ZN3XXXC2Ev_block_invoke_ XXX::~XXX() { _dispatch_once(^{ notify_register_dispatch( ^(int token) { XXLog(__FUNCTION__); }); }); } -// CHECK: define internal void @___ZN3XXXD2Ev_block_invoke_ +// CHECK: define internal {{.*}}void @___ZN3XXXD2Ev_block_invoke_ diff --git a/test/CodeGenCXX/redefine_extname.cpp b/test/CodeGenCXX/redefine_extname.cpp index 2b6b703a1b8f..f76fe6252fef 100644 --- a/test/CodeGenCXX/redefine_extname.cpp +++ b/test/CodeGenCXX/redefine_extname.cpp @@ -8,7 +8,7 @@ extern "C" { int statvfs64(struct statvfs64 *); } -void foo() { +void some_func() { struct statvfs64 st; statvfs64(&st); // Check that even if there is a structure with redefined name before the @@ -16,3 +16,15 @@ void foo() { // CHECK: call i32 @statvfs(%struct.statvfs64* %st) } +// This is a case when redefenition is deferred *and* we have a local of the +// same name. PR23923. +#pragma redefine_extname foo bar +int f() { + int foo = 0; + return foo; +} +extern "C" { + int foo() { return 1; } +// CHECK: define i32 @bar() +} + diff --git a/test/CodeGenCXX/template-dependent-bind-temporary.cpp b/test/CodeGenCXX/template-dependent-bind-temporary.cpp index 47d8279a4774..4c4b3ea9f776 100644 --- a/test/CodeGenCXX/template-dependent-bind-temporary.cpp +++ b/test/CodeGenCXX/template-dependent-bind-temporary.cpp @@ -18,7 +18,7 @@ void IntToString(T a) } int main() { -// CHECK-LABEL: define linkonce_odr void @_Z11IntToStringIcEvT_( +// CHECK-LABEL: define linkonce_odr {{.*}}void @_Z11IntToStringIcEvT_( IntToString('a'); } diff --git a/test/CodeGenCXX/thunks.cpp b/test/CodeGenCXX/thunks.cpp index 2287d65a286d..0e97255cc6fa 100644 --- a/test/CodeGenCXX/thunks.cpp +++ b/test/CodeGenCXX/thunks.cpp @@ -365,6 +365,7 @@ namespace Test15 { // This is from Test5: // CHECK-LABEL: define internal void @_ZThn8_N6Test4B12_GLOBAL__N_11C1fEv( +// CHECK-NOT: comdat // CHECK-LABEL: define linkonce_odr void @_ZTv0_n24_N5Test51B1fEv // This is from Test10: diff --git a/test/CodeGenCXX/trap-fnattr.cpp b/test/CodeGenCXX/trap-fnattr.cpp new file mode 100644 index 000000000000..b73ea432b787 --- /dev/null +++ b/test/CodeGenCXX/trap-fnattr.cpp @@ -0,0 +1,36 @@ +// RUN: %clang_cc1 -O0 -emit-llvm -ftrapv -ftrap-function=mytrap %s -o - | FileCheck %s -check-prefix=TRAPFUNC +// RUN: %clang_cc1 -O0 -emit-llvm -ftrapv %s -o - | FileCheck %s -check-prefix=NOOPTION + +// TRAPFUNC-LABEL: define void @{{_Z12test_builtinv|\"\\01\?test_builtin@@YAXXZ\"}} +// TRAPFUNC: call void @llvm.trap() [[ATTR0:#[0-9]+]] + +// NOOPTION-LABEL: define void @{{_Z12test_builtinv|\"\\01\?test_builtin@@YAXXZ\"}} +// NOOPTION: call void @llvm.trap(){{$}} + +void test_builtin(void) { + __builtin_trap(); +} + +// TRAPFUNC-LABEL: define {{.*}}i32 @{{_Z13test_noreturnv|\"\\01\?test_noreturn@@YAHXZ\"}} +// TRAPFUNC: call void @llvm.trap() [[ATTR0]] + +// NOOPTION-LABEL: define {{.*}}i32 @{{_Z13test_noreturnv|\"\\01\?test_noreturn@@YAHXZ\"}} +// NOOPTION: call void @llvm.trap(){{$}} + +int test_noreturn(void) { +} + +// TRAPFUNC-LABEL: define {{.*}}i32 @{{_Z17test_add_overflowii|\"\\01\?test_add_overflow@@YAHHH@Z\"}} +// TRAPFUNC: call void @llvm.trap() [[ATTR1:#[0-9]+]] + +// NOOPTION-LABEL: define {{.*}}i32 @{{_Z17test_add_overflowii|\"\\01\?test_add_overflow@@YAHHH@Z\"}} +// NOOPTION: call void @llvm.trap() [[ATTR2:#[0-9]+]] + +int test_add_overflow(int a, int b) { + return a + b; +} + +// TRAPFUNC: attributes [[ATTR0]] = { {{.*}}"trap-func-name"="mytrap" } +// TRAPFUNC: attributes [[ATTR1]] = { {{.*}}"trap-func-name"="mytrap" } + +// NOOPTION-NOT: attributes [[ATTR2]] = { {{.*}}"trap-func-name"="mytrap" } diff --git a/test/CodeGenCXX/typeid-should-throw.cpp b/test/CodeGenCXX/typeid-should-throw.cpp index 1d8fc85896af..428c737a3a08 100644 --- a/test/CodeGenCXX/typeid-should-throw.cpp +++ b/test/CodeGenCXX/typeid-should-throw.cpp @@ -10,73 +10,73 @@ struct A { struct B : A {}; void f1(A *x) { typeid(false, *x); } -// CHECK-LABEL: define void @_Z2f1P1A +// CHECK-LABEL: define {{.*}}void @_Z2f1P1A // CHECK: icmp eq {{.*}}, null // CHECK-NEXT: br i1 void f2(bool b, A *x, A *y) { typeid(b ? *x : *y); } -// CHECK-LABEL: define void @_Z2f2bP1AS0_ +// CHECK-LABEL: define {{.*}}void @_Z2f2bP1AS0_ // CHECK: icmp eq {{.*}}, null // CHECK-NEXT: br i1 void f3(bool b, A *x, A &y) { typeid(b ? *x : y); } -// CHECK-LABEL: define void @_Z2f3bP1ARS_ +// CHECK-LABEL: define {{.*}}void @_Z2f3bP1ARS_ // CHECK: icmp eq {{.*}}, null // CHECK-NEXT: br i1 void f4(bool b, A &x, A *y) { typeid(b ? x : *y); } -// CHECK-LABEL: define void @_Z2f4bR1APS_ +// CHECK-LABEL: define {{.*}}void @_Z2f4bR1APS_ // CHECK: icmp eq {{.*}}, null // CHECK-NEXT: br i1 void f5(volatile A *x) { typeid(*x); } -// CHECK-LABEL: define void @_Z2f5PV1A +// CHECK-LABEL: define {{.*}}void @_Z2f5PV1A // CHECK: icmp eq {{.*}}, null // CHECK-NEXT: br i1 void f6(A *x) { typeid((B &)*(B *)x); } -// CHECK-LABEL: define void @_Z2f6P1A +// CHECK-LABEL: define {{.*}}void @_Z2f6P1A // CHECK: icmp eq {{.*}}, null // CHECK-NEXT: br i1 void f7(A *x) { typeid((*x)); } -// CHECK-LABEL: define void @_Z2f7P1A +// CHECK-LABEL: define {{.*}}void @_Z2f7P1A // CHECK: icmp eq {{.*}}, null // CHECK-NEXT: br i1 void f8(A *x) { typeid(x[0]); } -// CHECK-LABEL: define void @_Z2f8P1A +// CHECK-LABEL: define {{.*}}void @_Z2f8P1A // CHECK: icmp eq {{.*}}, null // CHECK-NEXT: br i1 void f9(A *x) { typeid(0[x]); } -// CHECK-LABEL: define void @_Z2f9P1A +// CHECK-LABEL: define {{.*}}void @_Z2f9P1A // CHECK: icmp eq {{.*}}, null // CHECK-NEXT: br i1 void f10(A *x, A *y) { typeid(*y ?: *x); } -// CHECK-LABEL: define void @_Z3f10P1AS0_ +// CHECK-LABEL: define {{.*}}void @_Z3f10P1AS0_ // CHECK: icmp eq {{.*}}, null // CHECK-NEXT: br i1 void f11(A *x, A &y) { typeid(*x ?: y); } -// CHECK-LABEL: define void @_Z3f11P1ARS_ +// CHECK-LABEL: define {{.*}}void @_Z3f11P1ARS_ // CHECK: icmp eq {{.*}}, null // CHECK-NEXT: br i1 void f12(A &x, A *y) { typeid(x ?: *y); } -// CHECK-LABEL: define void @_Z3f12R1APS_ +// CHECK-LABEL: define {{.*}}void @_Z3f12R1APS_ // CHECK: icmp eq {{.*}}, null // CHECK-NEXT: br i1 void f13(A &x, A &y) { typeid(x ?: y); } -// CHECK-LABEL: define void @_Z3f13R1AS0_ +// CHECK-LABEL: define {{.*}}void @_Z3f13R1AS0_ // CHECK-NOT: icmp eq {{.*}}, null void f14(A *x) { typeid((const A &)(A)*x); } -// CHECK-LABEL: define void @_Z3f14P1A +// CHECK-LABEL: define {{.*}}void @_Z3f14P1A // CHECK-NOT: icmp eq {{.*}}, null void f15(A *x) { typeid((A &&)*(A *)nullptr); } -// CHECK-LABEL: define void @_Z3f15P1A +// CHECK-LABEL: define {{.*}}void @_Z3f15P1A // CHECK-NOT: icmp eq {{.*}}, null diff --git a/test/CodeGenCXX/vararg-non-pod.cpp b/test/CodeGenCXX/vararg-non-pod.cpp index 613b28c736f0..36891a4d28c8 100644 --- a/test/CodeGenCXX/vararg-non-pod.cpp +++ b/test/CodeGenCXX/vararg-non-pod.cpp @@ -8,7 +8,7 @@ struct X { void vararg(...); -// CHECK-LABEL: define void @_Z4test1X +// CHECK-LABEL: define {{.*}}void @_Z4test1X void test(X x) { // CHECK: call void @llvm.trap() vararg(x); diff --git a/test/CodeGenCXX/virtual-destructor-synthesis.cpp b/test/CodeGenCXX/virtual-destructor-synthesis.cpp index 80d1b1e4ec75..59272358d145 100644 --- a/test/CodeGenCXX/virtual-destructor-synthesis.cpp +++ b/test/CodeGenCXX/virtual-destructor-synthesis.cpp @@ -12,5 +12,5 @@ pile_box::pile_box(box *pp) { } -// CHECK: call void @_ZdlPv +// CHECK: call {{.*}}void @_ZdlPv diff --git a/test/CodeGenCXX/vla-lambda-capturing.cpp b/test/CodeGenCXX/vla-lambda-capturing.cpp index f2332bf0dc99..44b6a2506d14 100644 --- a/test/CodeGenCXX/vla-lambda-capturing.cpp +++ b/test/CodeGenCXX/vla-lambda-capturing.cpp @@ -12,7 +12,7 @@ typedef __INTPTR_TYPE__ intptr_t; // CHECK-DAG: [[CAP_TYPE3:%.+]] = type { [[INTPTR_T]]*, [[INTPTR_T]], [[INTPTR_T]], [[INTPTR_T]]*, [[INTPTR_T]]* } // CHECK-DAG: [[CAP_TYPE4:%.+]] = type { [[INTPTR_T]]*, [[INTPTR_T]], [[INTPTR_T]]*, [[INTPTR_T]], [[INTPTR_T]]* } -// CHECK: define void [[G:@.+]]( +// CHECK: define {{.*}}void [[G:@.+]]( // CHECK: [[N_ADDR:%.+]] = alloca [[INTPTR_T]] // CHECK: store [[INTPTR_T]] %{{.+}}, [[INTPTR_T]]* [[N_ADDR]] // CHECK: [[N_VAL:%.+]] = load [[INTPTR_T]], [[INTPTR_T]]* [[N_ADDR]] @@ -22,7 +22,7 @@ typedef __INTPTR_TYPE__ intptr_t; // CHECK: store [[INTPTR_T]]* %{{.+}}, [[INTPTR_T]]** [[CAP_BUFFER_ADDR]] // CHECK: [[CAP_N_REF:%.+]] = getelementptr inbounds [[CAP_TYPE1]], [[CAP_TYPE1]]* [[CAP_ARG:%.+]], i{{.+}} 0, i{{.+}} 2 // CHECK: store [[INTPTR_T]]* [[N_ADDR]], [[INTPTR_T]]** [[CAP_N_REF]] -// CHECK: call{{( x86_thiscallcc)?}} void [[G_LAMBDA:@.+]]([[CAP_TYPE1]]* [[CAP_ARG]]) +// CHECK: call{{.*}} void [[G_LAMBDA:@.+]]([[CAP_TYPE1]]* [[CAP_ARG]]) // CHECK: ret void void g(intptr_t n) { intptr_t buffer[n]; @@ -70,17 +70,17 @@ void b(intptr_t n, T arg) { // CHECK-LABEL: @main int main() { - // CHECK: call void [[G]]([[INTPTR_T]] [[INTPTR_T_ATTR:(signext )?]]1) + // CHECK: call {{.*}}void [[G]]([[INTPTR_T]] [[INTPTR_T_ATTR:(signext )?]]1) g((intptr_t)1); - // CHECK: call void [[F_INT:@.+]]([[INTPTR_T]] [[INTPTR_T_ATTR]]1, [[INTPTR_T]] [[INTPTR_T_ATTR]]2) + // CHECK: call {{.*}}void [[F_INT:@.+]]([[INTPTR_T]] [[INTPTR_T_ATTR]]1, [[INTPTR_T]] [[INTPTR_T_ATTR]]2) f((intptr_t)1, (intptr_t)2); - // CHECK: call void [[B_INT:@.+]]([[INTPTR_T]] [[INTPTR_T_ATTR]]12, [[INTPTR_T]] [[INTPTR_T_ATTR]]13) + // CHECK: call {{.*}}void [[B_INT:@.+]]([[INTPTR_T]] [[INTPTR_T_ATTR]]12, [[INTPTR_T]] [[INTPTR_T_ATTR]]13) b((intptr_t)12, (intptr_t)13); // CHECK: ret i32 0 return 0; } -// CHECK: define linkonce_odr void [[F_INT]]([[INTPTR_T]] +// CHECK: define linkonce_odr {{.*}}void [[F_INT]]([[INTPTR_T]] // CHECK: [[SIZE:%.+]] = add // CHECK: call i{{.+}}* @llvm.stacksave() // CHECK: [[BUFFER_ADDR:%.+]] = alloca [[INTPTR_T]], [[INTPTR_T]] [[SIZE]] @@ -88,11 +88,11 @@ int main() { // CHECK: store [[INTPTR_T]] [[SIZE]], [[INTPTR_T]]* [[CAP_SIZE_REF]] // CHECK: [[CAP_BUFFER_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE2]], [[CAP_TYPE2]]* [[CAP_ARG]], i{{.+}} 0, i{{.+}} 1 // CHECK: store [[INTPTR_T]]* [[BUFFER_ADDR]], [[INTPTR_T]]** [[CAP_BUFFER_ADDR_REF]] -// CHECK: call{{( x86_thiscallcc)?}} void [[F_INT_LAMBDA:@.+]]([[CAP_TYPE2]]* [[CAP_ARG]]) +// CHECK: call{{.*}} void [[F_INT_LAMBDA:@.+]]([[CAP_TYPE2]]* [[CAP_ARG]]) // CHECK: call void @llvm.stackrestore( // CHECK: ret void // CHECK: void [[B_INT]]([[INTPTR_T]] -// CHECK: [[SIZE1:%.+]] = call [[INTPTR_T]] +// CHECK: [[SIZE1:%.+]] = call {{.*}}[[INTPTR_T]] // CHECK: call i{{.+}}* @llvm.stacksave() // CHECK: [[BUFFER2_ADDR:%.+]] = alloca [[INTPTR_T]], [[INTPTR_T]] [[SIZE1]] // CHECK: [[SIZE2:%.+]] = add @@ -107,11 +107,11 @@ int main() { // CHECK: store [[INTPTR_T]]* [[BUFFER1_ADDR]], [[INTPTR_T]]** [[CAP_BUFFER1_ADDR_REF]] // CHECK: [[CAP_BUFFER2_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]], [[CAP_TYPE3]]* [[CAP_ARG]], i{{.+}} 0, i{{.+}} 4 // CHECK: store [[INTPTR_T]]* [[BUFFER2_ADDR]], [[INTPTR_T]]** [[CAP_BUFFER2_ADDR_REF]] -// CHECK: call{{( x86_thiscallcc)?}} void [[B_INT_LAMBDA:@.+]]([[CAP_TYPE3]]* [[CAP_ARG]]) +// CHECK: call{{.*}} void [[B_INT_LAMBDA:@.+]]([[CAP_TYPE3]]* [[CAP_ARG]]) // CHECK: call void @llvm.stackrestore( // CHECK: ret void -// CHECK: define linkonce_odr{{( x86_thiscallcc)?}} void [[F_INT_LAMBDA]]([[CAP_TYPE2]]* +// CHECK: define linkonce_odr{{.*}} void [[F_INT_LAMBDA]]([[CAP_TYPE2]]* // CHECK: [[THIS:%.+]] = load [[CAP_TYPE2]]*, [[CAP_TYPE2]]** // CHECK: [[SIZE_REF:%.+]] = getelementptr inbounds [[CAP_TYPE2]], [[CAP_TYPE2]]* [[THIS]], i{{.+}} 0, i{{.+}} 0 // CHECK: [[SIZE:%.+]] = load [[INTPTR_T]], [[INTPTR_T]]* [[SIZE_REF]] @@ -120,7 +120,7 @@ int main() { // CHECK: call void @llvm.stackrestore( // CHECK: ret void -// CHECK: define linkonce_odr{{( x86_thiscallcc)?}} void [[B_INT_LAMBDA]]([[CAP_TYPE3]]* +// CHECK: define linkonce_odr{{.*}} void [[B_INT_LAMBDA]]([[CAP_TYPE3]]* // CHECK: [[SIZE2_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]], [[CAP_TYPE3]]* [[THIS:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 1 // CHECK: [[SIZE2:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[SIZE2_REF]] // CHECK: [[SIZE1_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]], [[CAP_TYPE3]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 2 @@ -152,10 +152,10 @@ int main() { // CHECK: [[BUFFER1_ADDR_REF_ORIG:%.+]] = getelementptr inbounds [[CAP_TYPE3]], [[CAP_TYPE3]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 3 // CHECK: [[BUFFER1_ADDR_ORIG:%.+]] = load [[INTPTR_T]]*, [[INTPTR_T]]** [[BUFFER1_ADDR_REF_ORIG]] // CHECK: store [[INTPTR_T]]* [[BUFFER1_ADDR_ORIG]], [[INTPTR_T]]** [[BUFFER1_ADDR_REF]] -// CHECK: call{{( x86_thiscallcc)?}} void [[B_INT_LAMBDA_LAMBDA:@.+]]([[CAP_TYPE4]]* [[CAP]]) +// CHECK: call{{.*}} void [[B_INT_LAMBDA_LAMBDA:@.+]]([[CAP_TYPE4]]* [[CAP]]) // CHECK: ret void -// CHECK: define linkonce_odr{{( x86_thiscallcc)?}} void [[B_INT_LAMBDA_LAMBDA]]([[CAP_TYPE4]]* +// CHECK: define linkonce_odr{{.*}} void [[B_INT_LAMBDA_LAMBDA]]([[CAP_TYPE4]]* // CHECK: [[SIZE1_REF:%.+]] = getelementptr inbounds [[CAP_TYPE4]], [[CAP_TYPE4]]* [[THIS:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 1 // CHECK: [[SIZE1:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[SIZE1_REF]] // CHECK: [[SIZE2_REF:%.+]] = getelementptr inbounds [[CAP_TYPE4]], [[CAP_TYPE4]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 3 diff --git a/test/CodeGenCXX/volatile-1.cpp b/test/CodeGenCXX/volatile-1.cpp index 65eb9f69ebd9..f32e4288b897 100644 --- a/test/CodeGenCXX/volatile-1.cpp +++ b/test/CodeGenCXX/volatile-1.cpp @@ -17,7 +17,7 @@ volatile struct S { int printf(const char *, ...); -// CHECK: define void @{{.*}}test +// CHECK: define {{.*}}void @{{.*}}test void test() { asm("nop"); // CHECK: call void asm diff --git a/test/CodeGenCXX/x86_64-arguments-nacl-x32.cpp b/test/CodeGenCXX/x86_64-arguments-nacl-x32.cpp index bb9bd888b20f..3392b32bd2b6 100644 --- a/test/CodeGenCXX/x86_64-arguments-nacl-x32.cpp +++ b/test/CodeGenCXX/x86_64-arguments-nacl-x32.cpp @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 -triple x86_64-unknown-nacl -emit-llvm -o - %s | FileCheck %s -// RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnux32 -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-nacl -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -std=c++11 -triple=x86_64-unknown-linux-gnux32 -emit-llvm -o - %s | FileCheck %s struct test_struct {}; typedef int test_struct::* test_struct_mdp; @@ -42,3 +42,16 @@ struct struct_with_mfp_too_much { void f_struct_with_mfp_too_much(struct_with_mfp_too_much a, int x) { (void)a; } + +/* Struct containing an empty struct */ +typedef struct { int* a; test_struct x; double *b; } struct_with_empty; + +// CHECK-LABEL: define void @{{.*}}f_pass_struct_with_empty{{.*}}(i64 %x{{.*}}, double* %x +void f_pass_struct_with_empty(struct_with_empty x) { + (void) x; +} + +// CHECK-LABEL: define { i64, double* } @{{.*}}f_return_struct_with_empty +struct_with_empty f_return_struct_with_empty() { + return {0, {}, 0}; +} diff --git a/test/CodeGenObjC/arc-block-copy-escape.m b/test/CodeGenObjC/arc-block-copy-escape.m index afe7c0bdc18b..16a75a0d3118 100644 --- a/test/CodeGenObjC/arc-block-copy-escape.m +++ b/test/CodeGenObjC/arc-block-copy-escape.m @@ -8,15 +8,15 @@ void use_int(int); void test0(int i) { block_t block = ^{ use_int(i); }; - // CHECK-LABEL: define void @test0( - // CHECK: call i8* @objc_retainBlock(i8* {{%.*}}) [[NUW:#[0-9]+]], !clang.arc.copy_on_escape + // CHECK-LABEL: define {{.*}}void @test0( + // CHECK: call {{.*}}i8* @objc_retainBlock(i8* {{%.*}}) [[NUW:#[0-9]+]], !clang.arc.copy_on_escape // CHECK: ret void } void test1(int i) { id block = ^{ use_int(i); }; - // CHECK-LABEL: define void @test1( - // CHECK: call i8* @objc_retainBlock(i8* {{%.*}}) [[NUW]] + // CHECK-LABEL: define {{.*}}void @test1( + // CHECK: call {{.*}}i8* @objc_retainBlock(i8* {{%.*}}) [[NUW]] // CHECK-NOT: !clang.arc.copy_on_escape // CHECK: ret void } diff --git a/test/CodeGenObjC/objc2-legacy-dispatch.m b/test/CodeGenObjC/objc2-legacy-dispatch.m index aa944f89519f..5584f49c6caa 100644 --- a/test/CodeGenObjC/objc2-legacy-dispatch.m +++ b/test/CodeGenObjC/objc2-legacy-dispatch.m @@ -7,9 +7,9 @@ // // RUN: %clang_cc1 -fobjc-dispatch-method=legacy -emit-llvm -o - %s | FileCheck -check-prefix=CHECK_OLD_DISPATCH %s // -// CHECK_OLD_DISPATCH-LABEL: define void @f0 +// CHECK_OLD_DISPATCH-LABEL: define {{.*}}void @f0 // CHECK_OLD_DISPATCH: load {{.*}}OBJC_SELECTOR_REFERENCES -// CHECK_OLD_DISPATCH-LABEL: define void @f1 +// CHECK_OLD_DISPATCH-LABEL: define {{.*}}void @f1 // CHECK_OLD_DISPATCH: load {{.*}}OBJC_SELECTOR_REFERENCES @interface A diff --git a/test/CodeGenObjC/related-result-type.m b/test/CodeGenObjC/related-result-type.m index cd7847421812..cacf2c031498 100644 --- a/test/CodeGenObjC/related-result-type.m +++ b/test/CodeGenObjC/related-result-type.m @@ -9,7 +9,7 @@ @interface NSString : NSObject @end -// CHECK-LABEL: define void @test1() +// CHECK-LABEL: define {{.*}}void @test1() void test1() { // CHECK: {{call.*@objc_msgSend}} // CHECK: {{call.*@objc_msgSend}} @@ -18,7 +18,7 @@ void test1() { NSString *str1 = [[[NSString alloc] init] retain]; } -// CHECK-LABEL: define void @test2() +// CHECK-LABEL: define {{.*}}void @test2() void test2() { // CHECK: {{call.*@objc_msgSend}} // CHECK: {{call.*@objc_msgSend}} @@ -32,7 +32,7 @@ void test2() { @end @implementation Test2 -// CHECK: define internal i8* @"\01-[Test2 init]" +// CHECK: define internal {{.*}}i8* @"\01-[Test2 init]" - (id)init { // CHECK: {{call.*@objc_msgSendSuper}} // CHECK-NEXT: bitcast i8* @@ -45,7 +45,7 @@ void test2() { @end @implementation Test3 -// CHECK: define internal i8* @"\01-[Test3 init]" +// CHECK: define internal {{.*}}i8* @"\01-[Test3 init]" - (id)init { // CHECK: {{call.*@objc_msgSendSuper}} // CHECK-NEXT: bitcast i8* diff --git a/test/CodeGenObjCXX/arc-mangle.mm b/test/CodeGenObjCXX/arc-mangle.mm index b921a7f935bc..a168d41b336c 100644 --- a/test/CodeGenObjCXX/arc-mangle.mm +++ b/test/CodeGenObjCXX/arc-mangle.mm @@ -1,25 +1,25 @@ // RUN: %clang_cc1 -fobjc-arc -fobjc-runtime-has-weak -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s -// CHECK-LABEL: define void @_Z1fPU8__strongP11objc_object(i8**) +// CHECK-LABEL: define {{.*}}void @_Z1fPU8__strongP11objc_object(i8**) void f(__strong id *) {} -// CHECK-LABEL: define void @_Z1fPU6__weakP11objc_object(i8**) +// CHECK-LABEL: define {{.*}}void @_Z1fPU6__weakP11objc_object(i8**) void f(__weak id *) {} -// CHECK-LABEL: define void @_Z1fPU15__autoreleasingP11objc_object(i8**) +// CHECK-LABEL: define {{.*}}void @_Z1fPU15__autoreleasingP11objc_object(i8**) void f(__autoreleasing id *) {} -// CHECK-LABEL: define void @_Z1fPP11objc_object(i8**) +// CHECK-LABEL: define {{.*}}void @_Z1fPP11objc_object(i8**) void f(__unsafe_unretained id *) {} -// CHECK-LABEL: define void @_Z1fPKU8__strongP11objc_object(i8**) +// CHECK-LABEL: define {{.*}}void @_Z1fPKU8__strongP11objc_object(i8**) void f(const __strong id *) {} -// CHECK-LABEL: define void @_Z1fPKU6__weakP11objc_object(i8**) +// CHECK-LABEL: define {{.*}}void @_Z1fPKU6__weakP11objc_object(i8**) void f(const __weak id *) {} -// CHECK-LABEL: define void @_Z1fPKU15__autoreleasingP11objc_object(i8**) +// CHECK-LABEL: define {{.*}}void @_Z1fPKU15__autoreleasingP11objc_object(i8**) void f(const __autoreleasing id *) {} -// CHECK-LABEL: define void @_Z1fPKP11objc_object(i8**) +// CHECK-LABEL: define {{.*}}void @_Z1fPKP11objc_object(i8**) void f(const __unsafe_unretained id *) {} template<unsigned N> struct unsigned_c { }; -// CHECK-LABEL: define weak_odr void @_Z1gIKvEvP10unsigned_cIXplszv1U8__bridgecvPT_v1U8__bridgecvP11objc_objectcvS3_Li0ELi1EEE +// CHECK-LABEL: define weak_odr {{.*}}void @_Z1gIKvEvP10unsigned_cIXplszv1U8__bridgecvPT_v1U8__bridgecvP11objc_objectcvS3_Li0ELi1EEE template<typename T>void g(unsigned_c<sizeof((__bridge T*)(__bridge id)(T*)0) + 1>*) {} template void g<const void>(unsigned_c<sizeof(id) + 1> *); diff --git a/test/CodeGenObjCXX/debug-info-line.mm b/test/CodeGenObjCXX/debug-info-line.mm index a7d6a1559987..6d7321c381f5 100644 --- a/test/CodeGenObjCXX/debug-info-line.mm +++ b/test/CodeGenObjCXX/debug-info-line.mm @@ -15,7 +15,7 @@ void f1() { }(); } -// CHECK-LABEL: define internal i8* @"\01-[TNSObject init]" +// CHECK-LABEL: define internal {{.*}}i8* @"\01-[TNSObject init]" @implementation TNSObject - (id)init { diff --git a/test/CodeGenOpenCL/event_t.cl b/test/CodeGenOpenCL/event_t.cl index ddf12a9d8b9a..a84d8bb610c0 100644 --- a/test/CodeGenOpenCL/event_t.cl +++ b/test/CodeGenOpenCL/event_t.cl @@ -6,7 +6,7 @@ void kernel ker() { event_t e; // CHECK: alloca %opencl.event_t*, foo(e); -// CHECK: call void @foo(%opencl.event_t* % +// CHECK: call {{.*}}void @foo(%opencl.event_t* % foo(0); -// CHECK: call void @foo(%opencl.event_t* null) +// CHECK: call {{.*}}void @foo(%opencl.event_t* null) } diff --git a/test/CodeGenOpenCL/local.cl b/test/CodeGenOpenCL/local.cl index f1031cdfd84e..da371f8e4648 100644 --- a/test/CodeGenOpenCL/local.cl +++ b/test/CodeGenOpenCL/local.cl @@ -8,7 +8,7 @@ __kernel void foo(void) { func(&i); } -// CHECK-LABEL: define void @_Z3barPU7CLlocali +// CHECK-LABEL: define {{.*}}void @_Z3barPU7CLlocali __kernel void __attribute__((__overloadable__)) bar(local int *x) { *x = 5; } diff --git a/test/CodeGenOpenCL/opencl_types.cl b/test/CodeGenOpenCL/opencl_types.cl index ac4ed1c3b81e..5f4ebb8a283e 100644 --- a/test/CodeGenOpenCL/opencl_types.cl +++ b/test/CodeGenOpenCL/opencl_types.cl @@ -22,7 +22,7 @@ void fnc3(image3d_t img) {} // CHECK: @fnc3(%opencl.image3d_t* void fnc4smp(sampler_t s) {} -// CHECK-LABEL: define void @fnc4smp(i32 +// CHECK-LABEL: define {{.*}}void @fnc4smp(i32 kernel void foo(image1d_t img) { sampler_t smp = 5; @@ -31,9 +31,9 @@ kernel void foo(image1d_t img) { // CHECK: alloca %opencl.event_t* // CHECK: store i32 5, fnc4smp(smp); -// CHECK: call void @fnc4smp(i32 +// CHECK: call {{.*}}void @fnc4smp(i32 fnc4smp(glb_smp); -// CHECK: call void @fnc4smp(i32 +// CHECK: call {{.*}}void @fnc4smp(i32 } void __attribute__((overloadable)) bad1(image1d_t *b, image2d_t *c, image2d_t *d) {} diff --git a/test/CoverageMapping/implicit-def-in-macro.m b/test/CoverageMapping/implicit-def-in-macro.m new file mode 100644 index 000000000000..7e563acc54d1 --- /dev/null +++ b/test/CoverageMapping/implicit-def-in-macro.m @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -triple x86_64-apple-darwin -fobjc-runtime=macosx-10.10.0 -fblocks -fobjc-arc %s | FileCheck %s + +@interface Foo +@end +#define Bar Foo + +@implementation Blah +// CHECK-LABEL: +[Blah load]: ++ load { // CHECK: File 0, [[@LINE]]:8 -> [[END:[0-9:]+]] = #0 + return 0; + // CHECK: Expansion,File 0, [[@LINE+1]]:3 -> [[@LINE+1]]:6 = 0 + Bar *attribute; // CHECK: File 0, [[@LINE]]:6 -> [[END]] = 0 +} +@end + +int main() {} diff --git a/test/CoverageMapping/ir.c b/test/CoverageMapping/ir.c index 4b1238c1380a..5ac3495c41f8 100644 --- a/test/CoverageMapping/ir.c +++ b/test/CoverageMapping/ir.c @@ -9,4 +9,4 @@ int main(void) { return 0; } -// CHECK: @__llvm_coverage_mapping = internal constant { i32, i32, i32, i32, [2 x { i8*, i32, i32, i64 }], [{{[0-9]+}} x i8] } { i32 2, i32 {{[0-9]+}}, i32 {{[0-9]+}}, i32 0, [2 x { i8*, i32, i32, i64 }] [{ i8*, i32, i32, i64 } { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__llvm_profile_name_foo, i32 0, i32 0), i32 3, i32 9, i64 {{[0-9]+}} }, { i8*, i32, i32, i64 } { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @__llvm_profile_name_main, i32 0, i32 0), i32 4, i32 9, i64 {{[0-9]+}} }] +// CHECK: @__llvm_coverage_mapping = internal constant { i32, i32, i32, i32, [2 x <{ i8*, i32, i32, i64 }>], [{{[0-9]+}} x i8] } { i32 2, i32 {{[0-9]+}}, i32 {{[0-9]+}}, i32 0, [2 x <{ i8*, i32, i32, i64 }>] [<{ i8*, i32, i32, i64 }> <{ i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__llvm_profile_name_foo, i32 0, i32 0), i32 3, i32 9, i64 {{[0-9]+}} }>, <{ i8*, i32, i32, i64 }> <{ i8* getelementptr inbounds ([4 x i8], [4 x i8]* @__llvm_profile_name_main, i32 0, i32 0), i32 4, i32 9, i64 {{[0-9]+}} }>] diff --git a/test/Driver/Inputs/debian_multiarch_tree/lib/powerpc64le-linux-gnu/.keep b/test/Driver/Inputs/debian_multiarch_tree/lib/powerpc64le-linux-gnu/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/debian_multiarch_tree/lib/powerpc64le-linux-gnu/.keep diff --git a/test/Driver/Inputs/debian_multiarch_tree/usr/lib/gcc/powerpc64le-linux-gnu/4.5/crtbegin.o b/test/Driver/Inputs/debian_multiarch_tree/usr/lib/gcc/powerpc64le-linux-gnu/4.5/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/debian_multiarch_tree/usr/lib/gcc/powerpc64le-linux-gnu/4.5/crtbegin.o diff --git a/test/Driver/Inputs/debian_multiarch_tree/usr/lib/powerpc64le-linux-gnu/.keep b/test/Driver/Inputs/debian_multiarch_tree/usr/lib/powerpc64le-linux-gnu/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/debian_multiarch_tree/usr/lib/powerpc64le-linux-gnu/.keep diff --git a/test/Driver/arm-mfpu.c b/test/Driver/arm-mfpu.c index 8439cddf9d7f..93fb0a8eb436 100644 --- a/test/Driver/arm-mfpu.c +++ b/test/Driver/arm-mfpu.c @@ -34,6 +34,17 @@ // CHECK-VFP3: "-target-feature" "-fp-armv8" // CHECK-VFP3: "-target-feature" "-neon" +// RUN: %clang -target arm-linux-eabi -mfpu=vfpv3-fp16 %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-VFP3-FP16 %s +// CHECK-VFP3-FP16: "-target-feature" "-fp-only-sp" +// CHECK-VFP3-FP16: "-target-feature" "-d16" +// CHECK-VFP3-FP16: "-target-feature" "+vfp3" +// CHECK-VFP3-FP16: "-target-feature" "+fp16" +// CHECK-VFP3-FP16: "-target-feature" "-vfp4" +// CHECK-VFP3-FP16: "-target-feature" "-fp-armv8" +// CHECK-VFP3-FP16: "-target-feature" "-neon" +// CHECK-VFP3-FP16: "-target-feature" "-crypto" + // RUN: %clang -target arm-linux-eabi -mfpu=vfp3-d16 %s -### -o %t.o 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-VFP3-D16 %s // RUN: %clang -target arm-linux-eabi -mfpu=vfpv3-d16 %s -### -o %t.o 2>&1 \ @@ -45,6 +56,39 @@ // CHECK-VFP3-D16: "-target-feature" "-fp-armv8" // CHECK-VFP3-D16: "-target-feature" "-neon" +// RUN: %clang -target arm-linux-eabi -mfpu=vfpv3-d16-fp16 %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-VFP3-D16-FP16 %s +// CHECK-VFP3-D16-FP16: "-target-feature" "-fp-only-sp" +// CHECK-VFP3-D16-FP16: "-target-feature" "+d16" +// CHECK-VFP3-D16-FP16: "-target-feature" "+vfp3" +// CHECK-VFP3-D16-FP16: "-target-feature" "+fp16" +// CHECK-VFP3-D16-FP16: "-target-feature" "-vfp4" +// CHECK-VFP3-D16-FP16: "-target-feature" "-fp-armv8" +// CHECK-VFP3-D16-FP16: "-target-feature" "-neon" +// CHECK-VFP3-D16-FP16: "-target-feature" "-crypto" + +// RUN: %clang -target arm-linux-eabi -mfpu=vfpv3xd %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-VFP3XD %s +// CHECK-VFP3XD: "-target-feature" "+fp-only-sp" +// CHECK-VFP3XD: "-target-feature" "+d16" +// CHECK-VFP3XD: "-target-feature" "+vfp3" +// CHECK-VFP3XD: "-target-feature" "-fp16" +// CHECK-VFP3XD: "-target-feature" "-vfp4" +// CHECK-VFP3XD: "-target-feature" "-fp-armv8" +// CHECK-VFP3XD: "-target-feature" "-neon" +// CHECK-VFP3XD: "-target-feature" "-crypto" + +// RUN: %clang -target arm-linux-eabi -mfpu=vfpv3xd-fp16 %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-VFP3XD-FP16 %s +// CHECK-VFP3XD-FP16: "-target-feature" "+fp-only-sp" +// CHECK-VFP3XD-FP16: "-target-feature" "+d16" +// CHECK-VFP3XD-FP16: "-target-feature" "+vfp3" +// CHECK-VFP3XD-FP16: "-target-feature" "+fp16" +// CHECK-VFP3XD-FP16: "-target-feature" "-vfp4" +// CHECK-VFP3XD-FP16: "-target-feature" "-fp-armv8" +// CHECK-VFP3XD-FP16: "-target-feature" "-neon" +// CHECK-VFP3XD-FP16: "-target-feature" "-crypto" + // RUN: %clang -target arm-linux-eabi -mfpu=vfp4 %s -### -o %t.o 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-VFP4 %s // RUN: %clang -target arm-linux-eabi -mfpu=vfpv4 %s -### -o %t.o 2>&1 \ @@ -97,6 +141,17 @@ // RUN: | FileCheck --check-prefix=CHECK-NEON %s // CHECK-NEON: "-target-feature" "+neon" +// RUN: %clang -target arm-linux-eabi -mfpu=neon-fp16 %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-NEON-FP16 %s +// CHECK-NEON-FP16: "-target-feature" "-fp-only-sp" +// CHECK-NEON-FP16: "-target-feature" "-d16" +// CHECK-NEON-FP16: "-target-feature" "+vfp3" +// CHECK-NEON-FP16: "-target-feature" "+fp16" +// CHECK-NEON-FP16: "-target-feature" "-vfp4" +// CHECK-NEON-FP16: "-target-feature" "-fp-armv8" +// CHECK-NEON-FP16: "-target-feature" "+neon" +// CHECK-NEON-FP16: "-target-feature" "-crypto" + // RUN: %clang -target arm-linux-eabi -mfpu=neon-vfpv3 %s -### -o %t.o 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-NEON-VFPV3 %s // CHECK-NEON-VFPV3: "-target-feature" "+neon" diff --git a/test/Driver/bindings.c b/test/Driver/bindings.c index dd8ad14f6725..880667b73934 100644 --- a/test/Driver/bindings.c +++ b/test/Driver/bindings.c @@ -1,8 +1,8 @@ // Basic binding. // RUN: %clang -target i386-unknown-unknown -ccc-print-bindings -no-integrated-as %s 2>&1 | FileCheck %s --check-prefix=CHECK01 // CHECK01: "clang", inputs: ["{{.*}}bindings.c"], output: "{{.*}}.s" -// CHECK01: "GNU::Assemble", inputs: ["{{.*}}.s"], output: "{{.*}}.o" -// CHECK01: "gcc::Link", inputs: ["{{.*}}.o"], output: "a.out" +// CHECK01: "GNU::Assembler", inputs: ["{{.*}}.s"], output: "{{.*}}.o" +// CHECK01: "gcc::Linker", inputs: ["{{.*}}.o"], output: "a.out" // Clang control options @@ -21,5 +21,5 @@ // Darwin bindings // RUN: %clang -target i386-apple-darwin9 -no-integrated-as -ccc-print-bindings %s 2>&1 | FileCheck %s --check-prefix=CHECK14 // CHECK14: "clang", inputs: ["{{.*}}bindings.c"], output: "{{.*}}.s" -// CHECK14: "darwin::Assemble", inputs: ["{{.*}}.s"], output: "{{.*}}.o" -// CHECK14: "darwin::Link", inputs: ["{{.*}}.o"], output: "a.out" +// CHECK14: "darwin::Assembler", inputs: ["{{.*}}.s"], output: "{{.*}}.o" +// CHECK14: "darwin::Linker", inputs: ["{{.*}}.o"], output: "a.out" diff --git a/test/Driver/cl-link.c b/test/Driver/cl-link.c index 5bd200117967..8572b77a740f 100644 --- a/test/Driver/cl-link.c +++ b/test/Driver/cl-link.c @@ -11,7 +11,7 @@ // LINK: "bar" // LINK: "baz" -// RUN: %clang_cl /Tc%s -### -fsanitize=address 2>&1 | FileCheck --check-prefix=ASAN %s +// RUN: %clang_cl -m32 -arch:IA32 --target=i386-pc-win32 /Tc%s -### -fsanitize=address 2>&1 | FileCheck --check-prefix=ASAN %s // ASAN: link.exe // ASAN: "-debug" // ASAN: "-incremental:no" @@ -19,7 +19,7 @@ // ASAN: "{{.*}}clang_rt.asan_cxx-i386.lib" // ASAN: "{{.*}}cl-link{{.*}}.obj" -// RUN: %clang_cl /MD /Tc%s -### -fsanitize=address 2>&1 | FileCheck --check-prefix=ASAN-MD %s +// RUN: %clang_cl -m32 -arch:IA32 --target=i386-pc-win32 /MD /Tc%s -### -fsanitize=address 2>&1 | FileCheck --check-prefix=ASAN-MD %s // ASAN-MD: link.exe // ASAN-MD: "-debug" // ASAN-MD: "-incremental:no" @@ -33,8 +33,8 @@ // DLL: link.exe // "-dll" -// RUN: %clang_cl /LD /Tc%s -### -fsanitize=address 2>&1 | FileCheck --check-prefix=ASAN-DLL %s -// RUN: %clang_cl /LDd /Tc%s -### -fsanitize=address 2>&1 | FileCheck --check-prefix=ASAN-DLL %s +// RUN: %clang_cl -m32 -arch:IA32 --target=i386-pc-win32 /LD /Tc%s -### -fsanitize=address 2>&1 | FileCheck --check-prefix=ASAN-DLL %s +// RUN: %clang_cl -m32 -arch:IA32 --target=i386-pc-win32 /LDd /Tc%s -### -fsanitize=address 2>&1 | FileCheck --check-prefix=ASAN-DLL %s // ASAN-DLL: link.exe // ASAN-DLL: "-dll" // ASAN-DLL: "-debug" diff --git a/test/Driver/cl-x86-flags.c b/test/Driver/cl-x86-flags.c index 5aae4c41d019..d4f7fb585975 100644 --- a/test/Driver/cl-x86-flags.c +++ b/test/Driver/cl-x86-flags.c @@ -8,10 +8,10 @@ // RUN: --target=i386-pc-win32 -### -- 2>&1 %s | FileCheck -check-prefix=MFLAGS %s // MFLAGS-NOT: argument unused during compilation -// -arch:IA32 is no-op. // RUN: %clang_cl -m32 -arch:IA32 --target=i386 -### -- 2>&1 %s | FileCheck -check-prefix=IA32 %s -// IA32-NOT: argument unused during compilation +// IA32: "-target-cpu" "i386" // IA32-NOT: -target-feature +// IA32-NOT: argument unused during compilation // RUN: %clang_cl -m32 -arch:ia32 --target=i386 -### -- 2>&1 %s | FileCheck -check-prefix=ia32 %s // ia32: argument unused during compilation @@ -22,6 +22,7 @@ // IA3264-NOT: -target-feature // RUN: %clang_cl -m32 -arch:SSE --target=i386 -### -- 2>&1 %s | FileCheck -check-prefix=SSE %s +// SSE: "-target-cpu" "pentium3" // SSE: -target-feature // SSE: +sse // SSE-NOT: argument unused during compilation @@ -31,6 +32,7 @@ // sse-NOT: -target-feature // RUN: %clang_cl -m32 -arch:SSE2 --target=i386 -### -- 2>&1 %s | FileCheck -check-prefix=SSE2 %s +// SSE2: "-target-cpu" "pentium4" // SSE2: -target-feature // SSE2: +sse2 // SSE2-NOT: argument unused during compilation @@ -42,12 +44,14 @@ // RUN: %clang_cl -m64 -arch:SSE --target=x86_64 -### -- 2>&1 %s | FileCheck -check-prefix=SSE64 %s // SSE64: argument unused during compilation // SSE64-NOT: -target-feature +// SSE64-NOT: pentium3 // RUN: %clang_cl -m64 -arch:SSE2 --target=x86_64 -### -- 2>&1 %s | FileCheck -check-prefix=SSE264 %s // SSE264: argument unused during compilation // SSE264-NOT: -target-feature // RUN: %clang_cl -m32 -arch:AVX --target=i386 -### -- 2>&1 %s | FileCheck -check-prefix=AVX %s +// AVX: "-target-cpu" "sandybridge" // AVX: -target-feature // AVX: +avx @@ -56,6 +60,7 @@ // avx-NOT: -target-feature // RUN: %clang_cl -m32 -arch:AVX2 --target=i386 -### -- 2>&1 %s | FileCheck -check-prefix=AVX2 %s +// AVX2: "-target-cpu" "haswell" // AVX2: -target-feature // AVX2: +avx2 @@ -64,6 +69,7 @@ // avx2-NOT: -target-feature // RUN: %clang_cl -m64 -arch:AVX --target=x86_64 -### -- 2>&1 %s | FileCheck -check-prefix=AVX64 %s +// AVX64: "-target-cpu" "sandybridge" // AVX64: -target-feature // AVX64: +avx @@ -72,6 +78,7 @@ // avx64-NOT: -target-feature // RUN: %clang_cl -m64 -arch:AVX2 --target=x86_64 -### -- 2>&1 %s | FileCheck -check-prefix=AVX264 %s +// AVX264: "-target-cpu" "haswell" // AVX264: -target-feature // AVX264: +avx2 diff --git a/test/Driver/darwin-debug-flags.c b/test/Driver/darwin-debug-flags.c index 17b0bba17c6b..5080a59e943d 100644 --- a/test/Driver/darwin-debug-flags.c +++ b/test/Driver/darwin-debug-flags.c @@ -5,7 +5,7 @@ // <rdar://problem/12955296> // RUN: %clang -### -target i386-apple-darwin9 -c -g %t.s 2>&1 | FileCheck -check-prefix=P %s -// CHECK: !0 = !DICompileUnit( +// CHECK: !0 = distinct !DICompileUnit( // CHECK-SAME: flags: // CHECK-SAME: -I path\5C with\5C \5C\5Cspaces // CHECK-SAME: -g -Os diff --git a/test/Driver/darwin-dsymutil.c b/test/Driver/darwin-dsymutil.c index 0e2c4907104e..09451a81b797 100644 --- a/test/Driver/darwin-dsymutil.c +++ b/test/Driver/darwin-dsymutil.c @@ -28,7 +28,7 @@ // RUN: -o foo %s -g 2> %t // RUN: FileCheck -check-prefix=CHECK-OUTPUT-NAME < %t %s // -// CHECK-OUTPUT-NAME: "x86_64-apple-darwin10" - "darwin::Link", inputs: [{{.*}}], output: "foo" +// CHECK-OUTPUT-NAME: "x86_64-apple-darwin10" - "darwin::Linker", inputs: [{{.*}}], output: "foo" // CHECK-OUTPUT-NAME: "x86_64-apple-darwin10" - "darwin::Dsymutil", inputs: ["foo"], output: "foo.dSYM" // Check that we only use dsymutil when needed. diff --git a/test/Driver/darwin-sdkroot.c b/test/Driver/darwin-sdkroot.c index 58bc683320ff..3d2a413a6370 100644 --- a/test/Driver/darwin-sdkroot.c +++ b/test/Driver/darwin-sdkroot.c @@ -40,3 +40,39 @@ // env SDKROOT=/ cmd //c echo %SDKROOT% // // This test passes using env.exe from GnuWin32. + +// Check if clang set the correct deployment target from -sysroot +// +// RUN: rm -rf %t/SDKs/iPhoneOS8.0.0.sdk +// RUN: mkdir -p %t/SDKs/iPhoneOS8.0.0.sdk +// RUN: env SDKROOT=%t/SDKs/iPhoneOS8.0.0.sdk %clang -target arm64-apple-darwin %s -### 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-IPHONE %s +// +// CHECK-IPHONE: clang +// CHECK-IPHONE: "-cc1" +// CHECK-IPHONE: "-triple" "arm64-apple-ios8.0.0" +// CHECK-IPHONE: ld +// CHECK-IPHONE: "-iphoneos_version_min" "8.0.0" +// +// +// RUN: rm -rf %t/SDKs/iPhoneSimulator8.0.sdk +// RUN: mkdir -p %t/SDKs/iPhoneSimulator8.0.sdk +// RUN: env SDKROOT=%t/SDKs/iPhoneSimulator8.0.sdk %clang -target x86_64-apple-darwin %s -### 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-SIMULATOR %s +// +// CHECK-SIMULATOR: clang +// CHECK-SIMULATOR: "-cc1" +// CHECK-SIMULATOR: "-triple" "x86_64-apple-ios8.0.0" +// CHECK-SIMULATOR: ld +// CHECK-SIMULATOR: "-ios_simulator_version_min" "8.0.0" +// +// RUN: rm -rf %t/SDKs/MacOSX10.10.0.sdk +// RUN: mkdir -p %t/SDKs/MacOSX10.10.0.sdk +// RUN: env SDKROOT=%t/SDKs/MacOSX10.10.0.sdk %clang -target x86_64-apple-darwin %s -### 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-MACOSX %s +// +// CHECK-MACOSX: clang +// CHECK-MACOSX: "-cc1" +// CHECK-MACOSX: "-triple" "x86_64-apple-macosx10.10.0" +// CHECK-MACOSX: ld +// CHECK-MACOSX: "-macosx_version_min" "10.10.0" diff --git a/test/Driver/darwin-verify-debug.c b/test/Driver/darwin-verify-debug.c index ebbf89a4d636..6b91290866a4 100644 --- a/test/Driver/darwin-verify-debug.c +++ b/test/Driver/darwin-verify-debug.c @@ -21,7 +21,7 @@ // RUN: --verify-debug-info -o foo %s -g 2> %t // RUN: FileCheck -check-prefix=CHECK-OUTPUT-NAME < %t %s // -// CHECK-OUTPUT-NAME: "x86_64-apple-darwin10" - "darwin::Link", inputs: [{{.*}}], output: "foo" +// CHECK-OUTPUT-NAME: "x86_64-apple-darwin10" - "darwin::Linker", inputs: [{{.*}}], output: "foo" // CHECK-OUTPUT-NAME: "x86_64-apple-darwin10" - "darwin::Dsymutil", inputs: ["foo"], output: "foo.dSYM" // CHECK-OUTPUT-NAME: "x86_64-apple-darwin10" - "darwin::VerifyDebug", inputs: ["foo.dSYM"], output: (nothing) diff --git a/test/Driver/fsanitize.c b/test/Driver/fsanitize.c index bac12dc7fb5f..96d078101695 100644 --- a/test/Driver/fsanitize.c +++ b/test/Driver/fsanitize.c @@ -11,11 +11,20 @@ // 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}"}} // 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}"}} +// 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|object-size|float-cast-overflow|array-bounds|enum|bool|returns-nonnull-attribute|nonnull-attribute),?){17}"}} // 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 i386-pc-win32 -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-WIN --check-prefix=CHECK-UNDEFINED-WIN32 +// RUN: %clang -target i386-pc-win32 -fsanitize=undefined -x c++ %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-WIN --check-prefix=CHECK-UNDEFINED-WIN32 --check-prefix=CHECK-UNDEFINED-WIN-CXX +// RUN: %clang -target x86_64-pc-win32 -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-WIN --check-prefix=CHECK-UNDEFINED-WIN64 +// RUN: %clang -target x86_64-pc-win32 -fsanitize=undefined -x c++ %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-WIN --check-prefix=CHECK-UNDEFINED-WIN64 --check-prefix=CHECK-UNDEFINED-WIN-CXX +// CHECK-UNDEFINED-WIN: "-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-WIN32-SAME: "--dependent-lib={{[^"]*}}ubsan_standalone-i386.lib" +// CHECK-UNDEFINED-WIN64-SAME: "--dependent-lib={{[^"]*}}ubsan_standalone-x86_64.lib" +// CHECK-UNDEFINED-WIN-CXX-SAME: "--dependent-lib={{[^"]*}}ubsan_standalone_cxx{{[^"]*}}.lib" + // 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}"}} @@ -205,6 +214,12 @@ // 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-apple-darwin10 -mmacosx-version-min=10.8 -fsanitize=vptr %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-VPTR-DARWIN-OLD +// CHECK-VPTR-DARWIN-OLD: unsupported option '-fsanitize=vptr' for target 'x86_64-apple-darwin10' + +// RUN: %clang -target x86_64-apple-darwin10 -mmacosx-version-min=10.9 -fsanitize=alignment,vptr %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-VPTR-DARWIN-NEW +// CHECK-VPTR-DARWIN-NEW: -fsanitize=alignment,vptr + // 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' @@ -228,6 +243,9 @@ // 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 -target x86_64-apple-darwin10 -mmacosx-version-min=10.7 -flto -fsanitize=cfi-vcall -fno-sanitize-trap=cfi -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-NOTRAP-OLD-MACOS +// CHECK-CFI-NOTRAP-OLD-MACOS: error: unsupported option '-fno-sanitize-trap=cfi-vcall' for target 'x86_64-apple-darwin10' + // 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 @@ -257,3 +275,7 @@ // SP: "-fsanitize=safe-stack" // SP-ASAN-NOT: stack-protector // SP-ASAN: "-fsanitize=address,safe-stack" + +// RUN: %clang -target powerpc64-unknown-linux-gnu -fsanitize=memory %s -### 2>&1 | FileCheck %s -check-prefix=CHECK-SANM +// RUN: %clang -target powerpc64le-unknown-linux-gnu -fsanitize=memory %s -### 2>&1 | FileCheck %s -check-prefix=CHECK-SANM +// CHECK-SANM: "-fsanitize=memory" diff --git a/test/Driver/integrated-as.s b/test/Driver/integrated-as.s index 9a7d2c5dfef4..181f790a1f99 100644 --- a/test/Driver/integrated-as.s +++ b/test/Driver/integrated-as.s @@ -43,3 +43,6 @@ // RUN: %clang -### -c -integrated-as %s -Wa,-gdwarf-2 2>&1 | FileCheck --check-prefix=DWARF2WA %s // DWARF2WA: "-gdwarf-2" + +// RUN: %clang -### -x assembler -c -integrated-as %s -I myincludedir 2>&1 | FileCheck --check-prefix=INCLUDEPATH %s +// INCLUDEPATH: "-I" "myincludedir" diff --git a/test/Driver/ios-version-min.c b/test/Driver/ios-version-min.c new file mode 100644 index 000000000000..aa536cf7827b --- /dev/null +++ b/test/Driver/ios-version-min.c @@ -0,0 +1,7 @@ +// REQUIRES: x86-registered-target +// REQUIRES: arm-registered-target +// RUN: %clang -target i386-apple-darwin10 -miphonesimulator-version-min=7.0 -arch i386 -S -o - %s | FileCheck %s +// RUN: %clang -target armv7s-apple-darwin10 -miphoneos-version-min=7.0 -arch armv7s -S -o - %s | FileCheck %s + +int main() { return 0; } +// CHECK: .ios_version_min 7, 0 diff --git a/test/Driver/linux-ld.c b/test/Driver/linux-ld.c index 5c4778be8cf5..5e865a953c7c 100644 --- a/test/Driver/linux-ld.c +++ b/test/Driver/linux-ld.c @@ -817,6 +817,19 @@ // CHECK-DEBIAN-PPC: "-L[[SYSROOT]]/lib" // CHECK-DEBIAN-PPC: "-L[[SYSROOT]]/usr/lib" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=powerpc64le-linux-gnu \ +// RUN: --gcc-toolchain="" \ +// RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ +// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-PPC64LE %s +// CHECK-DEBIAN-PPC64LE: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" +// CHECK-DEBIAN-PPC64LE: "{{.*}}/usr/lib/gcc/powerpc64le-linux-gnu/4.5{{/|\\\\}}crtbegin.o" +// CHECK-DEBIAN-PPC64LE: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64le-linux-gnu/4.5" +// CHECK-DEBIAN-PPC64LE: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64le-linux-gnu/4.5/../../../powerpc64le-linux-gnu" +// CHECK-DEBIAN-PPC64LE: "-L[[SYSROOT]]/usr/lib/powerpc64le-linux-gnu" +// CHECK-DEBIAN-PPC64LE: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64le-linux-gnu/4.5/../../.." +// CHECK-DEBIAN-PPC64LE: "-L[[SYSROOT]]/lib" +// CHECK-DEBIAN-PPC64LE: "-L[[SYSROOT]]/usr/lib" +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=powerpc64-linux-gnu \ // RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ diff --git a/test/Driver/lit.local.cfg b/test/Driver/lit.local.cfg index af6d02139069..6c2373bd2178 100644 --- a/test/Driver/lit.local.cfg +++ b/test/Driver/lit.local.cfg @@ -4,3 +4,15 @@ config.substitutions = list(config.substitutions) config.substitutions.insert(0, ('%clang_cc1', """*** Do not use 'clang -cc1' in Driver tests. ***""") ) + +# Remove harmful environmental variables for clang Driver tests. +# Some might be useful for other tests so they are only removed here. +driver_overwrite_env_vars = ['MACOSX_DEPLOYMENT_TARGET', + 'IPHONEOS_DEPLOYMENT_TARGET', + 'SDKROOT', 'CCC_OVERRIDE_OPTIONS', + 'CC_PRINT_OPTIONS', 'CC_PRINT_HEADERS', + 'CC_LOG_DIAGNOSTICS'] + +for name in driver_overwrite_env_vars: + if name in config.environment: + del config.environment[name] diff --git a/test/Driver/msan.c b/test/Driver/msan.c new file mode 100644 index 000000000000..22f7471510ad --- /dev/null +++ b/test/Driver/msan.c @@ -0,0 +1,12 @@ +// RUN: %clang -target x86_64-unknown-linux -fsanitize=memory %s -S -emit-llvm -o - | FileCheck %s +// RUN: %clang -O1 -target x86_64-unknown-linux -fsanitize=memory %s -S -emit-llvm -o - | FileCheck %s +// RUN: %clang -O2 -target x86_64-unknown-linux -fsanitize=memory %s -S -emit-llvm -o - | FileCheck %s +// RUN: %clang -O3 -target x86_64-unknown-linux -fsanitize=memory %s -S -emit-llvm -o - | FileCheck %s +// RUN: %clang -target mips64-linux-gnu -fsanitize=memory %s -S -emit-llvm -o - | FileCheck %s +// RUN: %clang -target mips64el-unknown-linux-gnu -fsanitize=memory %s -S -emit-llvm -o - | FileCheck %s +// RUN: %clang -target powerpc64-unknown-linux-gnu -fsanitize=memory %s -S -emit-llvm -o - | FileCheck %s +// RUN: %clang -target powerpc64le-unknown-linux-gnu -fsanitize=memory %s -S -emit-llvm -o - | FileCheck %s +// Verify that -fsanitize=memory invokes msan instrumentation. + +int foo(int *a) { return *a; } +// CHECK: __msan_init diff --git a/test/Driver/pic.c b/test/Driver/pic.c index a515f8117a1d..120e66a92ac4 100644 --- a/test/Driver/pic.c +++ b/test/Driver/pic.c @@ -242,3 +242,9 @@ // RUN: | FileCheck %s --check-prefix=CHECK-PIC1 // RUN: %clang -c %s -target arm64-linux-android -### 2>&1 \ // RUN: | FileCheck %s --check-prefix=CHECK-PIC1 +// +// On Windows-X64 PIC is enabled by default +// RUN: %clang -c %s -target x86_64-pc-windows-msvc18.0.0 -### 2>&1 \ +// RUN: | FileCheck %s --check-prefix=CHECK-PIC2 +// RUN: %clang -c %s -target x86_64-pc-windows-gnu -### 2>&1 \ +// RUN: | FileCheck %s --check-prefix=CHECK-PIC2 diff --git a/test/FixIt/fixit-nullability-declspec.cpp b/test/FixIt/fixit-nullability-declspec.cpp index 2ac20b9d9b4c..17989c3a885e 100644 --- a/test/FixIt/fixit-nullability-declspec.cpp +++ b/test/FixIt/fixit-nullability-declspec.cpp @@ -4,6 +4,6 @@ // 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?}} +_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/Index/annotate-literals.m b/test/Index/annotate-literals.m index 20bfd2c45642..a1e4fb2bd187 100644 --- a/test/Index/annotate-literals.m +++ b/test/Index/annotate-literals.m @@ -29,44 +29,61 @@ typedef unsigned char BOOL; + (id)dictionaryWithObjects:(const id [])objects forKeys:(const id [])keys count:(unsigned long)cnt; @end -void test_literals(id k1, id o1, id k2, id o2, id k3) { +@interface NSValue ++ (NSValue *)valueWithBytes:(const void *)value objCType:(const char *)type; +@end + +typedef struct __attribute__((objc_boxable)) _c_struct { + int dummy; +} c_struct; + +void test_literals(id k1, id o1, id k2, id o2, id k3, c_struct s) { id objects = @[ o1, o2 ]; id dict = @{ k1 : o1, k2 : o2, k3 : @17 }; + id val = @(s); } -// RUN: c-index-test -test-annotate-tokens=%s:33:1:37:1 %s | FileCheck -check-prefix=CHECK-LITERALS %s +// RUN: c-index-test -test-annotate-tokens=%s:41:1:46:1 %s | FileCheck -check-prefix=CHECK-LITERALS %s -// CHECK-LITERALS: Identifier: "id" [33:3 - 33:5] TypeRef=id:0:0 -// CHECK-LITERALS: Identifier: "objects" [33:6 - 33:13] VarDecl=objects:33:6 (Definition) -// CHECK-LITERALS: Punctuation: "=" [33:14 - 33:15] VarDecl=objects:33:6 (Definition) -// CHECK-LITERALS: Punctuation: "@" [33:16 - 33:17] UnexposedExpr= -// CHECK-LITERALS: Punctuation: "[" [33:17 - 33:18] UnexposedExpr= -// CHECK-LITERALS: Identifier: "o1" [33:19 - 33:21] DeclRefExpr=o1:32:30 -// CHECK-LITERALS: Punctuation: "," [33:21 - 33:22] UnexposedExpr= -// CHECK-LITERALS: Identifier: "o2" [33:23 - 33:25] DeclRefExpr=o2:32:44 -// CHECK-LITERALS: Punctuation: "]" [33:26 - 33:27] UnexposedExpr= -// CHECK-LITERALS: Punctuation: ";" [33:27 - 33:28] DeclStmt= -// CHECK-LITERALS: Identifier: "id" [34:3 - 34:5] TypeRef=id:0:0 -// CHECK-LITERALS: Identifier: "dict" [34:6 - 34:10] VarDecl=dict:34:6 (Definition) -// CHECK-LITERALS: Punctuation: "=" [34:11 - 34:12] VarDecl=dict:34:6 (Definition) -// CHECK-LITERALS: Punctuation: "@" [34:13 - 34:14] UnexposedExpr= -// CHECK-LITERALS: Punctuation: "{" [34:14 - 34:15] UnexposedExpr= -// CHECK-LITERALS: Identifier: "k1" [34:16 - 34:18] DeclRefExpr=k1:32:23 -// CHECK-LITERALS: Punctuation: ":" [34:19 - 34:20] UnexposedExpr= -// CHECK-LITERALS: Identifier: "o1" [34:21 - 34:23] DeclRefExpr=o1:32:30 -// CHECK-LITERALS: Punctuation: "," [34:23 - 34:24] UnexposedExpr= -// CHECK-LITERALS: Identifier: "k2" [35:16 - 35:18] DeclRefExpr=k2:32:37 -// CHECK-LITERALS: Punctuation: ":" [35:19 - 35:20] UnexposedExpr= -// CHECK-LITERALS: Identifier: "o2" [35:21 - 35:23] DeclRefExpr=o2:32:44 -// CHECK-LITERALS: Punctuation: "," [35:23 - 35:24] UnexposedExpr= -// CHECK-LITERALS: Identifier: "k3" [36:16 - 36:18] DeclRefExpr=k3:32:51 -// CHECK-LITERALS: Punctuation: ":" [36:19 - 36:20] UnexposedExpr= -// CHECK-LITERALS: Punctuation: "@" [36:21 - 36:22] UnexposedExpr= -// CHECK-LITERALS: Literal: "17" [36:22 - 36:24] IntegerLiteral= -// CHECK-LITERALS: Punctuation: "}" [36:25 - 36:26] UnexposedExpr= -// CHECK-LITERALS: Punctuation: ";" [36:26 - 36:27] DeclStmt= -// CHECK-LITERALS: Punctuation: "}" [37:1 - 37:2] CompoundStmt= +// CHECK-LITERALS: Identifier: "id" [41:3 - 41:5] TypeRef=id:0:0 +// CHECK-LITERALS: Identifier: "objects" [41:6 - 41:13] VarDecl=objects:41:6 (Definition) +// CHECK-LITERALS: Punctuation: "=" [41:14 - 41:15] VarDecl=objects:41:6 (Definition) +// CHECK-LITERALS: Punctuation: "@" [41:16 - 41:17] UnexposedExpr= +// CHECK-LITERALS: Punctuation: "[" [41:17 - 41:18] UnexposedExpr= +// CHECK-LITERALS: Identifier: "o1" [41:19 - 41:21] DeclRefExpr=o1:40:30 +// CHECK-LITERALS: Punctuation: "," [41:21 - 41:22] UnexposedExpr= +// CHECK-LITERALS: Identifier: "o2" [41:23 - 41:25] DeclRefExpr=o2:40:44 +// CHECK-LITERALS: Punctuation: "]" [41:26 - 41:27] UnexposedExpr= +// CHECK-LITERALS: Punctuation: ";" [41:27 - 41:28] DeclStmt= +// CHECK-LITERALS: Identifier: "id" [42:3 - 42:5] TypeRef=id:0:0 +// CHECK-LITERALS: Identifier: "dict" [42:6 - 42:10] VarDecl=dict:42:6 (Definition) +// CHECK-LITERALS: Punctuation: "=" [42:11 - 42:12] VarDecl=dict:42:6 (Definition) +// CHECK-LITERALS: Punctuation: "@" [42:13 - 42:14] UnexposedExpr= +// CHECK-LITERALS: Punctuation: "{" [42:14 - 42:15] UnexposedExpr= +// CHECK-LITERALS: Identifier: "k1" [42:16 - 42:18] DeclRefExpr=k1:40:23 +// CHECK-LITERALS: Punctuation: ":" [42:19 - 42:20] UnexposedExpr= +// CHECK-LITERALS: Identifier: "o1" [42:21 - 42:23] DeclRefExpr=o1:40:30 +// CHECK-LITERALS: Punctuation: "," [42:23 - 42:24] UnexposedExpr= +// CHECK-LITERALS: Identifier: "k2" [43:16 - 43:18] DeclRefExpr=k2:40:37 +// CHECK-LITERALS: Punctuation: ":" [43:19 - 43:20] UnexposedExpr= +// CHECK-LITERALS: Identifier: "o2" [43:21 - 43:23] DeclRefExpr=o2:40:44 +// CHECK-LITERALS: Punctuation: "," [43:23 - 43:24] UnexposedExpr= +// CHECK-LITERALS: Identifier: "k3" [44:16 - 44:18] DeclRefExpr=k3:40:51 +// CHECK-LITERALS: Punctuation: ":" [44:19 - 44:20] UnexposedExpr= +// CHECK-LITERALS: Punctuation: "@" [44:21 - 44:22] UnexposedExpr= +// CHECK-LITERALS: Literal: "17" [44:22 - 44:24] IntegerLiteral= +// CHECK-LITERALS: Punctuation: "}" [44:25 - 44:26] UnexposedExpr= +// CHECK-LITERALS: Punctuation: ";" [44:26 - 44:27] DeclStmt= +// CHECK-LITERALS: Identifier: "id" [45:3 - 45:5] TypeRef=id:0:0 +// CHECK-LITERALS: Identifier: "val" [45:6 - 45:9] VarDecl=val:45:6 (Definition) +// CHECK-LITERALS: Punctuation: "=" [45:10 - 45:11] VarDecl=val:45:6 (Definition) +// CHECK-LITERALS: Punctuation: "@" [45:12 - 45:13] UnexposedExpr= +// CHECK-LITERALS: Punctuation: "(" [45:13 - 45:14] ParenExpr= +// CHECK-LITERALS: Identifier: "s" [45:14 - 45:15] DeclRefExpr=s:40:64 +// CHECK-LITERALS: Punctuation: ")" [45:15 - 45:16] ParenExpr= +// CHECK-LITERALS: Punctuation: ";" [45:16 - 45:17] DeclStmt= +// CHECK-LITERALS: Punctuation: "}" [46:1 - 46:2] CompoundStmt= diff --git a/test/Index/complete-objc-message.m b/test/Index/complete-objc-message.m index a62b49194e83..193f1f8bf228 100644 --- a/test/Index/complete-objc-message.m +++ b/test/Index/complete-objc-message.m @@ -345,4 +345,4 @@ void test_Nullability(Nullability *n, A* a) { // 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 *)} +// CHECK-NULLABLE: ObjCInstanceMethodDecl:{ResultType A * _Nonnull}{TypedText method:}{Placeholder (nullable A *)} diff --git a/test/Index/complete-stmt.c b/test/Index/complete-stmt.c index 8bbfe2db56d8..0deb4d371c2f 100644 --- a/test/Index/complete-stmt.c +++ b/test/Index/complete-stmt.c @@ -16,8 +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 _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/Modules/Inputs/DebugModule.h b/test/Modules/Inputs/DebugModule.h new file mode 100644 index 000000000000..5612b73a8cfb --- /dev/null +++ b/test/Modules/Inputs/DebugModule.h @@ -0,0 +1 @@ +@class F; diff --git a/test/Modules/Inputs/ImportNameInDir.h b/test/Modules/Inputs/ImportNameInDir.h new file mode 100644 index 000000000000..ae7b1a0fb278 --- /dev/null +++ b/test/Modules/Inputs/ImportNameInDir.h @@ -0,0 +1,4 @@ +#import <NameInDir/NameInDir.h> + +// Don't crash. +#undef NAME_IN_DIR diff --git a/test/Modules/Inputs/NameInDir.framework/Headers/NameInDir.h b/test/Modules/Inputs/NameInDir.framework/Headers/NameInDir.h new file mode 100644 index 000000000000..bea23914858b --- /dev/null +++ b/test/Modules/Inputs/NameInDir.framework/Headers/NameInDir.h @@ -0,0 +1,2 @@ +// NameInDir.h +#define NAME_IN_DIR 1 diff --git a/test/Modules/Inputs/NameInDir.framework/Modules/module.modulemap b/test/Modules/Inputs/NameInDir.framework/Modules/module.modulemap new file mode 100644 index 000000000000..48e1c56749f9 --- /dev/null +++ b/test/Modules/Inputs/NameInDir.framework/Modules/module.modulemap @@ -0,0 +1,5 @@ +framework module NameInModMap { + umbrella header "NameInDir.h" + export * + module * { export * } +} diff --git a/test/Modules/Inputs/NameInDir2.framework/Headers/NameInDir2.h b/test/Modules/Inputs/NameInDir2.framework/Headers/NameInDir2.h new file mode 100644 index 000000000000..6dc3eea149e7 --- /dev/null +++ b/test/Modules/Inputs/NameInDir2.framework/Headers/NameInDir2.h @@ -0,0 +1 @@ +// NameInDir2.h diff --git a/test/Modules/Inputs/NameInDir2.framework/Modules/module.modulemap b/test/Modules/Inputs/NameInDir2.framework/Modules/module.modulemap new file mode 100644 index 000000000000..24f15f8e846b --- /dev/null +++ b/test/Modules/Inputs/NameInDir2.framework/Modules/module.modulemap @@ -0,0 +1,5 @@ +framework module NameInDir2 { + umbrella header "NameInDir2.h" + export * + module * { export * } +} diff --git a/test/Modules/Inputs/NameInDirInferred.framework/Headers/NameInDirInferred.h b/test/Modules/Inputs/NameInDirInferred.framework/Headers/NameInDirInferred.h new file mode 100644 index 000000000000..c0b12e6f9459 --- /dev/null +++ b/test/Modules/Inputs/NameInDirInferred.framework/Headers/NameInDirInferred.h @@ -0,0 +1 @@ +// NameInDirInferred.h diff --git a/test/Modules/Inputs/crash.h b/test/Modules/Inputs/crash.h new file mode 100644 index 000000000000..bc878fbcb027 --- /dev/null +++ b/test/Modules/Inputs/crash.h @@ -0,0 +1 @@ +#pragma clang __debug crash diff --git a/test/Modules/Inputs/explicit-build-prefer-self/a.h b/test/Modules/Inputs/explicit-build-prefer-self/a.h new file mode 100644 index 000000000000..d45761275d8f --- /dev/null +++ b/test/Modules/Inputs/explicit-build-prefer-self/a.h @@ -0,0 +1,2 @@ +// a +#include "x.h" diff --git a/test/Modules/Inputs/explicit-build-prefer-self/b.h b/test/Modules/Inputs/explicit-build-prefer-self/b.h new file mode 100644 index 000000000000..76e2042cb91c --- /dev/null +++ b/test/Modules/Inputs/explicit-build-prefer-self/b.h @@ -0,0 +1,2 @@ +// b +#include "x.h" diff --git a/test/Modules/Inputs/explicit-build-prefer-self/map b/test/Modules/Inputs/explicit-build-prefer-self/map new file mode 100644 index 000000000000..26be8e690736 --- /dev/null +++ b/test/Modules/Inputs/explicit-build-prefer-self/map @@ -0,0 +1,2 @@ +module a { header "a.h" header "x.h" } +module b { header "b.h" header "x.h" } diff --git a/test/Modules/Inputs/explicit-build-prefer-self/x.h b/test/Modules/Inputs/explicit-build-prefer-self/x.h new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Modules/Inputs/explicit-build-prefer-self/x.h diff --git a/test/Modules/Inputs/merge-class-definition-visibility/b.h b/test/Modules/Inputs/merge-class-definition-visibility/b.h index 2b8f5f868ed9..03c0ad98dfd8 100644 --- a/test/Modules/Inputs/merge-class-definition-visibility/b.h +++ b/test/Modules/Inputs/merge-class-definition-visibility/b.h @@ -1,2 +1,4 @@ // Include definition of A into the same module as c.h #include "a.h" + +struct B {}; diff --git a/test/Modules/Inputs/merge-class-definition-visibility/d.h b/test/Modules/Inputs/merge-class-definition-visibility/d.h index 2243de1baf9a..c51edab1416d 100644 --- a/test/Modules/Inputs/merge-class-definition-visibility/d.h +++ b/test/Modules/Inputs/merge-class-definition-visibility/d.h @@ -1 +1 @@ -#include "a.h" +struct B {}; diff --git a/test/Modules/Inputs/merge-class-definition-visibility/e.h b/test/Modules/Inputs/merge-class-definition-visibility/e.h new file mode 100644 index 000000000000..f126b504b9b5 --- /dev/null +++ b/test/Modules/Inputs/merge-class-definition-visibility/e.h @@ -0,0 +1,3 @@ +#include "a.h" + +struct B {}; diff --git a/test/Modules/Inputs/merge-class-definition-visibility/modmap b/test/Modules/Inputs/merge-class-definition-visibility/modmap index 7d988fbba003..dcb65871886a 100644 --- a/test/Modules/Inputs/merge-class-definition-visibility/modmap +++ b/test/Modules/Inputs/merge-class-definition-visibility/modmap @@ -3,5 +3,6 @@ module Def1 { module C { header "c.h" } } module Def2 { - header "d.h" + module D { header "d.h" } + module E { header "e.h" } } diff --git a/test/Modules/Inputs/module.map b/test/Modules/Inputs/module.map index 8ec3e21121b7..ffaa53e18e28 100644 --- a/test/Modules/Inputs/module.map +++ b/test/Modules/Inputs/module.map @@ -324,3 +324,15 @@ module recursive1 { module recursive2 { header "recursive2.h" } +module crash { + header "crash.h" +} + +module DebugModule { + header "DebugModule.h" +} + +module ImportNameInDir { + header "ImportNameInDir.h" + export * +} diff --git a/test/Modules/Inputs/submodule-visibility/a.h b/test/Modules/Inputs/submodule-visibility/a.h index d8805c92f24d..e4965d72218b 100644 --- a/test/Modules/Inputs/submodule-visibility/a.h +++ b/test/Modules/Inputs/submodule-visibility/a.h @@ -1 +1,9 @@ int n; + +#ifdef B +#error B is defined +#endif + +#define A + +#include "c.h" diff --git a/test/Modules/Inputs/submodule-visibility/b.h b/test/Modules/Inputs/submodule-visibility/b.h index fa419c0c5c48..67ef6529dbd8 100644 --- a/test/Modules/Inputs/submodule-visibility/b.h +++ b/test/Modules/Inputs/submodule-visibility/b.h @@ -1 +1,10 @@ int m = n; + +#include "other.h" +#include "c.h" + +#if defined(A) && !defined(ALLOW_NAME_LEAKAGE) +#error A is defined +#endif + +#define B diff --git a/test/Modules/Inputs/submodule-visibility/c.h b/test/Modules/Inputs/submodule-visibility/c.h new file mode 100644 index 000000000000..259b8c7c61c7 --- /dev/null +++ b/test/Modules/Inputs/submodule-visibility/c.h @@ -0,0 +1,6 @@ +#ifndef C_H_INCLUDED +#define C_H_INCLUDED + +struct C {}; + +#endif diff --git a/test/Modules/Inputs/submodule-visibility/module.modulemap b/test/Modules/Inputs/submodule-visibility/module.modulemap index 2e13344dc635..d2f0c7783ffa 100644 --- a/test/Modules/Inputs/submodule-visibility/module.modulemap +++ b/test/Modules/Inputs/submodule-visibility/module.modulemap @@ -1,4 +1,5 @@ module x { module a { header "a.h" } module b { header "b.h" } } +module other { header "other.h" } module cycles { module cycle1 { header "cycle1.h" } diff --git a/test/Modules/Inputs/submodule-visibility/other.h b/test/Modules/Inputs/submodule-visibility/other.h new file mode 100644 index 000000000000..f40c757ca62e --- /dev/null +++ b/test/Modules/Inputs/submodule-visibility/other.h @@ -0,0 +1 @@ +#include "c.h" diff --git a/test/Modules/Inputs/submodules-merge-defs/defs.h b/test/Modules/Inputs/submodules-merge-defs/defs.h index 247b05c47082..bda0567c93a3 100644 --- a/test/Modules/Inputs/submodules-merge-defs/defs.h +++ b/test/Modules/Inputs/submodules-merge-defs/defs.h @@ -10,6 +10,7 @@ public: // Check that lookup and access checks are performed in the right context. struct B::Inner2 : Inner1 {}; template<typename T> void B::f() {} +template<> inline void B::f<int>() {} // Check that base-specifiers are correctly disambiguated. template<int N> struct C_Base { struct D { constexpr operator int() const { return 0; } }; }; @@ -31,7 +32,8 @@ 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; } // FIXME: Re-enable this once we support merging member specializations. +template<> inline int F<char>::f() { return 0; } +template<> template<typename U> int F<char>::g() { return 0; } template<> struct F<void> { int h(); }; inline int F<void>::h() { return 0; } template<typename T> struct F<T *> { int i(); }; @@ -74,3 +76,21 @@ namespace FriendDefArg { template<typename, int, template<typename> class> friend struct D; }; } + +namespace SeparateInline { + inline void f(); + void f() {} + constexpr int g() { return 0; } +} + +namespace TrailingAttributes { + template<typename T> struct X {} __attribute__((aligned(8))); +} + +namespace MergeFunctionTemplateSpecializations { + template<typename T> T f(); + template<typename T> struct X { + template<typename U> using Q = decltype(f<T>() + U()); + }; + using xiq = X<int>::Q<int>; +} diff --git a/test/Modules/cxx-irgen.cpp b/test/Modules/cxx-irgen.cpp index 37de23fd2548..7cdb0d6eb595 100644 --- a/test/Modules/cxx-irgen.cpp +++ b/test/Modules/cxx-irgen.cpp @@ -12,7 +12,7 @@ CtorInit<int> x; // Keep these two namespace definitions separate; merging them hides the bug. namespace EmitInlineMethods { - // CHECK-DAG: define linkonce_odr [[CC:(x86_thiscallcc[ ]+)?]]void @_ZN17EmitInlineMethods1C1fEPNS_1AE( + // CHECK-DAG: define linkonce_odr [[CC:([0-9_a-z]*cc[ ]+)?]]void @_ZN17EmitInlineMethods1C1fEPNS_1AE( // CHECK-DAG: declare [[CC]]void @_ZN17EmitInlineMethods1A1gEv( struct C { __attribute__((used)) void f(A *p) { p->g(); } @@ -26,14 +26,14 @@ namespace EmitInlineMethods { }; } -// CHECK-DAG: define available_externally hidden {{signext i32|i32}} @_ZN1SIiE1gEv({{.*}} #[[ALWAYS_INLINE:.*]] align +// CHECK-DAG: define available_externally hidden {{.*}}{{signext i32|i32}} @_ZN1SIiE1gEv({{.*}} #[[ALWAYS_INLINE:.*]] align int a = S<int>::g(); int b = h(); -// CHECK-DAG: define linkonce_odr {{signext i32|i32}} @_Z3minIiET_S0_S0_(i32 +// CHECK-DAG: define linkonce_odr {{.*}}{{signext i32|i32}} @_Z3minIiET_S0_S0_(i32 int c = min(1, 2); -// CHECK: define available_externally {{signext i32|i32}} @_ZN1SIiE1fEv({{.*}} #[[ALWAYS_INLINE]] align +// CHECK: define available_externally {{.*}}{{signext i32|i32}} @_ZN1SIiE1fEv({{.*}} #[[ALWAYS_INLINE]] align namespace ImplicitSpecialMembers { // CHECK-LABEL: define {{.*}} @_ZN22ImplicitSpecialMembers1BC2ERKS0_( @@ -49,9 +49,9 @@ namespace ImplicitSpecialMembers { // CHECK-LABEL: define {{.*}} @_ZN22ImplicitSpecialMembers1DC2EOS0_( // CHECK: call {{.*}} @_ZN22ImplicitSpecialMembers1AC1ERKS0_( // CHECK-LABEL: define {{.*}} @_ZN20OperatorDeleteLookup1AD0Ev( - // CHECK: call void @_ZN20OperatorDeleteLookup1AdlEPv( + // CHECK: call {{.*}}void @_ZN20OperatorDeleteLookup1AdlEPv( - // CHECK-DAG: call {{[a-z]*[ ]?i32}} @_ZN8CtorInitIiE1fEv( + // CHECK-DAG: call {{[a-z\_\d]*[ ]?i32}} @_ZN8CtorInitIiE1fEv( extern B b1; B b2(b1); diff --git a/test/Modules/debug-info-moduleimport.m b/test/Modules/debug-info-moduleimport.m new file mode 100644 index 000000000000..1f12b0270be4 --- /dev/null +++ b/test/Modules/debug-info-moduleimport.m @@ -0,0 +1,7 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -g -fmodules -DGREETING="Hello World" -UNDEBUG -fimplicit-module-maps -fmodules-cache-path=%t %s -I %S/Inputs -isysroot /tmp/.. -I %t -emit-llvm -o - | FileCheck %s + +// CHECK: ![[CU:.*]] = distinct !DICompileUnit +@import DebugModule; +// CHECK: !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: ![[CU]], entity: ![[MODULE:.*]], line: 5) +// CHECK: ![[MODULE]] = !DIModule(scope: null, name: "DebugModule", configMacros: "\22-DGREETING=Hello World\22 \22-UNDEBUG\22", includePath: "{{.*}}test{{.*}}Modules{{.*}}Inputs", isysroot: "/tmp/..") diff --git a/test/Modules/direct-module-import.m b/test/Modules/direct-module-import.m index 3216eb908ab6..bf9248e395e8 100644 --- a/test/Modules/direct-module-import.m +++ b/test/Modules/direct-module-import.m @@ -1,7 +1,7 @@ // RUN: rm -rf %t // 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 +// CHECK: call {{.*}}i8* @getModuleVersion const char* getVer(void) { return getModuleVersion(); } diff --git a/test/Modules/explicit-build-prefer-self.cpp b/test/Modules/explicit-build-prefer-self.cpp new file mode 100644 index 000000000000..13fbdbd764c4 --- /dev/null +++ b/test/Modules/explicit-build-prefer-self.cpp @@ -0,0 +1,3 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -fno-implicit-modules -emit-module -fmodule-name=a %S/Inputs/explicit-build-prefer-self/map -o %t/a.pcm +// RUN: %clang_cc1 -fmodules -fno-implicit-modules -emit-module -fmodule-name=b %S/Inputs/explicit-build-prefer-self/map -o %t/b.pcm diff --git a/test/Modules/framework-name.m b/test/Modules/framework-name.m new file mode 100644 index 000000000000..a63e206073d4 --- /dev/null +++ b/test/Modules/framework-name.m @@ -0,0 +1,33 @@ +// REQUIRES: shell +// RUN: rm -rf %t.mcp %t +// RUN: mkdir -p %t +// RUN: ln -s %S/Inputs/NameInDir2.framework %t/NameInImport.framework +// RUN: ln -s %S/Inputs/NameInDirInferred.framework %t/NameInImportInferred.framework +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t.mcp -fimplicit-module-maps -I %S/Inputs -F %S/Inputs -F %t -Wauto-import -verify %s + +// Sanity check that we won't somehow find non-canonical module names or +// modules where we shouldn't search the framework. +// RUN: echo '@import NameInModMap' | not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -F %S/Inputs -F %t -Wauto-import -x objective-c - 2>&1 | FileCheck %s +// RUN: echo '@import NameInDir' | not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -F %S/Inputs -F %t -Wauto-import -x objective-c - 2>&1 | FileCheck %s +// RUN: echo '@import NameInImport' | not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -F %S/Inputs -F %t -Wauto-import -x objective-c - 2>&1 | FileCheck %s +// RUN: echo '@import NameInImportInferred' | not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -F %S/Inputs -F %t -Wauto-import -x objective-c - 2>&1 | FileCheck %s +// CHECK: module '{{.*}}' not found + +// FIXME: We might want to someday lock down framework modules so that these +// name mismatches are disallowed. However, as long as we *don't* prevent them +// it's important that they map correctly to module imports. + +// The module map name doesn't match the directory name. +#import <NameInDir/NameInDir.h> // expected-warning {{import of module 'NameInModMap'}} + +// The name in the import doesn't match the module name. +#import <NameInImport/NameInDir2.h> // expected-warning {{import of module 'NameInDir2'}} +@import NameInDir2; // OK + +// The name in the import doesn't match the module name (inferred framework module). +#import <NameInImportInferred/NameInDirInferred.h> // expected-warning {{import of module 'NameInDirInferred'}} + +@import ImportNameInDir; +#ifdef NAME_IN_DIR +#error NAME_IN_DIR should be undef'd +#endif diff --git a/test/Modules/merge-class-definition-visibility.cpp b/test/Modules/merge-class-definition-visibility.cpp index e8602c0d5489..ac4c95158449 100644 --- a/test/Modules/merge-class-definition-visibility.cpp +++ b/test/Modules/merge-class-definition-visibility.cpp @@ -1,15 +1,23 @@ // 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 +// RUN: -fmodules-cache-path=%t %s -verify \ +// RUN: -fmodules-local-submodule-visibility // expected-no-diagnostics #include "c.h" template<typename T> struct X { T t; }; typedef X<A> XA; +struct B; -#include "d.h" -// Ensure that this triggers the import of the second definition from d.h, +#include "e.h" +// Ensure that this triggers the import of the second definition from e.h, // which is necessary to make the definition of A visible in the template // instantiation. XA xa; + +// Ensure that we make the definition of B visible. We made the parse-merged +// definition from e.h visible, which makes the definition from d.h visible, +// and that definition was merged into the canonical definition from b.h, +// so that becomes visible, and we have a visible definition. +B b; diff --git a/test/Modules/module-feature.m b/test/Modules/module-feature.m new file mode 100644 index 000000000000..4926d26515f8 --- /dev/null +++ b/test/Modules/module-feature.m @@ -0,0 +1,14 @@ +// RUN: rm -rf %t %t.nohash + +// Each set of features gets its own cache. +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fimplicit-module-maps -fmodule-feature f1 -fmodule-feature f2 -F %S/Inputs %s -verify -Rmodule-build +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fimplicit-module-maps -fmodule-feature f2 -F %S/Inputs %s -verify -Rmodule-build +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fimplicit-module-maps -fmodule-feature f2 -fmodule-feature f1 -F %S/Inputs %s -Rmodule-build 2>&1 | FileCheck %s -allow-empty -check-prefix=ALREADY_BUILT +// ALREADY_BUILT-NOT: building module + +// Errors if we try to force the load. +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t.nohash -fimplicit-module-maps -fdisable-module-hash -fmodule-feature f1 -fmodule-feature f2 -F %S/Inputs %s -verify -Rmodule-build +// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t.nohash -fimplicit-module-maps -fdisable-module-hash -fmodule-feature f2 -F %S/Inputs %s 2>&1 | FileCheck %s -check-prefix=DIFFERS +// DIFFERS: error: module features differs + +@import Module; // expected-remark {{building module 'Module'}} expected-remark {{finished}} diff --git a/test/Modules/module_file_info.m b/test/Modules/module_file_info.m index 01d5073650b4..8693d2b89497 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 -fimplicit-module-maps -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 -fmodule-feature myfeature %s // RUN: %clang_cc1 -module-file-info %t/DependsOnModule.pcm | FileCheck %s // CHECK: Generated by this Clang: @@ -14,6 +14,8 @@ // CHECK: C99: Yes // CHECK: Objective-C 1: Yes // CHECK: modules extension to C: Yes +// CHECK: Module features: +// CHECK: myfeature // CHECK: Target options: // CHECK: Triple: diff --git a/test/Modules/modules-with-same-name.m b/test/Modules/modules-with-same-name.m index b5cb6fafb851..b6925dfd234c 100644 --- a/test/Modules/modules-with-same-name.m +++ b/test/Modules/modules-with-same-name.m @@ -7,19 +7,19 @@ // 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 +// RUN: find %t -name "A-*.pc[m]" | count 2 // DependsOnA, using A from 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 +// RUN: find %t -name "*.pc[m]" | count 3 // DependsOnA, using A from 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 +// RUN: find %t -name "*.pc[m]" | count 3 #ifdef DIRECT @import A; diff --git a/test/Modules/pch-used.m b/test/Modules/pch-used.m index cdfadb2cf966..0711d136b82e 100644 --- a/test/Modules/pch-used.m +++ b/test/Modules/pch-used.m @@ -6,4 +6,4 @@ void f() { SPXTrace(); } void g() { double x = DBL_MAX; } -// CHECK: define internal void @SPXTrace +// CHECK: define internal {{.*}}void @SPXTrace diff --git a/test/Modules/signal.m b/test/Modules/signal.m new file mode 100644 index 000000000000..30059e935113 --- /dev/null +++ b/test/Modules/signal.m @@ -0,0 +1,11 @@ +// REQUIRES: shell +// RUN: rm -rf %t + +// Crash building module. +// RUN: not --crash %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs %s + +// The dead symlink is still around, but the underlying lock file is gone. +// RUN: find %t -name "crash-*.pcm.lock" | count 1 +// RUN: find %t -name "crash-*.pcm.lock-*" | count 0 + +@import crash; diff --git a/test/Modules/submodule-visibility.cpp b/test/Modules/submodule-visibility.cpp index 084f811f231f..b2c5fc7ba198 100644 --- a/test/Modules/submodule-visibility.cpp +++ b/test/Modules/submodule-visibility.cpp @@ -20,3 +20,11 @@ #endif int k = n + m; // OK, a and b are visible here. + +#ifndef A +#error A is not defined +#endif + +#ifndef B +#error B is not defined +#endif diff --git a/test/Modules/submodules-merge-defs.cpp b/test/Modules/submodules-merge-defs.cpp index 94c0fd354c98..92c784440b9e 100644 --- a/test/Modules/submodules-merge-defs.cpp +++ b/test/Modules/submodules-merge-defs.cpp @@ -3,7 +3,7 @@ // 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 -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility -DTEXTUAL -DEARLY_INDIRECT_INCLUDE -fno-modules-hide-internal-linkage // 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. @@ -27,33 +27,37 @@ int pre_use_a = use_a(pre_a); // expected-error {{'A' must be imported}} expecte B::Inner2 pre_bi; // expected-error +{{must be imported}} // expected-note@defs.h:4 +{{here}} // expected-note@defs.h:11 +{{here}} +void pre_bfi(B b) { // expected-error {{must use 'class'}} expected-error +{{must be imported}} + b.f<int>(); // expected-error +{{must be imported}} expected-error +{{}} + // expected-note@defs.h:12 +{{here}} +} C_Base<1> pre_cb1; // expected-error +{{must be imported}} -// expected-note@defs.h:15 +{{here}} +// expected-note@defs.h:16 +{{here}} C1 pre_c1; // expected-error +{{must be imported}} expected-error {{must use 'struct'}} -// expected-note@defs.h:17 +{{here}} -C2 pre_c2; // expected-error +{{must be imported}} expected-error {{must use 'struct'}} // expected-note@defs.h:18 +{{here}} +C2 pre_c2; // expected-error +{{must be imported}} expected-error {{must use 'struct'}} +// expected-note@defs.h:19 +{{here}} D::X pre_dx; // expected-error +{{must be imported}} -// expected-note@defs.h:20 +{{here}} // expected-note@defs.h:21 +{{here}} +// expected-note@defs.h:22 +{{here}} // FIXME: We should warn that use_dx is being used without being imported. int pre_use_dx = use_dx(pre_dx); int pre_e = E(0); // expected-error {{must be imported}} -// expected-note@defs.h:24 +{{here}} +// expected-note@defs.h:25 +{{here}} 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}} +// expected-note@defs.h:27 +{{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}} +// expected-note@defs.h:43 +{{here}} +decltype(G::h) pre_gh = G::h; // expected-error +{{must be imported}} +// expected-note@defs.h:44 +{{here}} J<> pre_j; // expected-error {{declaration of 'J' must be imported}} #ifdef IMPORT_USE_2 @@ -63,7 +67,7 @@ J<> pre_j; // expected-error {{declaration of 'J' must be imported}} #else // expected-error@-6 {{default argument of 'J' must be imported from module 'stuff.use'}} #endif -// expected-note@defs.h:49 +{{here}} +// expected-note@defs.h:51 +{{here}} // Make definitions from second module visible. #ifdef TEXTUAL @@ -77,6 +81,9 @@ J<> pre_j; // expected-error {{declaration of 'J' must be imported}} A post_a; int post_use_a = use_a(post_a); B::Inner2 post_bi; +void post_bfi(B b) { + b.f<int>(); +} C_Base<1> post_cb1; C1 c1; C2 c2; @@ -92,3 +99,10 @@ 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; + +MergeFunctionTemplateSpecializations::X<int>::Q<char> xiqc; + +#ifdef TEXTUAL +#include "use-defs.h" +void use_static_inline() { StaticInline::g({}); } +#endif diff --git a/test/OpenMP/barrier_codegen.cpp b/test/OpenMP/barrier_codegen.cpp index 12d4c449ff71..9e393ac83360 100644 --- a/test/OpenMP/barrier_codegen.cpp +++ b/test/OpenMP/barrier_codegen.cpp @@ -24,7 +24,7 @@ int main(int argc, char **argv) { static int a; #pragma omp barrier // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T]]* [[LOC]]) - // CHECK: call i32 @__kmpc_cancel_barrier([[IDENT_T]]* [[EXPLICIT_BARRIER_LOC]], i32 [[GTID]]) + // CHECK: call void @__kmpc_barrier([[IDENT_T]]* [[EXPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: call {{.+}} [[TMAIN_INT:@.+]](i{{[0-9][0-9]}} // CHECK: call {{.+}} [[TMAIN_CHAR:@.+]](i{{[0-9]}} return tmain(argc) + tmain(argv[0][0]) + a; @@ -32,10 +32,10 @@ int main(int argc, char **argv) { // CHECK: define {{.+}} [[TMAIN_INT]]( // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T]]* [[LOC]]) -// CHECK: call i32 @__kmpc_cancel_barrier([[IDENT_T]]* [[EXPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call void @__kmpc_barrier([[IDENT_T]]* [[EXPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: define {{.+}} [[TMAIN_CHAR]]( // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T]]* [[LOC]]) -// CHECK: call i32 @__kmpc_cancel_barrier([[IDENT_T]]* [[EXPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call void @__kmpc_barrier([[IDENT_T]]* [[EXPLICIT_BARRIER_LOC]], i32 [[GTID]]) #endif diff --git a/test/OpenMP/cancel_ast_print.cpp b/test/OpenMP/cancel_ast_print.cpp new file mode 100644 index 000000000000..f244c784e86e --- /dev/null +++ b/test/OpenMP/cancel_ast_print.cpp @@ -0,0 +1,47 @@ +// 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 + +int main (int argc, char **argv) { +// CHECK: int main(int argc, char **argv) { +#pragma omp parallel +{ +#pragma omp cancel parallel +} +// CHECK: #pragma omp parallel +// CHECK-NEXT: { +// CHECK-NEXT: #pragma omp cancel parallel +// CHECK-NEXT: } +#pragma omp sections +{ +#pragma omp cancel sections +} +// CHECK-NEXT: #pragma omp sections +// CHECK: { +// CHECK: #pragma omp cancel sections +// CHECK: } +#pragma omp for +for (int i = 0; i < argc; ++i) { +#pragma omp cancel for +} +// CHECK: #pragma omp for +// CHECK-NEXT: for (int i = 0; i < argc; ++i) { +// CHECK-NEXT: #pragma omp cancel for +// CHECK-NEXT: } +#pragma omp task +{ +#pragma omp cancel taskgroup +} +// CHECK: #pragma omp task +// CHECK: { +// CHECK: #pragma omp cancel taskgroup +// CHECK: } +// CHECK: return argc; + return argc; +} + +#endif diff --git a/test/OpenMP/cancel_messages.cpp b/test/OpenMP/cancel_messages.cpp new file mode 100644 index 000000000000..07088387cb4f --- /dev/null +++ b/test/OpenMP/cancel_messages.cpp @@ -0,0 +1,83 @@ +// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s + +int main(int argc, char **argv) { +#pragma omp cancellation // expected-error {{expected an OpenMP directive}} +#pragma omp cancel // expected-error {{one of 'for', 'parallel', 'sections' or 'taskgroup' is expected}} + ; +#pragma omp cancel parallel untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp cancel'}} +#pragma omp cancel unknown // expected-error {{one of 'for', 'parallel', 'sections' or 'taskgroup' is expected}} +#pragma omp cancel sections( // expected-warning {{extra tokens at the end of '#pragma omp cancel' are ignored}} +#pragma omp cancel for, ) // expected-warning {{extra tokens at the end of '#pragma omp cancel' are ignored}} +#pragma omp cancel taskgroup() // expected-warning {{extra tokens at the end of '#pragma omp cancel' are ignored}} +#pragma omp cancel parallel, if // expected-warning {{extra tokens at the end of '#pragma omp cancel' are ignored}} + if (argc) +#pragma omp cancel for // expected-error {{'#pragma omp cancel' cannot be an immediate substatement}} + if (argc) { +#pragma omp taskgroup +#pragma omp task +#pragma omp parallel + { +#pragma omp cancel taskgroup // expected-error {{region cannot be closely nested inside 'parallel' region}} + } + } +#pragma omp parallel +#pragma omp taskgroup + { +#pragma omp cancel taskgroup // expected-error {{region cannot be closely nested inside 'taskgroup' region}} + } +#pragma omp parallel + { +#pragma omp cancel for // expected-error {{region cannot be closely nested inside 'parallel' region}} + } +#pragma omp task + { +#pragma omp cancel sections // expected-error {{region cannot be closely nested inside 'task' region}} + } +#pragma omp sections + { +#pragma omp cancel parallel // expected-error {{region cannot be closely nested inside 'sections' region}} + } + while (argc) +#pragma omp cancel for // expected-error {{'#pragma omp cancel' cannot be an immediate substatement}} + while (argc) { +#pragma omp cancel sections + } + do +#pragma omp cancel parallel // expected-error {{'#pragma omp cancel' cannot be an immediate substatement}} + while (argc) + ; + do { +#pragma omp cancel taskgroup + } while (argc); + switch (argc) +#pragma omp cancel parallel // expected-error {{'#pragma omp cancel' cannot be an immediate substatement}} + switch (argc) + case 1: +#pragma omp cancel sections // expected-error {{'#pragma omp cancel' cannot be an immediate substatement}} + switch (argc) + case 1: { +#pragma omp cancel for + } + switch (argc) { +#pragma omp cancel taskgroup + case 1: +#pragma omp cancel parallel // expected-error {{'#pragma omp cancel' cannot be an immediate substatement}} + break; + default: { +#pragma omp cancel sections + } break; + } + for (;;) +#pragma omp cancel for // expected-error {{'#pragma omp cancel' cannot be an immediate substatement}} + for (;;) { +#pragma omp cancel taskgroup + } +label: +#pragma omp cancel parallel // expected-error {{'#pragma omp cancel' cannot be an immediate substatement}} +label1 : { +#pragma omp cancel sections +} + + return 0; +} + diff --git a/test/OpenMP/cancellation_point_ast_print.cpp b/test/OpenMP/cancellation_point_ast_print.cpp new file mode 100644 index 000000000000..c8b133cbac68 --- /dev/null +++ b/test/OpenMP/cancellation_point_ast_print.cpp @@ -0,0 +1,47 @@ +// 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 + +int main (int argc, char **argv) { +// CHECK: int main(int argc, char **argv) { +#pragma omp parallel +{ +#pragma omp cancellation point parallel +} +// CHECK: #pragma omp parallel +// CHECK-NEXT: { +// CHECK-NEXT: #pragma omp cancellation point parallel +// CHECK-NEXT: } +#pragma omp sections +{ +#pragma omp cancellation point sections +} +// CHECK-NEXT: #pragma omp sections +// CHECK: { +// CHECK: #pragma omp cancellation point sections +// CHECK: } +#pragma omp for +for (int i = 0; i < argc; ++i) { +#pragma omp cancellation point for +} +// CHECK: #pragma omp for +// CHECK-NEXT: for (int i = 0; i < argc; ++i) { +// CHECK-NEXT: #pragma omp cancellation point for +// CHECK-NEXT: } +#pragma omp task +{ +#pragma omp cancellation point taskgroup +} +// CHECK: #pragma omp task +// CHECK: { +// CHECK: #pragma omp cancellation point taskgroup +// CHECK: } +// CHECK: return argc; + return argc; +} + +#endif diff --git a/test/OpenMP/cancellation_point_codegen.cpp b/test/OpenMP/cancellation_point_codegen.cpp new file mode 100644 index 000000000000..47903c1f3277 --- /dev/null +++ b/test/OpenMP/cancellation_point_codegen.cpp @@ -0,0 +1,95 @@ +// RUN: %clang_cc1 -verify -fopenmp -triple x86_64-apple-darwin13.4.0 -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-apple-darwin13.4.0 -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -std=c++11 -include-pch %t -fsyntax-only -verify %s -triple x86_64-apple-darwin13.4.0 -emit-llvm -o - | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +int main (int argc, char **argv) { +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num( +#pragma omp parallel +{ +#pragma omp cancellation point parallel + argv[0][0] = argc; +} +// CHECK: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call( +#pragma omp sections +{ +#pragma omp cancellation point sections +} +// CHECK: call i32 @__kmpc_single( +// CHECK-NOT: @__kmpc_cancellationpoint +// CHECK: call void @__kmpc_end_single( +// CHECK: call void @__kmpc_barrier(%ident_t* +#pragma omp sections +{ +#pragma omp cancellation point sections +#pragma omp section + { +#pragma omp cancellation point sections + } +} +// CHECK: call void @__kmpc_for_static_init_4( +// CHECK: [[RES:%.+]] = call i32 @__kmpc_cancellationpoint(%ident_t* {{[^,]+}}, i32 [[GTID]], i32 3) +// CHECK: [[CMP:%.+]] = icmp ne i32 [[RES]], 0 +// CHECK: br i1 [[CMP]], label %[[EXIT:[^,].+]], label %[[CONTINUE:.+]] +// CHECK: [[EXIT]] +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* +// CHECK: br label +// CHECK: [[CONTINUE]] +// CHECK: br label +// CHECK: [[RES:%.+]] = call i32 @__kmpc_cancellationpoint(%ident_t* {{[^,]+}}, i32 [[GTID]], i32 3) +// CHECK: [[CMP:%.+]] = icmp ne i32 [[RES]], 0 +// CHECK: br i1 [[CMP]], label %[[EXIT:[^,].+]], label %[[CONTINUE:.+]] +// CHECK: [[EXIT]] +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* +// CHECK: br label +// CHECK: [[CONTINUE]] +// CHECK: br label +// CHECK: call void @__kmpc_for_static_fini( +#pragma omp for +for (int i = 0; i < argc; ++i) { +#pragma omp cancellation point for +} +// CHECK: call void @__kmpc_for_static_init_4( +// CHECK: [[RES:%.+]] = call i32 @__kmpc_cancellationpoint(%ident_t* {{[^,]+}}, i32 [[GTID]], i32 2) +// CHECK: [[CMP:%.+]] = icmp ne i32 [[RES]], 0 +// CHECK: br i1 [[CMP]], label %[[EXIT:[^,].+]], label %[[CONTINUE:.+]] +// CHECK: [[EXIT]] +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* +// CHECK: br label +// CHECK: [[CONTINUE]] +// CHECK: br label +// CHECK: call void @__kmpc_for_static_fini( +// CHECK: call void @__kmpc_barrier(%ident_t* +#pragma omp task +{ +#pragma omp cancellation point taskgroup +} +// CHECK: call i8* @__kmpc_omp_task_alloc( +// CHECK: call i32 @__kmpc_omp_task( + return argc; +} + +// CHECK: define internal void @{{[^(]+}}(i32* {{[^,]+}}, i32* {{[^,]+}}, +// CHECK: [[RES:%.+]] = call i32 @__kmpc_cancellationpoint(%ident_t* {{[^,]+}}, i32 {{[^,]+}}, i32 1) +// CHECK: [[CMP:%.+]] = icmp ne i32 [[RES]], 0 +// CHECK: br i1 [[CMP]], label %[[EXIT:[^,]+]], +// CHECK: [[EXIT]] +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* +// CHECK: br label %[[RETURN:.+]] +// CHECK: [[RETURN]] +// CHECK: ret void + +// CHECK: define internal i32 @{{[^(]+}}(i32 +// CHECK: [[RES:%.+]] = call i32 @__kmpc_cancellationpoint(%ident_t* {{[^,]+}}, i32 {{[^,]+}}, i32 4) +// CHECK: [[CMP:%.+]] = icmp ne i32 [[RES]], 0 +// CHECK: br i1 [[CMP]], label %[[EXIT:[^,]+]], +// CHECK: [[EXIT]] +// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* +// CHECK: br label %[[RETURN:.+]] +// CHECK: [[RETURN]] +// CHECK: ret i32 0 + +#endif diff --git a/test/OpenMP/cancellation_point_messages.cpp b/test/OpenMP/cancellation_point_messages.cpp new file mode 100644 index 000000000000..d25cb6113d16 --- /dev/null +++ b/test/OpenMP/cancellation_point_messages.cpp @@ -0,0 +1,83 @@ +// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s + +int main(int argc, char **argv) { +#pragma omp cancellation // expected-error {{expected an OpenMP directive}} +#pragma omp cancellation point // expected-error {{one of 'for', 'parallel', 'sections' or 'taskgroup' is expected}} + ; +#pragma omp cancellation point parallel untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp cancellation point'}} +#pragma omp cancellation point unknown // expected-error {{one of 'for', 'parallel', 'sections' or 'taskgroup' is expected}} +#pragma omp cancellation point sections( // expected-warning {{extra tokens at the end of '#pragma omp cancellation point' are ignored}} +#pragma omp cancellation point for, ) // expected-warning {{extra tokens at the end of '#pragma omp cancellation point' are ignored}} +#pragma omp cancellation point taskgroup() // expected-warning {{extra tokens at the end of '#pragma omp cancellation point' are ignored}} +#pragma omp cancellation point parallel, if // expected-warning {{extra tokens at the end of '#pragma omp cancellation point' are ignored}} + if (argc) +#pragma omp cancellation point for // expected-error {{'#pragma omp cancellation point' cannot be an immediate substatement}} + if (argc) { +#pragma omp taskgroup +#pragma omp task +#pragma omp parallel + { +#pragma omp cancellation point taskgroup // expected-error {{region cannot be closely nested inside 'parallel' region}} + } + } +#pragma omp parallel +#pragma omp taskgroup + { +#pragma omp cancellation point taskgroup // expected-error {{region cannot be closely nested inside 'taskgroup' region}} + } +#pragma omp parallel + { +#pragma omp cancellation point for // expected-error {{region cannot be closely nested inside 'parallel' region}} + } +#pragma omp task + { +#pragma omp cancellation point sections // expected-error {{region cannot be closely nested inside 'task' region}} + } +#pragma omp sections + { +#pragma omp cancellation point parallel // expected-error {{region cannot be closely nested inside 'sections' region}} + } + while (argc) +#pragma omp cancellation point for // expected-error {{'#pragma omp cancellation point' cannot be an immediate substatement}} + while (argc) { +#pragma omp cancellation point sections + } + do +#pragma omp cancellation point parallel // expected-error {{'#pragma omp cancellation point' cannot be an immediate substatement}} + while (argc) + ; + do { +#pragma omp cancellation point taskgroup + } while (argc); + switch (argc) +#pragma omp cancellation point parallel // expected-error {{'#pragma omp cancellation point' cannot be an immediate substatement}} + switch (argc) + case 1: +#pragma omp cancellation point sections // expected-error {{'#pragma omp cancellation point' cannot be an immediate substatement}} + switch (argc) + case 1: { +#pragma omp cancellation point for + } + switch (argc) { +#pragma omp cancellation point taskgroup + case 1: +#pragma omp cancellation point parallel // expected-error {{'#pragma omp cancellation point' cannot be an immediate substatement}} + break; + default: { +#pragma omp cancellation point sections + } break; + } + for (;;) +#pragma omp cancellation point for // expected-error {{'#pragma omp cancellation point' cannot be an immediate substatement}} + for (;;) { +#pragma omp cancellation point taskgroup + } +label: +#pragma omp cancellation point parallel // expected-error {{'#pragma omp cancellation point' cannot be an immediate substatement}} +label1 : { +#pragma omp cancellation point sections +} + + return 0; +} + diff --git a/test/OpenMP/critical_codegen.cpp b/test/OpenMP/critical_codegen.cpp index d350d6e3aaea..26f5edb38038 100644 --- a/test/OpenMP/critical_codegen.cpp +++ b/test/OpenMP/critical_codegen.cpp @@ -11,7 +11,7 @@ // CHECK: [[UNNAMED_LOCK:@.+]] = common global [8 x i32] zeroinitializer // CHECK: [[THE_NAME_LOCK:@.+]] = common global [8 x i32] zeroinitializer -// CHECK: define void [[FOO:@.+]]() +// CHECK: define {{.*}}void [[FOO:@.+]]() void foo() {} @@ -21,15 +21,15 @@ 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_critical([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], [8 x i32]* [[UNNAMED_LOCK]]) +// CHECK: [[GTID:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:@.+]]) +// CHECK: call {{.*}}void @__kmpc_critical([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], [8 x i32]* [[UNNAMED_LOCK]]) // CHECK-NEXT: store i8 2, i8* [[A_ADDR]] -// CHECK-NEXT: call void @__kmpc_end_critical([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], [8 x i32]* [[UNNAMED_LOCK]]) +// CHECK-NEXT: call {{.*}}void @__kmpc_end_critical([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], [8 x i32]* [[UNNAMED_LOCK]]) #pragma omp critical a = 2; -// CHECK: call void @__kmpc_critical([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], [8 x i32]* [[THE_NAME_LOCK]]) -// CHECK-NEXT: invoke void [[FOO]]() -// CHECK: call void @__kmpc_end_critical([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], [8 x i32]* [[THE_NAME_LOCK]]) +// CHECK: call {{.*}}void @__kmpc_critical([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], [8 x i32]* [[THE_NAME_LOCK]]) +// CHECK-NEXT: invoke {{.*}}void [[FOO]]() +// CHECK: call {{.*}}void @__kmpc_end_critical([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], [8 x i32]* [[THE_NAME_LOCK]]) #pragma omp critical(the_name) foo(); // CHECK-NOT: call void @__kmpc_critical diff --git a/test/OpenMP/flush_codegen.cpp b/test/OpenMP/flush_codegen.cpp index 2c41b3a2ed6d..4ebdf522c28c 100644 --- a/test/OpenMP/flush_codegen.cpp +++ b/test/OpenMP/flush_codegen.cpp @@ -19,16 +19,16 @@ int main() { static int a; #pragma omp flush #pragma omp flush(a) - // CHECK: call void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) - // CHECK: call void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) + // CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) + // CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) return tmain(a); // CHECK: call {{.*}} [[TMAIN:@.+]]( // CHECK: ret } // CHECK: [[TMAIN]] -// CHECK: call void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) -// CHECK: call void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) +// CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) +// CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) // CHECK: ret #endif diff --git a/test/OpenMP/for_codegen.cpp b/test/OpenMP/for_codegen.cpp index 5dcacb254d69..30cf484f87a8 100644 --- a/test/OpenMP/for_codegen.cpp +++ b/test/OpenMP/for_codegen.cpp @@ -50,7 +50,7 @@ void without_schedule_clause(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) -// CHECK-NOT: __kmpc_cancel_barrier +// CHECK-NOT: __kmpc_barrier // CHECK: ret void } @@ -91,7 +91,7 @@ void static_not_chunked(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void } @@ -151,7 +151,7 @@ void static_chunked(float *a, float *b, float *c, float *d) { // CHECK: [[O_LOOP1_END]] // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void } @@ -192,7 +192,7 @@ void dynamic1(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: [[O_LOOP1_END]] -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void } @@ -233,7 +233,7 @@ void guided7(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: [[O_LOOP1_END]] -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void } @@ -278,7 +278,7 @@ void test_auto(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: [[O_LOOP1_END]] -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void } @@ -320,7 +320,7 @@ void runtime(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: [[O_LOOP1_END]] -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void } diff --git a/test/OpenMP/for_firstprivate_codegen.cpp b/test/OpenMP/for_firstprivate_codegen.cpp index 2402b501283c..1ef38661a46f 100644 --- a/test/OpenMP/for_firstprivate_codegen.cpp +++ b/test/OpenMP/for_firstprivate_codegen.cpp @@ -82,7 +82,7 @@ int main() { // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, // LAMBDA: [[G_VAL:%.+]] = load volatile i{{[0-9]+}}, i{{[0-9]+}}* [[G]] // LAMBDA: store i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G_PRIVATE_ADDR]] - // LAMBDA: call i32 @__kmpc_cancel_barrier( + // LAMBDA: call void @__kmpc_barrier( g = 1; // LAMBDA: call void @__kmpc_for_static_init_4( // LAMBDA: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], @@ -123,7 +123,7 @@ int main() { // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, // BLOCKS: [[G_VAL:%.+]] = load volatile i{{[0-9]+}}, i{{[0-9]+}}* [[G]] // BLOCKS: store i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G_PRIVATE_ADDR]] - // BLOCKS: call i32 @__kmpc_cancel_barrier( + // BLOCKS: call void @__kmpc_barrier( g = 1; // BLOCKS: call void @__kmpc_for_static_init_4( // BLOCKS: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], @@ -194,7 +194,7 @@ int main() { // CHECK: call {{.*}} [[ST_TY_DESTR]]([[ST_TY]]* [[ST_TY_TEMP]]) // Synchronization for initialization. -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) +// CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) // CHECK: call void @__kmpc_for_static_init_4( // CHECK: call void @__kmpc_for_static_fini( @@ -202,7 +202,7 @@ int main() { // ~(firstprivate var), ~(firstprivate s_arr) // CHECK-DAG: call {{.*}} [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* [[VAR_PRIV]]) // CHECK-DAG: call {{.*}} [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) +// CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) // CHECK: = call {{.*}}i{{.+}} [[TMAIN_INT:@.+]]() @@ -264,7 +264,7 @@ int main() { // Synchronization for initialization. // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_ADDR]] // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]] -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) +// CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) // CHECK: call void @__kmpc_for_static_init_4( // CHECK: call void @__kmpc_for_static_fini( diff --git a/test/OpenMP/for_private_codegen.cpp b/test/OpenMP/for_private_codegen.cpp index 8fc5fe7a18b0..8172912d04ee 100644 --- a/test/OpenMP/for_private_codegen.cpp +++ b/test/OpenMP/for_private_codegen.cpp @@ -19,9 +19,10 @@ struct S { volatile double g; // CHECK: [[S_FLOAT_TY:%.+]] = type { float } -// CHECK: [[CAP_MAIN_TY:%.+]] = type { i{{[0-9]+}}*, [2 x i{{[0-9]+}}]*, [2 x [[S_FLOAT_TY]]]*, [[S_FLOAT_TY]]* } +// CHECK: [[CAP_MAIN_TY:%.+]] = type { i8 } +// CHECK: type { i8 } // CHECK: [[S_INT_TY:%.+]] = type { i{{[0-9]+}} } -// CHECK: [[CAP_TMAIN_TY:%.+]] = type { i{{[0-9]+}}*, [2 x i{{[0-9]+}}]*, [2 x [[S_INT_TY]]]*, [[S_INT_TY]]* } +// CHECK: [[CAP_TMAIN_TY:%.+]] = type { i8 } template <typename T> T tmain() { S<T> test; @@ -42,10 +43,10 @@ int main() { #ifdef LAMBDA // LAMBDA: [[G:@.+]] = global double // LAMBDA-LABEL: @main - // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]]( + // LAMBDA: call{{.*}} void [[OUTER_LAMBDA:@.+]]( [&]() { // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]]( - // LAMBDA: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* %{{.+}}) + // LAMBDA: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* %{{.+}}) #pragma omp parallel #pragma omp for private(g) for (int i = 0; i < 2; ++i) { @@ -53,12 +54,12 @@ int main() { // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = alloca double, // LAMBDA: store %{{.+}}* [[ARG]], %{{.+}}** [[ARG_REF:%.+]], g = 1; - // LAMBDA: call void @__kmpc_for_static_init_4( + // LAMBDA: call {{.*}}void @__kmpc_for_static_init_4( // LAMBDA: store volatile double 1.0{{.+}}, double* [[G_PRIVATE_ADDR]], // LAMBDA: [[G_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 // LAMBDA: store double* [[G_PRIVATE_ADDR]], double** [[G_PRIVATE_ADDR_REF]] - // LAMBDA: call{{( x86_thiscallcc)?}} void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) - // LAMBDA: call void @__kmpc_for_static_fini( + // LAMBDA: call{{.*}} void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) + // LAMBDA: call {{.*}}void @__kmpc_for_static_fini( [&]() { // LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]]) // LAMBDA: store %{{.+}}* [[ARG_PTR]], %{{.+}}** [[ARG_PTR_REF:%.+]], @@ -74,10 +75,10 @@ int main() { #elif defined(BLOCKS) // BLOCKS: [[G:@.+]] = global double // BLOCKS-LABEL: @main - // BLOCKS: call void {{%.+}}(i8 + // BLOCKS: call {{.*}}void {{%.+}}(i8 ^{ // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* - // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* {{.+}}) + // BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* {{.+}}) #pragma omp parallel #pragma omp for private(g) for (int i = 0; i < 2; ++i) { @@ -85,13 +86,13 @@ int main() { // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = alloca double, // BLOCKS: store %{{.+}}* [[ARG]], %{{.+}}** [[ARG_REF:%.+]], g = 1; - // BLOCKS: call void @__kmpc_for_static_init_4( + // BLOCKS: call {{.*}}void @__kmpc_for_static_init_4( // BLOCKS: store volatile double 1.0{{.+}}, double* [[G_PRIVATE_ADDR]], // BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS: double* [[G_PRIVATE_ADDR]] // BLOCKS-NOT: [[G]]{{[[^:word:]]}} - // BLOCKS: call void {{%.+}}(i8 - // BLOCKS: call void @__kmpc_for_static_fini( + // BLOCKS: call {{.*}}void {{%.+}}(i8 + // BLOCKS: call {{.*}}void @__kmpc_for_static_fini( ^{ // BLOCKS: define {{.+}} void {{@.+}}(i8* g = 2; diff --git a/test/OpenMP/for_simd_codegen.cpp b/test/OpenMP/for_simd_codegen.cpp index 00ec6cb0d6c7..936119201695 100644 --- a/test/OpenMP/for_simd_codegen.cpp +++ b/test/OpenMP/for_simd_codegen.cpp @@ -50,7 +50,7 @@ void simple(float *a, float *b, float *c, float *d) { } // CHECK: [[SIMPLE_LOOP1_END]] // CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) -// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) long long k = get_val(); @@ -101,7 +101,7 @@ void simple(float *a, float *b, float *c, float *d) { // 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 %{{.+}}) +// CHECK: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) int lin = 12; #pragma omp for simd linear(lin : get_val()), linear(g_ptr) @@ -172,7 +172,7 @@ void simple(float *a, float *b, float *c, float *d) { // 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 %{{.+}}) +// CHECK: call void @__kmpc_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) @@ -209,7 +209,7 @@ void simple(float *a, float *b, float *c, float *d) { } // CHECK: [[SIMPLE_LOOP4_END]] // CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) -// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call void @__kmpc_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) @@ -246,7 +246,7 @@ void simple(float *a, float *b, float *c, float *d) { } // CHECK: [[SIMPLE_LOOP5_END]] // CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) -// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) // CHECK-NOT: mul i32 %{{.+}}, 10 #pragma omp for simd @@ -413,7 +413,7 @@ int templ1(T a, T *z) { // 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: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) // CHECK: ret i32 0 // void inst_templ1() { @@ -505,7 +505,7 @@ void iter_simple(IterDouble ia, IterDouble ib, IterDouble ic) { } // CHECK: [[IT_END]] // CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) -// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) // CHECK: ret void } @@ -584,7 +584,7 @@ void collapsed(float *a, float *b, float *c, float *d) { // 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: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) // CHECK: ret void } diff --git a/test/OpenMP/master_codegen.cpp b/test/OpenMP/master_codegen.cpp index 1eb47e4e736d..e6ea21a5cb7b 100644 --- a/test/OpenMP/master_codegen.cpp +++ b/test/OpenMP/master_codegen.cpp @@ -9,7 +9,7 @@ // CHECK: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* } -// CHECK: define void [[FOO:@.+]]() +// CHECK: define {{.*}}void [[FOO:@.+]]() void foo() {} @@ -19,23 +19,23 @@ int main() { // CHECK: [[A_ADDR:%.+]] = alloca i8 char a; -// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:@.+]]) -// CHECK: [[RES:%.+]] = call i32 @__kmpc_master([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +// CHECK: [[GTID:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:@.+]]) +// CHECK: [[RES:%.+]] = call {{.*}}i32 @__kmpc_master([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) // CHECK-NEXT: [[IS_MASTER:%.+]] = icmp ne i32 [[RES]], 0 // CHECK-NEXT: br i1 [[IS_MASTER]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]] // CHECK: [[THEN]] // CHECK-NEXT: store i8 2, i8* [[A_ADDR]] -// CHECK-NEXT: call void @__kmpc_end_master([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +// CHECK-NEXT: call {{.*}}void @__kmpc_end_master([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) // CHECK-NEXT: br label {{%?}}[[EXIT]] // CHECK: [[EXIT]] #pragma omp master a = 2; -// CHECK: [[RES:%.+]] = call i32 @__kmpc_master([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +// CHECK: [[RES:%.+]] = call {{.*}}i32 @__kmpc_master([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) // CHECK-NEXT: [[IS_MASTER:%.+]] = icmp ne i32 [[RES]], 0 // CHECK-NEXT: br i1 [[IS_MASTER]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]] // CHECK: [[THEN]] -// CHECK-NEXT: invoke void [[FOO]]() -// CHECK: call void @__kmpc_end_master([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +// CHECK-NEXT: invoke {{.*}}void [[FOO]]() +// CHECK: call {{.*}}void @__kmpc_end_master([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) // CHECK-NEXT: br label {{%?}}[[EXIT]] // CHECK: [[EXIT]] #pragma omp master diff --git a/test/OpenMP/ordered_codegen.cpp b/test/OpenMP/ordered_codegen.cpp index adc6ff6f862d..768462387a95 100644 --- a/test/OpenMP/ordered_codegen.cpp +++ b/test/OpenMP/ordered_codegen.cpp @@ -53,7 +53,7 @@ void static_not_chunked(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: [[O_LOOP1_END]] -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void } @@ -104,7 +104,7 @@ void dynamic1(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: [[O_LOOP1_END]] -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void } @@ -158,7 +158,7 @@ void test_auto(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: [[O_LOOP1_END]] -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void } @@ -209,7 +209,7 @@ void runtime(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: [[O_LOOP1_END]] -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void } diff --git a/test/OpenMP/parallel_codegen.cpp b/test/OpenMP/parallel_codegen.cpp index 16c9c59d8df9..907d1351356c 100644 --- a/test/OpenMP/parallel_codegen.cpp +++ b/test/OpenMP/parallel_codegen.cpp @@ -34,14 +34,14 @@ int main (int argc, char **argv) { return tmain(argv); } -// CHECK-LABEL: define {{[a-z]*[ ]?i32}} @main({{i32[ ]?[a-z]*}} %argc, i8** %argv) +// CHECK-LABEL: define {{[a-z\_\b]*[ ]?i32}} @main({{i32[ ]?[a-z]*}} %argc, i8** %argv) // CHECK: [[AGG_CAPTURED:%.+]] = alloca %struct.anon // CHECK: [[ARGC_REF:%.+]] = getelementptr inbounds %struct.anon, %struct.anon* [[AGG_CAPTURED]], i32 0, i32 0 // CHECK-NEXT: store i32* {{%[a-z0-9.]+}}, i32** [[ARGC_REF]] // CHECK-NEXT: [[BITCAST:%.+]] = bitcast %struct.anon* [[AGG_CAPTURED]] to i8* -// CHECK-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%ident_t* [[DEF_LOC_2]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon*)* [[OMP_OUTLINED:@.+]] to void (i32*, i32*, ...)*), i8* [[BITCAST]]) +// CHECK-NEXT: call {{.*}}void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%ident_t* [[DEF_LOC_2]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon*)* [[OMP_OUTLINED:@.+]] to void (i32*, i32*, ...)*), i8* [[BITCAST]]) // CHECK-NEXT: [[ARGV:%.+]] = load i8**, i8*** {{%[a-z0-9.]+}} -// CHECK-NEXT: [[RET:%.+]] = call {{[a-z]*[ ]?i32}} [[TMAIN:@.+tmain.+]](i8** [[ARGV]]) +// CHECK-NEXT: [[RET:%.+]] = call {{[a-z\_\b]*[ ]?i32}} [[TMAIN:@.+tmain.+]](i8** [[ARGV]]) // CHECK-NEXT: ret i32 [[RET]] // CHECK-NEXT: } // CHECK-DEBUG-LABEL: define i32 @main(i32 %argc, i8** %argv) @@ -61,7 +61,7 @@ int main (int argc, char **argv) { // CHECK-DEBUG-NEXT: ret i32 [[RET]] // CHECK-DEBUG-NEXT: } -// CHECK: define internal void [[OMP_OUTLINED]](i32* %.global_tid., i32* %.bound_tid., %struct.anon* %__context) +// CHECK: define internal {{.*}}void [[OMP_OUTLINED]](i32* %.global_tid., i32* %.bound_tid., %struct.anon* %__context) // CHECK: #[[FN_ATTRS:[0-9]+]] // CHECK: [[CONTEXT_ADDR:%.+]] = alloca %struct.anon* // CHECK: store %struct.anon* %__context, %struct.anon** [[CONTEXT_ADDR]] @@ -69,10 +69,10 @@ int main (int argc, char **argv) { // CHECK-NEXT: [[ARGC_PTR_REF:%.+]] = getelementptr inbounds %struct.anon, %struct.anon* [[CONTEXT_PTR]], i32 0, i32 0 // CHECK-NEXT: [[ARGC_REF:%.+]] = load i32*, i32** [[ARGC_PTR_REF]] // CHECK-NEXT: [[ARGC:%.+]] = load i32, i32* [[ARGC_REF]] -// CHECK-NEXT: invoke void [[FOO:@.+foo.+]](i32{{[ ]?[a-z]*}} [[ARGC]]) +// CHECK-NEXT: invoke {{.*}}void [[FOO:@.+foo.+]](i32{{[ ]?[a-z]*}} [[ARGC]]) // CHECK: call {{.+}} @__kmpc_cancel_barrier( // CHECK: ret void -// CHECK: call void @{{.+terminate.*|abort}}( +// CHECK: call {{.*}}void @{{.+terminate.*|abort}}( // CHECK-NEXT: unreachable // CHECK-NEXT: } // CHECK-DEBUG: define internal void [[OMP_OUTLINED]](i32* %.global_tid., i32* %.bound_tid., %struct.anon* %__context) @@ -90,17 +90,17 @@ int main (int argc, char **argv) { // CHECK-DEBUG-NEXT: unreachable // CHECK-DEBUG-NEXT: } -// CHECK-DAG: define linkonce_odr void [[FOO]]({{i32[ ]?[a-z]*}} %argc) -// CHECK-DAG: declare void @__kmpc_fork_call(%ident_t*, i32, void (i32*, i32*, ...)*, ...) +// CHECK-DAG: define linkonce_odr {{.*}}void [[FOO]]({{i32[ ]?[a-z]*}} %argc) +// CHECK-DAG: declare {{.*}}void @__kmpc_fork_call(%ident_t*, i32, void (i32*, i32*, ...)*, ...) // CHECK-DEBUG-DAG: define linkonce_odr void [[FOO]](i32 %argc) // CHECK-DEBUG-DAG: declare void @__kmpc_fork_call(%ident_t*, i32, void (i32*, i32*, ...)*, ...) -// CHECK: define linkonce_odr {{[a-z]*[ ]?i32}} [[TMAIN]](i8** %argc) +// CHECK: define linkonce_odr {{[a-z\_\b]*[ ]?i32}} [[TMAIN]](i8** %argc) // CHECK: [[AGG_CAPTURED:%.+]] = alloca %struct.anon.0 // CHECK: [[ARGC_REF:%.+]] = getelementptr inbounds %struct.anon.0, %struct.anon.0* [[AGG_CAPTURED]], i32 0, i32 0 // CHECK-NEXT: store i8*** {{%[a-z0-9.]+}}, i8**** [[ARGC_REF]] // CHECK-NEXT: [[BITCAST:%.+]] = bitcast %struct.anon.0* [[AGG_CAPTURED]] to i8* -// CHECK-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%ident_t* [[DEF_LOC_2]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon.0*)* [[OMP_OUTLINED:@.+]] to void (i32*, i32*, ...)*), i8* [[BITCAST]]) +// CHECK-NEXT: call {{.*}}void (%ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%ident_t* [[DEF_LOC_2]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon.0*)* [[OMP_OUTLINED:@.+]] to void (i32*, i32*, ...)*), i8* [[BITCAST]]) // CHECK-NEXT: ret i32 0 // CHECK-NEXT: } // CHECK-DEBUG: define linkonce_odr i32 [[TMAIN]](i8** %argc) @@ -118,17 +118,17 @@ int main (int argc, char **argv) { // CHECK-DEBUG-NEXT: ret i32 0 // CHECK-DEBUG-NEXT: } -// CHECK: define internal void [[OMP_OUTLINED]](i32* %.global_tid., i32* %.bound_tid., %struct.anon.0* %__context) +// CHECK: define internal {{.*}}void [[OMP_OUTLINED]](i32* %.global_tid., i32* %.bound_tid., %struct.anon.0* %__context) // CHECK: [[CONTEXT_ADDR:%.+]] = alloca %struct.anon.0* // CHECK: store %struct.anon.0* %__context, %struct.anon.0** [[CONTEXT_ADDR]] // CHECK: [[CONTEXT_PTR:%.+]] = load %struct.anon.0*, %struct.anon.0** [[CONTEXT_ADDR]] // CHECK-NEXT: [[ARGC_PTR_REF:%.+]] = getelementptr inbounds %struct.anon.0, %struct.anon.0* [[CONTEXT_PTR]], i32 0, i32 0 // CHECK-NEXT: [[ARGC_REF:%.+]] = load i8***, i8**** [[ARGC_PTR_REF]] // CHECK-NEXT: [[ARGC:%.+]] = load i8**, i8*** [[ARGC_REF]] -// CHECK-NEXT: invoke void [[FOO1:@.+foo.+]](i8** [[ARGC]]) +// CHECK-NEXT: invoke {{.*}}void [[FOO1:@.+foo.+]](i8** [[ARGC]]) // CHECK: call {{.+}} @__kmpc_cancel_barrier( // CHECK: ret void -// CHECK: call void @{{.+terminate.*|abort}}( +// CHECK: call {{.*}}void @{{.+terminate.*|abort}}( // CHECK-NEXT: unreachable // CHECK-NEXT: } // CHECK-DEBUG: define internal void [[OMP_OUTLINED]](i32* %.global_tid., i32* %.bound_tid., %struct.anon.0* %__context) @@ -145,7 +145,7 @@ int main (int argc, char **argv) { // CHECK-DEBUG-NEXT: unreachable // CHECK-DEBUG-NEXT: } -// CHECK: define linkonce_odr void [[FOO1]](i8** %argc) +// CHECK: define linkonce_odr {{.*}}void [[FOO1]](i8** %argc) // CHECK-DEBUG: define linkonce_odr void [[FOO1]](i8** %argc) // CHECK: attributes #[[FN_ATTRS]] = {{.+}} nounwind diff --git a/test/OpenMP/parallel_copyin_codegen.cpp b/test/OpenMP/parallel_copyin_codegen.cpp index e69ace7820b6..dd0a9b621fca 100644 --- a/test/OpenMP/parallel_copyin_codegen.cpp +++ b/test/OpenMP/parallel_copyin_codegen.cpp @@ -58,16 +58,16 @@ int main() { #ifdef LAMBDA // LAMBDA: [[G:@.+]] = global i{{[0-9]+}} 1212, // LAMBDA-LABEL: @main - // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]]( + // LAMBDA: call{{.*}} void [[OUTER_LAMBDA:@.+]]( [&]() { // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]]( - // LAMBDA: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* + // LAMBDA: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* #pragma omp parallel copyin(g) { // LAMBDA: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* %{{.+}}, i32* %{{.+}}, %{{.+}}* [[ARG:%.+]]) // threadprivate_g = g; - // LAMBDA: call i8* @__kmpc_threadprivate_cached({{.+}} [[G]] + // LAMBDA: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[G]] // LAMBDA: ptrtoint i{{[0-9]+}}* %{{.+}} to i{{[0-9]+}} // LAMBDA: icmp ne i{{[0-9]+}} ptrtoint (i{{[0-9]+}}* [[G]] to i{{[0-9]+}}), %{{.+}} // LAMBDA: br i1 %{{.+}}, label %[[NOT_MASTER:.+]], label %[[DONE:.+]] @@ -76,9 +76,9 @@ int main() { // LAMBDA: store volatile i{{[0-9]+}} %{{.+}}, i{{[0-9]+}}* %{{.+}}, // LAMBDA: [[DONE]] - // LAMBDA: call i32 @__kmpc_cancel_barrier( + // LAMBDA: call {{.*}}i32 @__kmpc_cancel_barrier( g = 1; - // LAMBDA: call{{( x86_thiscallcc)?}} void [[INNER_LAMBDA:@.+]](%{{.+}}* + // LAMBDA: call{{.*}} void [[INNER_LAMBDA:@.+]](%{{.+}}* [&]() { // LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]]) // LAMBDA: store %{{.+}}* [[ARG_PTR]], %{{.+}}** [[ARG_PTR_REF:%.+]], @@ -91,16 +91,16 @@ int main() { #elif defined(BLOCKS) // BLOCKS: [[G:@.+]] = global i{{[0-9]+}} 1212, // BLOCKS-LABEL: @main - // BLOCKS: call void {{%.+}}(i8 + // BLOCKS: call {{.*}}void {{%.+}}(i8 ^{ // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* - // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* + // BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* #pragma omp parallel copyin(g) { // BLOCKS: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* %{{.+}}, i32* %{{.+}}, %{{.+}}* [[ARG:%.+]]) // threadprivate_g = g; - // BLOCKS: call i8* @__kmpc_threadprivate_cached({{.+}} [[G]] + // BLOCKS: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[G]] // BLOCKS: ptrtoint i{{[0-9]+}}* %{{.+}} to i{{[0-9]+}} // BLOCKS: icmp ne i{{[0-9]+}} ptrtoint (i{{[0-9]+}}* [[G]] to i{{[0-9]+}}), %{{.+}} // BLOCKS: br i1 %{{.+}}, label %[[NOT_MASTER:.+]], label %[[DONE:.+]] @@ -109,16 +109,16 @@ int main() { // BLOCKS: store volatile i{{[0-9]+}} %{{.+}}, i{{[0-9]+}}* %{{.+}}, // BLOCKS: [[DONE]] - // BLOCKS: call i32 @__kmpc_cancel_barrier( + // BLOCKS: call {{.*}}i32 @__kmpc_cancel_barrier( g = 1; // BLOCKS: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* // BLOCKS-NOT: [[G]]{{[[^:word:]]}} - // BLOCKS: call void {{%.+}}(i8 + // BLOCKS: call {{.*}}void {{%.+}}(i8 ^{ // BLOCKS: define {{.+}} void {{@.+}}(i8* g = 2; // BLOCKS-NOT: [[G]]{{[[^:word:]]}} - // BLOCKS: call i8* @__kmpc_threadprivate_cached({{.+}} [[G]] + // BLOCKS: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[G]] // BLOCKS: store volatile i{{[0-9]+}} 2, i{{[0-9]+}}* // BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS: ret @@ -148,19 +148,19 @@ int main() { // CHECK-LABEL: @main // CHECK: [[TEST:%.+]] = alloca [[S_FLOAT_TY]], // CHECK: call {{.*}} [[S_FLOAT_TY_COPY_ASSIGN:@.+]]([[S_FLOAT_TY]]* [[TEST]], [[S_FLOAT_TY]]* -// CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, {{%.+}}*)* [[MAIN_MICROTASK:@.+]] to void (i32*, i32*, ...)*), i8* %{{.+}}) -// CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, {{%.+}}*)* [[MAIN_MICROTASK1:@.+]] to void (i32*, i32*, ...)*), i8* %{{.+}}) +// CHECK: call {{.*}}void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, {{%.+}}*)* [[MAIN_MICROTASK:@.+]] to void (i32*, i32*, ...)*), i8* %{{.+}}) +// CHECK: call {{.*}}void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, {{%.+}}*)* [[MAIN_MICROTASK1:@.+]] to void (i32*, i32*, ...)*), i8* %{{.+}}) // CHECK: = call {{.*}}i{{.+}} [[TMAIN_INT:@.+]]() // CHECK: call {{.*}} [[S_FLOAT_TY_DESTR:@.+]]([[S_FLOAT_TY]]* // CHECK: ret // -// CHECK: define internal void [[MAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, {{%.+}}* %{{.+}}) +// CHECK: define internal {{.*}}void [[MAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, {{%.+}}* %{{.+}}) // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]], // CHECK: [[GTID_ADDR:%.+]] = load i32*, i32** [[GTID_ADDR_ADDR]], // CHECK: [[GTID:%.+]] = load i32, i32* [[GTID_ADDR]], // threadprivate_t_var = t_var; -// CHECK: call i8* @__kmpc_threadprivate_cached({{.+}} [[T_VAR]] +// CHECK: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[T_VAR]] // CHECK: ptrtoint i{{[0-9]+}}* %{{.+}} to i{{[0-9]+}} // CHECK: icmp ne i{{[0-9]+}} ptrtoint (i{{[0-9]+}}* [[T_VAR]] to i{{[0-9]+}}), %{{.+}} // CHECK: br i1 %{{.+}}, label %[[NOT_MASTER:.+]], label %[[DONE:.+]] @@ -169,11 +169,11 @@ int main() { // CHECK: store i{{[0-9]+}} %{{.+}}, i{{[0-9]+}}* %{{.+}}, // threadprivate_vec = vec; -// CHECK: call i8* @__kmpc_threadprivate_cached({{.+}} [[VEC]] +// CHECK: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[VEC]] // CHECK: call void @llvm.memcpy{{.*}}(i8* %{{.+}}, i8* bitcast ([2 x i{{[0-9]+}}]* [[VEC]] to i8*), // threadprivate_s_arr = s_arr; -// CHECK: call i8* @__kmpc_threadprivate_cached({{.+}} [[S_ARR]] +// CHECK: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[S_ARR]] // CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* {{%.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0 // CHECK: [[S_ARR_PRIV_END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[S_ARR_PRIV_BEGIN]], i{{[0-9]+}} 2 // CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[S_ARR_PRIV_BEGIN]], [[S_ARR_PRIV_END]] @@ -183,20 +183,20 @@ int main() { // CHECK: br i1 {{.+}}, label %{{.+}}, label %[[S_ARR_BODY]] // threadprivate_var = var; -// CHECK: call i8* @__kmpc_threadprivate_cached({{.+}} [[VAR]] +// CHECK: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[VAR]] // CHECK: call {{.*}} [[S_FLOAT_TY_COPY_ASSIGN]]([[S_FLOAT_TY]]* {{%.+}}, [[S_FLOAT_TY]]* {{.*}}[[VAR]]) // CHECK: [[DONE]] -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.*}}i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void -// CHECK: define internal void [[MAIN_MICROTASK1]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, {{%.+}}* %{{.+}}) +// CHECK: define internal {{.*}}void [[MAIN_MICROTASK1]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, {{%.+}}* %{{.+}}) // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]], // CHECK: [[GTID_ADDR:%.+]] = load i32*, i32** [[GTID_ADDR_ADDR]], // CHECK: [[GTID:%.+]] = load i32, i32* [[GTID_ADDR]], // threadprivate_t_var = t_var; -// CHECK: call i8* @__kmpc_threadprivate_cached({{.+}} [[T_VAR]] +// CHECK: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[T_VAR]] // CHECK: ptrtoint i{{[0-9]+}}* %{{.+}} to i{{[0-9]+}} // CHECK: icmp ne i{{[0-9]+}} ptrtoint (i{{[0-9]+}}* [[T_VAR]] to i{{[0-9]+}}), %{{.+}} // CHECK: br i1 %{{.+}}, label %[[NOT_MASTER:.+]], label %[[DONE:.+]] @@ -205,24 +205,24 @@ int main() { // CHECK: store i{{[0-9]+}} %{{.+}}, i{{[0-9]+}}* %{{.+}}, // CHECK: [[DONE]] -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.*}}i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void // CHECK: define {{.*}} i{{[0-9]+}} [[TMAIN_INT]]() // CHECK: [[TEST:%.+]] = alloca [[S_INT_TY]], // CHECK: call {{.*}} [[S_INT_TY_COPY_ASSIGN:@.+]]([[S_INT_TY]]* [[TEST]], [[S_INT_TY]]* -// CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, {{%.+}}*)* [[TMAIN_MICROTASK:@.+]] to void (i32*, i32*, ...)*), i8* %{{.+}}) -// CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, {{%.+}}*)* [[TMAIN_MICROTASK1:@.+]] to void (i32*, i32*, ...)*), i8* %{{.+}}) +// CHECK: call {{.*}}void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, {{%.+}}*)* [[TMAIN_MICROTASK:@.+]] to void (i32*, i32*, ...)*), i8* %{{.+}}) +// CHECK: call {{.*}}void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, {{%.+}}*)* [[TMAIN_MICROTASK1:@.+]] to void (i32*, i32*, ...)*), i8* %{{.+}}) // CHECK: call {{.*}} [[S_INT_TY_DESTR:@.+]]([[S_INT_TY]]* // CHECK: ret // -// CHECK: define internal void [[TMAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, {{%.+}}* %{{.+}}) +// CHECK: define internal {{.*}}void [[TMAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, {{%.+}}* %{{.+}}) // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]], // CHECK: [[GTID_ADDR:%.+]] = load i32*, i32** [[GTID_ADDR_ADDR]], // CHECK: [[GTID:%.+]] = load i32, i32* [[GTID_ADDR]], // threadprivate_t_var = t_var; -// CHECK: call i8* @__kmpc_threadprivate_cached({{.+}} [[TMAIN_T_VAR]] +// CHECK: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[TMAIN_T_VAR]] // CHECK: ptrtoint i{{[0-9]+}}* %{{.+}} to i{{[0-9]+}} // CHECK: icmp ne i{{[0-9]+}} ptrtoint (i{{[0-9]+}}* [[TMAIN_T_VAR]] to i{{[0-9]+}}), %{{.+}} // CHECK: br i1 %{{.+}}, label %[[NOT_MASTER:.+]], label %[[DONE:.+]] @@ -231,11 +231,11 @@ int main() { // CHECK: store i{{[0-9]+}} %{{.+}}, i{{[0-9]+}}* %{{.+}}, // threadprivate_vec = vec; -// CHECK: call i8* @__kmpc_threadprivate_cached({{.+}} [[TMAIN_VEC]] -// CHECK: call void @llvm.memcpy{{.*}}(i8* %{{.+}}, i8* bitcast ([2 x i{{[0-9]+}}]* [[TMAIN_VEC]] to i8*), +// CHECK: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[TMAIN_VEC]] +// CHECK: call {{.*}}void @llvm.memcpy{{.*}}(i8* %{{.+}}, i8* bitcast ([2 x i{{[0-9]+}}]* [[TMAIN_VEC]] to i8*), // threadprivate_s_arr = s_arr; -// CHECK: call i8* @__kmpc_threadprivate_cached({{.+}} [[TMAIN_S_ARR]] +// CHECK: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[TMAIN_S_ARR]] // CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_INT_TY]]], [2 x [[S_INT_TY]]]* {{%.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0 // CHECK: [[S_ARR_PRIV_END:%.+]] = getelementptr [[S_INT_TY]], [[S_INT_TY]]* [[S_ARR_PRIV_BEGIN]], i{{[0-9]+}} 2 // CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_INT_TY]]* [[S_ARR_PRIV_BEGIN]], [[S_ARR_PRIV_END]] @@ -245,20 +245,20 @@ int main() { // CHECK: br i1 {{.+}}, label %{{.+}}, label %[[S_ARR_BODY]] // threadprivate_var = var; -// CHECK: call i8* @__kmpc_threadprivate_cached({{.+}} [[TMAIN_VAR]] +// CHECK: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[TMAIN_VAR]] // CHECK: call {{.*}} [[S_INT_TY_COPY_ASSIGN]]([[S_INT_TY]]* {{%.+}}, [[S_INT_TY]]* {{.*}}[[TMAIN_VAR]]) // CHECK: [[DONE]] -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.*}}i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void -// CHECK: define internal void [[TMAIN_MICROTASK1]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, {{%.+}}* %{{.+}}) +// CHECK: define internal {{.*}}void [[TMAIN_MICROTASK1]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, {{%.+}}* %{{.+}}) // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]], // CHECK: [[GTID_ADDR:%.+]] = load i32*, i32** [[GTID_ADDR_ADDR]], // CHECK: [[GTID:%.+]] = load i32, i32* [[GTID_ADDR]], // threadprivate_t_var = t_var; -// CHECK: call i8* @__kmpc_threadprivate_cached({{.+}} [[TMAIN_T_VAR]] +// CHECK: call {{.*}}i8* @__kmpc_threadprivate_cached({{.+}} [[TMAIN_T_VAR]] // CHECK: ptrtoint i{{[0-9]+}}* %{{.+}} to i{{[0-9]+}} // CHECK: icmp ne i{{[0-9]+}} ptrtoint (i{{[0-9]+}}* [[TMAIN_T_VAR]] to i{{[0-9]+}}), %{{.+}} // CHECK: br i1 %{{.+}}, label %[[NOT_MASTER:.+]], label %[[DONE:.+]] @@ -267,7 +267,7 @@ int main() { // CHECK: store i{{[0-9]+}} %{{.+}}, i{{[0-9]+}}* %{{.+}}, // CHECK: [[DONE]] -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) +// CHECK: call {{.*}}i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]]) // CHECK: ret void #endif diff --git a/test/OpenMP/parallel_firstprivate_codegen.cpp b/test/OpenMP/parallel_firstprivate_codegen.cpp index 3f61362a3d97..760b96171abc 100644 --- a/test/OpenMP/parallel_firstprivate_codegen.cpp +++ b/test/OpenMP/parallel_firstprivate_codegen.cpp @@ -56,13 +56,13 @@ int main() { #ifdef LAMBDA // LAMBDA: [[G:@.+]] = global i{{[0-9]+}} 1212, // LAMBDA-LABEL: @main - // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]]( + // LAMBDA: call{{.*}} void [[OUTER_LAMBDA:@.+]]( [&]() { // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]]( // LAMBDA: [[G_LOCAL_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[AGG_CAPTURED:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 // LAMBDA: store i{{[0-9]+}}* [[G]], i{{[0-9]+}}** [[G_LOCAL_REF]] // LAMBDA: [[ARG:%.+]] = bitcast %{{.+}}* [[AGG_CAPTURED]] to i8* - // LAMBDA: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* [[ARG]]) + // LAMBDA: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* [[ARG]]) #pragma omp parallel firstprivate(g) { // LAMBDA: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* %{{.+}}, i32* %{{.+}}, %{{.+}}* [[ARG:%.+]]) @@ -73,12 +73,12 @@ int main() { // LAMBDA: [[G_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[G_REF_ADDR]] // LAMBDA: [[G_VAL:%.+]] = load volatile i{{[0-9]+}}, i{{[0-9]+}}* [[G_REF]] // LAMBDA: store i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G_PRIVATE_ADDR]] - // LAMBDA: call i32 @__kmpc_cancel_barrier( + // LAMBDA: call {{.*}}i32 @__kmpc_cancel_barrier( g = 1; // LAMBDA: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], // LAMBDA: [[G_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 // LAMBDA: store i{{[0-9]+}}* [[G_PRIVATE_ADDR]], i{{[0-9]+}}** [[G_PRIVATE_ADDR_REF]] - // LAMBDA: call{{( x86_thiscallcc)?}} void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) + // LAMBDA: call{{.*}} void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) [&]() { // LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]]) // LAMBDA: store %{{.+}}* [[ARG_PTR]], %{{.+}}** [[ARG_PTR_REF:%.+]], @@ -94,13 +94,13 @@ int main() { #elif defined(BLOCKS) // BLOCKS: [[G:@.+]] = global i{{[0-9]+}} 1212, // BLOCKS-LABEL: @main - // BLOCKS: call void {{%.+}}(i8 + // BLOCKS: call {{.*}}void {{%.+}}(i8 ^{ // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: [[G_LOCAL_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[AGG_CAPTURED:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 // BLOCKS: store i{{[0-9]+}}* [[G]], i{{[0-9]+}}** [[G_LOCAL_REF]] // BLOCKS: [[ARG:%.+]] = bitcast %{{.+}}* [[AGG_CAPTURED]] to i8* - // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* [[ARG]]) + // BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* [[ARG]]) #pragma omp parallel firstprivate(g) { // BLOCKS: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* %{{.+}}, i32* %{{.+}}, %{{.+}}* [[ARG:%.+]]) @@ -111,13 +111,13 @@ int main() { // BLOCKS: [[G_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[G_REF_ADDR]] // BLOCKS: [[G_VAL:%.+]] = load volatile i{{[0-9]+}}, i{{[0-9]+}}* [[G_REF]] // BLOCKS: store i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G_PRIVATE_ADDR]] - // BLOCKS: call i32 @__kmpc_cancel_barrier( + // BLOCKS: call {{.*}}i32 @__kmpc_cancel_barrier( g = 1; // BLOCKS: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], // BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS: i{{[0-9]+}}* [[G_PRIVATE_ADDR]] // BLOCKS-NOT: [[G]]{{[[^:word:]]}} - // BLOCKS: call void {{%.+}}(i8 + // BLOCKS: call {{.*}}void {{%.+}}(i8 ^{ // BLOCKS: define {{.+}} void {{@.+}}(i8* g = 2; @@ -150,12 +150,12 @@ int main() { // CHECK: [[TEST:%.+]] = alloca [[S_FLOAT_TY]], // CHECK: call {{.*}} [[S_FLOAT_TY_DEF_CONSTR:@.+]]([[S_FLOAT_TY]]* [[TEST]]) // CHECK: %{{.+}} = bitcast [[CAP_MAIN_TY]]* -// CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [[CAP_MAIN_TY]]*)* [[MAIN_MICROTASK:@.+]] to void +// CHECK: call {{.*}}void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [[CAP_MAIN_TY]]*)* [[MAIN_MICROTASK:@.+]] to void // CHECK: = call {{.*}}i{{.+}} [[TMAIN_INT:@.+]]() // CHECK: call {{.*}} [[S_FLOAT_TY_DESTR:@.+]]([[S_FLOAT_TY]]* // CHECK: ret // -// CHECK: define internal void [[MAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, [[CAP_MAIN_TY]]* %{{.+}}) +// CHECK: define internal {{.*}}void [[MAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, [[CAP_MAIN_TY]]* %{{.+}}) // CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}}, // CHECK: [[VEC_PRIV:%.+]] = alloca [2 x i{{[0-9]+}}], // CHECK: [[S_ARR_PRIV:%.+]] = alloca [2 x [[S_FLOAT_TY]]], @@ -189,7 +189,7 @@ int main() { // CHECK: call {{.*}} [[ST_TY_DESTR]]([[ST_TY]]* [[ST_TY_TEMP]]) // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_ADDR]] // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]] -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) +// CHECK: call {{.*}}i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) // CHECK-DAG: call {{.*}} [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* [[VAR_PRIV]]) // CHECK-DAG: call {{.*}} [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* // CHECK: ret void @@ -197,11 +197,11 @@ int main() { // CHECK: define {{.*}} i{{[0-9]+}} [[TMAIN_INT]]() // CHECK: [[TEST:%.+]] = alloca [[S_INT_TY]], // CHECK: call {{.*}} [[S_INT_TY_DEF_CONSTR:@.+]]([[S_INT_TY]]* [[TEST]]) -// CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [[CAP_TMAIN_TY]]*)* [[TMAIN_MICROTASK:@.+]] to void +// CHECK: call {{.*}}void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [[CAP_TMAIN_TY]]*)* [[TMAIN_MICROTASK:@.+]] to void // CHECK: call {{.*}} [[S_INT_TY_DESTR:@.+]]([[S_INT_TY]]* // CHECK: ret // -// CHECK: define internal void [[TMAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, [[CAP_TMAIN_TY]]* %{{.+}}) +// CHECK: define internal {{.*}}void [[TMAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, [[CAP_TMAIN_TY]]* %{{.+}}) // CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}}, // CHECK: [[VEC_PRIV:%.+]] = alloca [2 x i{{[0-9]+}}], // CHECK: [[S_ARR_PRIV:%.+]] = alloca [2 x [[S_INT_TY]]], @@ -235,7 +235,7 @@ int main() { // CHECK: call {{.*}} [[ST_TY_DESTR]]([[ST_TY]]* [[ST_TY_TEMP]]) // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_ADDR]] // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]] -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) +// CHECK: call {{.*}}i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) // CHECK-DAG: call {{.*}} [[S_INT_TY_DESTR]]([[S_INT_TY]]* [[VAR_PRIV]]) // CHECK-DAG: call {{.*}} [[S_INT_TY_DESTR]]([[S_INT_TY]]* // CHECK: ret void diff --git a/test/OpenMP/parallel_for_codegen.cpp b/test/OpenMP/parallel_for_codegen.cpp index 6262e761e0da..2a387d9dc376 100644 --- a/test/OpenMP/parallel_for_codegen.cpp +++ b/test/OpenMP/parallel_for_codegen.cpp @@ -27,7 +27,7 @@ void with_var_schedule() { // CHECK: [[CHUNK_SIZE:%.+]] = sext i8 [[CHUNK_VAL]] to i64 // CHECK: call void @__kmpc_for_static_init_8u([[IDENT_T_TY]]* [[DEFAULT_LOC:@[^,]+]], i32 [[GTID:%[^,]+]], i32 33, i32* [[IS_LAST:%[^,]+]], i64* [[OMP_LB:%[^,]+]], i64* [[OMP_UB:%[^,]+]], i64* [[OMP_ST:%[^,]+]], i64 1, i64 [[CHUNK_SIZE]]) // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) -// CHECK: __kmpc_cancel_barrier +// CHECK: __kmpc_barrier #pragma omp parallel for schedule(static, char(a)) for (unsigned long long i = 1; i < 2; ++i) { } @@ -73,7 +73,7 @@ void without_schedule_clause(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) // CHECK: ret void } @@ -117,7 +117,7 @@ void static_not_chunked(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) // CHECK: ret void } @@ -180,7 +180,7 @@ void static_chunked(float *a, float *b, float *c, float *d) { // CHECK: [[O_LOOP1_END]] // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) // CHECK: ret void } @@ -225,7 +225,7 @@ void dynamic1(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: [[O_LOOP1_END]] -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) // CHECK: ret void } @@ -270,7 +270,7 @@ void guided7(float *a, float *b, float *c, float *d) { } // CHECK: [[LOOP1_END]] // CHECK: [[O_LOOP1_END]] -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) // CHECK: ret void } @@ -322,7 +322,7 @@ void test_auto(float *a, float *b, float *c, float *d) { // CHECK: [[O_LOOP1_END]] // CHECK: [[GTID_REF:%.+]] = load i32*, i32** [[GTID_REF_ADDR]], // CHECK: [[GTID:%.+]] = load i32, i32* [[GTID_REF]], -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) // CHECK: ret void } @@ -369,7 +369,7 @@ void runtime(float *a, float *b, float *c, float *d) { // CHECK: [[O_LOOP1_END]] // CHECK: [[GTID_REF:%.+]] = load i32*, i32** [[GTID_REF_ADDR]], // CHECK: [[GTID:%.+]] = load i32, i32* [[GTID_REF]], -// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) // CHECK: ret void } @@ -386,14 +386,14 @@ void parallel_for(float *a) { // TERM_DEBUG: unwind label %[[TERM_LPAD:.+]], // TERM_DEBUG-NOT: __kmpc_global_thread_num // TERM_DEBUG: call void @__kmpc_for_static_fini({{.+}}), !dbg [[DBG_LOC_END:![0-9]+]] - // TERM_DEBUG: call {{.+}} @__kmpc_cancel_barrier({{.+}}), !dbg [[DBG_LOC_CANCEL:![0-9]+]] + // TERM_DEBUG: call {{.+}} @__kmpc_barrier({{.+}}), !dbg [[DBG_LOC_CANCEL:![0-9]+]] // 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({{.+}}) + // CLEANUP: call {{.+}} @__kmpc_barrier({{.+}}) for (unsigned i = 131071; i <= 2147483647; i += 127) a[i] += foo(); } diff --git a/test/OpenMP/parallel_for_simd_codegen.cpp b/test/OpenMP/parallel_for_simd_codegen.cpp index 3490b8fb1688..adde4242014f 100644 --- a/test/OpenMP/parallel_for_simd_codegen.cpp +++ b/test/OpenMP/parallel_for_simd_codegen.cpp @@ -63,7 +63,7 @@ void simple(float *a, float *b, float *c, float *d) { } // CHECK: [[SIMPLE_LOOP1_END]] // CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) -// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) long long k = get_val(); @@ -112,7 +112,7 @@ void simple(float *a, float *b, float *c, float *d) { // 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 %{{.+}}) +// CHECK: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) int lin = 12; #pragma omp parallel for simd linear(lin : get_val()), linear(g_ptr) @@ -186,7 +186,7 @@ void simple(float *a, float *b, float *c, float *d) { // 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 %{{.+}}) +// CHECK: call void @__kmpc_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) @@ -223,7 +223,7 @@ void simple(float *a, float *b, float *c, float *d) { } // CHECK: [[SIMPLE_LOOP4_END]] // CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) -// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call void @__kmpc_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) @@ -260,7 +260,7 @@ void simple(float *a, float *b, float *c, float *d) { } // CHECK: [[SIMPLE_LOOP5_END]] // CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) -// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) // CHECK-NOT: mul i32 %{{.+}}, 10 #pragma omp parallel for simd @@ -315,7 +315,7 @@ void simple(float *a, float *b, float *c, float *d) { // 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 %{{.+}}) +// CHECK: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) } int R; { @@ -364,7 +364,7 @@ void simple(float *a, float *b, float *c, float *d) { // 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 %{{.+}}) +// CHECK: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) } } @@ -473,7 +473,7 @@ void iter_simple(IterDouble ia, IterDouble ib, IterDouble ic) { } // CHECK: [[IT_END]] // CHECK: call void @__kmpc_for_static_fini(%ident_t* {{.+}}, i32 %{{.+}}) -// CHECK: call i32 @__kmpc_cancel_barrier(%ident_t* {{.+}}, i32 %{{.+}}) +// CHECK: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) // CHECK: ret void } @@ -552,7 +552,7 @@ void collapsed(float *a, float *b, float *c, float *d) { // 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: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) // CHECK: ret void } @@ -672,7 +672,7 @@ void widened(float *a, float *b, float *c, float *d) { // 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: call void @__kmpc_barrier(%ident_t* {{.+}}, i32 %{{.+}}) // CHECK: ret void // // TERM_DEBUG-LABEL: bar diff --git a/test/OpenMP/parallel_if_codegen.cpp b/test/OpenMP/parallel_if_codegen.cpp index 3461743221e0..ace20ecd8317 100644 --- a/test/OpenMP/parallel_if_codegen.cpp +++ b/test/OpenMP/parallel_if_codegen.cpp @@ -14,27 +14,27 @@ void fn6(); int Arg; -// CHECK-LABEL: define void @{{.+}}gtid_test +// CHECK-LABEL: define {{.*}}void @{{.+}}gtid_test void gtid_test() { -// CHECK: call void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, {{.+}}* [[GTID_TEST_REGION1:@.+]] to void +// CHECK: call {{.*}}void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, {{.+}}* [[GTID_TEST_REGION1:@.+]] to void #pragma omp parallel #pragma omp parallel if (false) gtid_test(); // CHECK: ret void } -// CHECK: define internal void [[GTID_TEST_REGION1]](i{{.+}}* [[GTID_PARAM:%.+]], i +// CHECK: define internal {{.*}}void [[GTID_TEST_REGION1]](i{{.+}}* [[GTID_PARAM:%.+]], i // CHECK: store i{{[0-9]+}}* [[GTID_PARAM]], i{{[0-9]+}}** [[GTID_ADDR_REF:%.+]], // CHECK: [[GTID_ADDR:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_REF]] // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_ADDR]] -// CHECK: call void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]]) +// CHECK: call {{.*}}void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]]) // CHECK: [[GTID_ADDR:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_REF]] // CHECK: call void [[GTID_TEST_REGION2:@.+]](i{{[0-9]+}}* [[GTID_ADDR]] -// CHECK: call void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]]) +// CHECK: call {{.*}}void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]]) // CHECK: ret void -// CHECK: define internal void [[GTID_TEST_REGION2]]( -// CHECK: call void @{{.+}}gtid_test +// CHECK: define internal {{.*}}void [[GTID_TEST_REGION2]]( +// CHECK: call {{.*}}void @{{.+}}gtid_test // CHECK: ret void template <typename T> @@ -50,26 +50,26 @@ int tmain(T Arg) { // CHECK-LABEL: define {{.*}}i{{[0-9]+}} @main() int main() { -// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num( -// CHECK: call void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, void {{.+}}* [[CAP_FN4:@.+]] to void +// CHECK: [[GTID:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num( +// CHECK: call {{.*}}void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, void {{.+}}* [[CAP_FN4:@.+]] to void #pragma omp parallel if (true) fn4(); -// CHECK: call void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: call {{.*}}void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) // CHECK: store i32 [[GTID]], i32* [[GTID_ADDR:%.+]], // CHECK: call void [[CAP_FN5:@.+]](i32* [[GTID_ADDR]], -// CHECK: call void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: call {{.*}}void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) #pragma omp parallel if (false) fn5(); // CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]] // CHECK: [[OMP_THEN]] -// CHECK: call void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, void {{.+}}* [[CAP_FN6:@.+]] to void +// CHECK: call {{.*}}void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, void {{.+}}* [[CAP_FN6:@.+]] to void // CHECK: br label %[[OMP_END:.+]] // CHECK: [[OMP_ELSE]] -// CHECK: call void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: call {{.*}}void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) // CHECK: store i32 [[GTID]], i32* [[GTID_ADDR:%.+]], // CHECK: call void [[CAP_FN6]](i32* [[GTID_ADDR]], -// CHECK: call void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: call {{.*}}void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) // CHECK: br label %[[OMP_END]] // CHECK: [[OMP_END]] #pragma omp parallel if (Arg) @@ -78,47 +78,47 @@ int main() { return tmain(Arg); } -// CHECK: define internal void [[CAP_FN4]] -// CHECK: call void @{{.+}}fn4 +// CHECK: define internal {{.*}}void [[CAP_FN4]] +// CHECK: call {{.*}}void @{{.+}}fn4 // CHECK: ret void -// CHECK: define internal void [[CAP_FN5]] -// CHECK: call void @{{.+}}fn5 +// CHECK: define internal {{.*}}void [[CAP_FN5]] +// CHECK: call {{.*}}void @{{.+}}fn5 // CHECK: ret void -// CHECK: define internal void [[CAP_FN6]] -// CHECK: call void @{{.+}}fn6 +// CHECK: define internal {{.*}}void [[CAP_FN6]] +// CHECK: call {{.*}}void @{{.+}}fn6 // CHECK: ret void // CHECK-LABEL: define {{.+}} @{{.+}}tmain -// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num( -// CHECK: call void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, void {{.+}}* [[CAP_FN1:@.+]] to void -// CHECK: call void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: [[GTID:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num( +// CHECK: call {{.*}}void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, void {{.+}}* [[CAP_FN1:@.+]] to void +// CHECK: call {{.*}}void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) // CHECK: store i32 [[GTID]], i32* [[GTID_ADDR:%.+]], // CHECK: call void [[CAP_FN2:@.+]](i32* [[GTID_ADDR]], -// CHECK: call void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: call {{.*}}void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) // CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]] // CHECK: [[OMP_THEN]] -// CHECK: call void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, void {{.+}}* [[CAP_FN3:@.+]] to void +// CHECK: call {{.*}}void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, void {{.+}}* [[CAP_FN3:@.+]] to void // CHECK: br label %[[OMP_END:.+]] // CHECK: [[OMP_ELSE]] -// CHECK: call void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: call {{.*}}void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) // CHECK: store i32 [[GTID]], i32* [[GTID_ADDR:%.+]], // CHECK: call void [[CAP_FN3]](i32* [[GTID_ADDR]], -// CHECK: call void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: call {{.*}}void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) // CHECK: br label %[[OMP_END]] // CHECK: [[OMP_END]] -// CHECK: define internal void [[CAP_FN1]] -// CHECK: call void @{{.+}}fn1 +// CHECK: define internal {{.*}}void [[CAP_FN1]] +// CHECK: call {{.*}}void @{{.+}}fn1 // CHECK: ret void -// CHECK: define internal void [[CAP_FN2]] -// CHECK: call void @{{.+}}fn2 +// CHECK: define internal {{.*}}void [[CAP_FN2]] +// CHECK: call {{.*}}void @{{.+}}fn2 // CHECK: ret void -// CHECK: define internal void [[CAP_FN3]] -// CHECK: call void @{{.+}}fn3 +// CHECK: define internal {{.*}}void [[CAP_FN3]] +// CHECK: call {{.*}}void @{{.+}}fn3 // CHECK: ret void #endif diff --git a/test/OpenMP/parallel_num_threads_codegen.cpp b/test/OpenMP/parallel_num_threads_codegen.cpp index 2342c47f0be2..d744e5e87b74 100644 --- a/test/OpenMP/parallel_num_threads_codegen.cpp +++ b/test/OpenMP/parallel_num_threads_codegen.cpp @@ -43,16 +43,16 @@ int main() { // CHECK-LABEL: define {{.*}}i{{[0-9]+}} @main() // CHECK-DAG: [[S_ADDR:%.+]] = alloca [[S_TY]] // CHECK-DAG: [[A_ADDR:%.+]] = alloca i8 -// CHECK-DAG: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEF_LOC_2]]) +// CHECK-DAG: [[GTID:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEF_LOC_2]]) // CHECK-DAG: call {{.*}} [[S_TY_CONSTR:@.+]]([[S_TY]]* [[S_ADDR]], [[INTPTR_T_TY]] [[INTPTR_T_TY_ATTR:(signext )?]]0) // CHECK: [[S_CHAR_OP:%.+]] = invoke{{.*}} i8 [[S_TY_CHAR_OP:@.+]]([[S_TY]]* [[S_ADDR]]) // CHECK: store i8 [[S_CHAR_OP]], i8* [[A_ADDR]] -// CHECK: call void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 2) -// CHECK: call void {{.*}} @__kmpc_fork_call( +// CHECK: call {{.*}}void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 2) +// CHECK: call {{.*}}void {{.*}} @__kmpc_fork_call( // CHECK: [[A_VAL:%.+]] = load i8, i8* [[A_ADDR]] // CHECK: [[RES:%.+]] = sext i8 [[A_VAL]] to i32 -// CHECK: call void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 [[RES]]) -// CHECK: call void {{.*}} @__kmpc_fork_call( +// CHECK: call {{.*}}void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 [[RES]]) +// CHECK: call {{.*}}void {{.*}} @__kmpc_fork_call( // CHECK: invoke{{.*}} [[INT_TY:i[0-9]+]] [[TMAIN_CHAR_5:@.+]]() // CHECK: invoke{{.*}} [[INT_TY]] [[TMAIN_S_1:@.+]]() // CHECK: call {{.*}} [[S_TY_DESTR:@.+]]([[S_TY]]* [[S_ADDR]]) @@ -60,24 +60,24 @@ int main() { // CHECK: } // CHECK: define{{.*}} [[INT_TY]] [[TMAIN_CHAR_5]]() -// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEF_LOC_2]]) -// CHECK: call void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 5) -// CHECK: call void {{.*}} @__kmpc_fork_call( -// CHECK: call void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 23) -// CHECK: call void {{.*}} @__kmpc_fork_call( +// CHECK: [[GTID:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEF_LOC_2]]) +// CHECK: call {{.*}}void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 5) +// CHECK: call {{.*}}void {{.*}} @__kmpc_fork_call( +// CHECK: call {{.*}}void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 23) +// CHECK: call {{.*}}void {{.*}} @__kmpc_fork_call( // CHECK: ret [[INT_TY]] 0 // CHECK-NEXT: } // CHECK: define{{.*}} [[INT_TY]] [[TMAIN_S_1]]() -// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEF_LOC_2]]) -// CHECK: call void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 1) -// CHECK: call void {{.*}} @__kmpc_fork_call( +// CHECK: [[GTID:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEF_LOC_2]]) +// CHECK: call {{.*}}void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 1) +// CHECK: call {{.*}}void {{.*}} @__kmpc_fork_call( // CHECK: call {{.*}} [[S_TY_CONSTR]]([[S_TY]]* [[S_TEMP:%.+]], [[INTPTR_T_TY]] [[INTPTR_T_TY_ATTR]]23) // CHECK: [[S_CHAR_OP:%.+]] = invoke{{.*}} i8 [[S_TY_CHAR_OP]]([[S_TY]]* [[S_TEMP]]) // CHECK: [[RES:%.+]] = sext {{.*}}i8 [[S_CHAR_OP]] to i32 -// CHECK: call void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 [[RES]]) +// CHECK: call {{.*}}void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 [[RES]]) // CHECK: call {{.*}} [[S_TY_DESTR]]([[S_TY]]* [[S_TEMP]]) -// CHECK: call void {{.*}} @__kmpc_fork_call( +// CHECK: call {{.*}}void {{.*}} @__kmpc_fork_call( // CHECK: ret [[INT_TY]] 0 // CHECK: } diff --git a/test/OpenMP/parallel_private_codegen.cpp b/test/OpenMP/parallel_private_codegen.cpp index 99e2d4d404db..55f25c67f063 100644 --- a/test/OpenMP/parallel_private_codegen.cpp +++ b/test/OpenMP/parallel_private_codegen.cpp @@ -19,9 +19,9 @@ struct S { volatile int g = 1212; // CHECK: [[S_FLOAT_TY:%.+]] = type { float } -// CHECK: [[CAP_MAIN_TY:%.+]] = type { [2 x i{{[0-9]+}}]*, i{{[0-9]+}}*, [2 x [[S_FLOAT_TY]]]*, [[S_FLOAT_TY]]* } +// CHECK: [[CAP_MAIN_TY:%.+]] = type { i8 } // CHECK: [[S_INT_TY:%.+]] = type { i{{[0-9]+}} } -// CHECK: [[CAP_TMAIN_TY:%.+]] = type { [2 x i{{[0-9]+}}]*, i{{[0-9]+}}*, [2 x [[S_INT_TY]]]*, [[S_INT_TY]]* } +// CHECK: [[CAP_TMAIN_TY:%.+]] = type { i8 } template <typename T> T tmain() { S<T> test; @@ -41,13 +41,12 @@ int main() { #ifdef LAMBDA // LAMBDA: [[G:@.+]] = global i{{[0-9]+}} 1212, // LAMBDA-LABEL: @main - // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]]( + // LAMBDA: call{{.*}} void [[OUTER_LAMBDA:@.+]]( [&]() { // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]]( - // LAMBDA: [[G_LOCAL_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[AGG_CAPTURED:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 - // LAMBDA: store i{{[0-9]+}}* [[G]], i{{[0-9]+}}** [[G_LOCAL_REF]] - // LAMBDA: [[ARG:%.+]] = bitcast %{{.+}}* [[AGG_CAPTURED]] to i8* - // LAMBDA: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* [[ARG]]) + // LAMBDA-NOT: = getelementptr inbounds %{{.+}}, + // LAMBDA: [[ARG:%.+]] = bitcast %{{.+}}* %{{.+}} to i8* + // LAMBDA: call{{.*}} void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* [[ARG]]) #pragma omp parallel private(g) { // LAMBDA: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* %{{.+}}, i32* %{{.+}}, %{{.+}}* [[ARG:%.+]]) @@ -57,7 +56,7 @@ int main() { // LAMBDA: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], // LAMBDA: [[G_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 // LAMBDA: store i{{[0-9]+}}* [[G_PRIVATE_ADDR]], i{{[0-9]+}}** [[G_PRIVATE_ADDR_REF]] - // LAMBDA: call{{( x86_thiscallcc)?}} void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) + // LAMBDA: call{{.*}} void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) [&]() { // LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]]) // LAMBDA: store %{{.+}}* [[ARG_PTR]], %{{.+}}** [[ARG_PTR_REF:%.+]], @@ -73,13 +72,12 @@ int main() { #elif defined(BLOCKS) // BLOCKS: [[G:@.+]] = global i{{[0-9]+}} 1212, // BLOCKS-LABEL: @main - // BLOCKS: call void {{%.+}}(i8 + // BLOCKS: call{{.*}} void {{%.+}}(i8 ^{ // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* - // BLOCKS: [[G_LOCAL_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[AGG_CAPTURED:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 - // BLOCKS: store i{{[0-9]+}}* [[G]], i{{[0-9]+}}** [[G_LOCAL_REF]] - // BLOCKS: [[ARG:%.+]] = bitcast %{{.+}}* [[AGG_CAPTURED]] to i8* - // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* [[ARG]]) + // BLOCKS-NOT: = getelementptr inbounds %{{.+}}, + // BLOCKS: [[ARG:%.+]] = bitcast %{{.+}}* %{{.+}} to i8* + // BLOCKS: call{{.*}} void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* [[ARG]]) #pragma omp parallel private(g) { // BLOCKS: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* %{{.+}}, i32* %{{.+}}, %{{.+}}* [[ARG:%.+]]) @@ -90,7 +88,7 @@ int main() { // BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS: i{{[0-9]+}}* [[G_PRIVATE_ADDR]] // BLOCKS-NOT: [[G]]{{[[^:word:]]}} - // BLOCKS: call void {{%.+}}(i8 + // BLOCKS: call{{.*}} void {{%.+}}(i8 ^{ // BLOCKS: define {{.+}} void {{@.+}}(i8* g = 2; diff --git a/test/OpenMP/parallel_proc_bind_codegen.cpp b/test/OpenMP/parallel_proc_bind_codegen.cpp index 2a8eaee127ce..34a64de7465d 100644 --- a/test/OpenMP/parallel_proc_bind_codegen.cpp +++ b/test/OpenMP/parallel_proc_bind_codegen.cpp @@ -36,16 +36,16 @@ int main() { } // 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: [[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: [[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: } diff --git a/test/OpenMP/parallel_sections_codegen.cpp b/test/OpenMP/parallel_sections_codegen.cpp index c16cc8d5edd7..ba1bf6cc56a0 100644 --- a/test/OpenMP/parallel_sections_codegen.cpp +++ b/test/OpenMP/parallel_sections_codegen.cpp @@ -73,7 +73,7 @@ int main() { // CHECK: [[INNER_LOOP_END]] } // CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 [[GTID]]) -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], +// CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], return tmain<int>(); } @@ -89,7 +89,7 @@ int main() { // CHECK: call void @__kmpc_end_single( // CHECK-NEXT: br label %[[END]] // CHECK: [[END]] -// CHECK-NEXT: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], +// CHECK-NEXT: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], // CHECK-NEXT: ret // CHECK: [[TERM_LPAD]] // CHECK: call void @__clang_call_terminate(i8* diff --git a/test/OpenMP/sections_codegen.cpp b/test/OpenMP/sections_codegen.cpp index 11cc900fbecf..d25230a79907 100644 --- a/test/OpenMP/sections_codegen.cpp +++ b/test/OpenMP/sections_codegen.cpp @@ -72,7 +72,7 @@ int main() { // CHECK: [[INNER_LOOP_END]] } // CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 [[GTID]]) -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_SECTIONS_LOC]], +// CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_SECTIONS_LOC]], #pragma omp sections nowait { foo(); @@ -96,8 +96,8 @@ int main() { // CHECK-NEXT: br label %[[END]] // CHECK: [[END]] // CHECK-NEXT: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_SINGLE_LOC]], -// CHECK-NEXT: call i32 @__kmpc_cancel_barrier( -// CHECK-NEXT: ret +// CHECK: call i32 @__kmpc_cancel_barrier( +// CHECK: ret // CHECK: [[TERM_LPAD]] // CHECK: call void @__clang_call_terminate(i8* // CHECK-NEXT: unreachable diff --git a/test/OpenMP/sections_firstprivate_codegen.cpp b/test/OpenMP/sections_firstprivate_codegen.cpp index ba49864dda82..4ec16ba02d9b 100644 --- a/test/OpenMP/sections_firstprivate_codegen.cpp +++ b/test/OpenMP/sections_firstprivate_codegen.cpp @@ -84,7 +84,7 @@ int main() { // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, // LAMBDA: [[G_VAL:%.+]] = load volatile i{{[0-9]+}}, i{{[0-9]+}}* [[G]] // LAMBDA: store i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G_PRIVATE_ADDR]] - // LAMBDA: call i32 @__kmpc_cancel_barrier( + // LAMBDA: call void @__kmpc_barrier( g = 1; // LAMBDA: call void @__kmpc_for_static_init_4( // LAMBDA: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], @@ -126,7 +126,7 @@ int main() { // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, // BLOCKS: [[G_VAL:%.+]] = load volatile i{{[0-9]+}}, i{{[0-9]+}}* [[G]] // BLOCKS: store i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G_PRIVATE_ADDR]] - // BLOCKS: call i32 @__kmpc_cancel_barrier( + // BLOCKS: call void @__kmpc_barrier( g = 1; // BLOCKS: call void @__kmpc_for_static_init_4( // BLOCKS: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], @@ -199,7 +199,7 @@ int main() { // CHECK-DAG: call {{.*}} [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* // CHECK: call void @__kmpc_end_single( -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) +// CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) // CHECK: = call {{.*}}i{{.+}} [[TMAIN_INT:@.+]]() @@ -261,7 +261,7 @@ int main() { // Synchronization for initialization. // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_ADDR]] // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]] -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) +// CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) // CHECK: call void @__kmpc_for_static_init_4( // CHECK: call void @__kmpc_for_static_fini( diff --git a/test/OpenMP/sections_private_codegen.cpp b/test/OpenMP/sections_private_codegen.cpp index 4bad714908d2..90331cbd43a9 100644 --- a/test/OpenMP/sections_private_codegen.cpp +++ b/test/OpenMP/sections_private_codegen.cpp @@ -19,9 +19,9 @@ struct S { volatile double g; // CHECK: [[S_FLOAT_TY:%.+]] = type { float } -// CHECK: [[CAP_MAIN_TY:%.+]] = type { i{{[0-9]+}}*, [2 x i{{[0-9]+}}]*, [2 x [[S_FLOAT_TY]]]*, [[S_FLOAT_TY]]* } +// CHECK: [[CAP_MAIN_TY:%.+]] = type { i8 } // CHECK: [[S_INT_TY:%.+]] = type { i{{[0-9]+}} } -// CHECK: [[CAP_TMAIN_TY:%.+]] = type { i{{[0-9]+}}*, [2 x i{{[0-9]+}}]*, [2 x [[S_INT_TY]]]*, [[S_INT_TY]]* } +// CHECK: [[CAP_TMAIN_TY:%.+]] = type { i8 } template <typename T> T tmain() { S<T> test; @@ -43,10 +43,10 @@ int main() { #ifdef LAMBDA // LAMBDA: [[G:@.+]] = global double // LAMBDA-LABEL: @main - // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]]( + // LAMBDA: call{{.*}} void [[OUTER_LAMBDA:@.+]]( [&]() { // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]]( - // LAMBDA: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* %{{.+}}) + // LAMBDA: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* %{{.+}}) #pragma omp parallel #pragma omp sections private(g) { @@ -54,12 +54,12 @@ int main() { // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = alloca double, // LAMBDA: store %{{.+}}* [[ARG]], %{{.+}}** [[ARG_REF:%.+]], g = 1; - // LAMBDA: call void @__kmpc_for_static_init_4( + // LAMBDA: call {{.*}}void @__kmpc_for_static_init_4( // LAMBDA: store volatile double 1.0{{.+}}, double* [[G_PRIVATE_ADDR]], // LAMBDA: [[G_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 // LAMBDA: store double* [[G_PRIVATE_ADDR]], double** [[G_PRIVATE_ADDR_REF]] - // LAMBDA: call{{( x86_thiscallcc)?}} void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) - // LAMBDA: call void @__kmpc_for_static_fini( + // LAMBDA: call{{.*}} void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) + // LAMBDA: call {{.*}}void @__kmpc_for_static_fini( #pragma omp section [&]() { // LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]]) @@ -76,10 +76,10 @@ int main() { #elif defined(BLOCKS) // BLOCKS: [[G:@.+]] = global double // BLOCKS-LABEL: @main - // BLOCKS: call void {{%.+}}(i8 + // BLOCKS: call {{.*}}void {{%.+}}(i8 ^{ // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* - // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* {{.+}}) + // BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* {{.+}}) #pragma omp parallel #pragma omp sections private(g) { @@ -87,13 +87,13 @@ int main() { // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = alloca double, // BLOCKS: store %{{.+}}* [[ARG]], %{{.+}}** [[ARG_REF:%.+]], g = 1; - // BLOCKS: call void @__kmpc_for_static_init_4( + // BLOCKS: call {{.*}}void @__kmpc_for_static_init_4( // BLOCKS: store volatile double 1.0{{.+}}, double* [[G_PRIVATE_ADDR]], // BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS: double* [[G_PRIVATE_ADDR]] // BLOCKS-NOT: [[G]]{{[[^:word:]]}} - // BLOCKS: call void {{%.+}}(i8 - // BLOCKS: call void @__kmpc_for_static_fini( + // BLOCKS: call {{.*}}void {{%.+}}(i8 + // BLOCKS: call {{.*}}void @__kmpc_for_static_fini( #pragma omp section ^{ // BLOCKS: define {{.+}} void {{@.+}}(i8* diff --git a/test/OpenMP/simd_metadata.c b/test/OpenMP/simd_metadata.c index 2a95fef160f4..e7e35dd54d74 100644 --- a/test/OpenMP/simd_metadata.c +++ b/test/OpenMP/simd_metadata.c @@ -1,5 +1,6 @@ // RUN: %clang_cc1 -fopenmp -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=X86 // RUN: %clang_cc1 -fopenmp -triple x86_64-unknown-unknown -target-feature +avx -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=X86-AVX +// RUN: %clang_cc1 -fopenmp -triple x86_64-unknown-unknown -target-feature +avx512f -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=X86-AVX512 // RUN: %clang_cc1 -fopenmp -triple powerpc64-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=PPC // RUN: %clang_cc1 -fopenmp -triple powerpc64-unknown-unknown -target-abi elfv1-qpx -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=PPC-QPX @@ -16,6 +17,7 @@ void h1(float *c, float *a, double b[], int size) // X86-NEXT: [[A_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[A_PTRINT]], 15 // X86-AVX-NEXT: [[A_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[A_PTRINT]], 31 +// X86-AVX512-NEXT: [[A_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[A_PTRINT]], 63 // PPC-NEXT: [[A_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[A_PTRINT]], 15 // PPC-QPX-NEXT: [[A_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[A_PTRINT]], 15 @@ -25,6 +27,7 @@ void h1(float *c, float *a, double b[], int size) // X86-NEXT: [[B_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[B_PTRINT]], 15 // X86-AVX-NEXT: [[B_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[B_PTRINT]], 31 +// X86-AVX512-NEXT: [[B_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[B_PTRINT]], 63 // PPC-NEXT: [[B_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[B_PTRINT]], 15 // PPC-QPX-NEXT: [[B_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[B_PTRINT]], 31 diff --git a/test/OpenMP/single_codegen.cpp b/test/OpenMP/single_codegen.cpp index 0593b2aa7513..d81739ed9163 100644 --- a/test/OpenMP/single_codegen.cpp +++ b/test/OpenMP/single_codegen.cpp @@ -63,7 +63,7 @@ int main() { // CHECK-NEXT: call void @__kmpc_end_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) // CHECK-NEXT: br label {{%?}}[[EXIT]] // CHECK: [[EXIT]] -// CHECK: call{{.*}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_SINGLE_LOC]], i32 [[GTID]]) +// CHECK: call{{.*}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_SINGLE_LOC]], i32 [[GTID]]) #pragma omp single a = 2; // CHECK: store i32 0, i32* [[DID_IT]] diff --git a/test/OpenMP/single_firstprivate_codegen.cpp b/test/OpenMP/single_firstprivate_codegen.cpp index e30c00df19be..059108b37659 100644 --- a/test/OpenMP/single_firstprivate_codegen.cpp +++ b/test/OpenMP/single_firstprivate_codegen.cpp @@ -182,7 +182,7 @@ int main() { // CHECK-DAG: call {{.*}} [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* // CHECK: call void @__kmpc_end_single( -// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) +// CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) // CHECK: = call {{.*}}i{{.+}} [[TMAIN_INT:@.+]]() diff --git a/test/OpenMP/single_private_codegen.cpp b/test/OpenMP/single_private_codegen.cpp index 4f78d082b82b..a7fb2ed54937 100644 --- a/test/OpenMP/single_private_codegen.cpp +++ b/test/OpenMP/single_private_codegen.cpp @@ -19,9 +19,9 @@ struct S { volatile double g; // CHECK: [[S_FLOAT_TY:%.+]] = type { float } -// CHECK: [[CAP_MAIN_TY:%.+]] = type { i{{[0-9]+}}*, [2 x i{{[0-9]+}}]*, [2 x [[S_FLOAT_TY]]]*, [[S_FLOAT_TY]]* } +// CHECK: [[CAP_MAIN_TY:%.+]] = type { i8 } // CHECK: [[S_INT_TY:%.+]] = type { i{{[0-9]+}} } -// CHECK: [[CAP_TMAIN_TY:%.+]] = type { i{{[0-9]+}}*, [2 x i{{[0-9]+}}]*, [2 x [[S_INT_TY]]]*, [[S_INT_TY]]* } +// CHECK: [[CAP_TMAIN_TY:%.+]] = type { i8 } template <typename T> T tmain() { S<T> test; @@ -42,10 +42,10 @@ int main() { #ifdef LAMBDA // LAMBDA: [[G:@.+]] = global double // LAMBDA-LABEL: @main - // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]]( + // LAMBDA: call{{.*}} void [[OUTER_LAMBDA:@.+]]( [&]() { // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]]( - // LAMBDA: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* %{{.+}}) + // LAMBDA: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* %{{.+}}) #pragma omp parallel #pragma omp single private(g) { @@ -53,12 +53,12 @@ int main() { // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = alloca double, // LAMBDA: store %{{.+}}* [[ARG]], %{{.+}}** [[ARG_REF:%.+]], g = 1; - // LAMBDA: call i32 @__kmpc_single( + // LAMBDA: call {{.*}}i32 @__kmpc_single( // LAMBDA: store volatile double 1.0{{.+}}, double* [[G_PRIVATE_ADDR]], // LAMBDA: [[G_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 // LAMBDA: store double* [[G_PRIVATE_ADDR]], double** [[G_PRIVATE_ADDR_REF]] - // LAMBDA: call{{( x86_thiscallcc)?}} void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) - // LAMBDA: call void @__kmpc_end_single( + // LAMBDA: call{{.*}} void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) + // LAMBDA: call {{.*}}void @__kmpc_end_single( [&]() { // LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]]) // LAMBDA: store %{{.+}}* [[ARG_PTR]], %{{.+}}** [[ARG_PTR_REF:%.+]], @@ -74,10 +74,10 @@ int main() { #elif defined(BLOCKS) // BLOCKS: [[G:@.+]] = global double // BLOCKS-LABEL: @main - // BLOCKS: call void {{%.+}}(i8 + // BLOCKS: call {{.*}}void {{%.+}}(i8 ^{ // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* - // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* {{.+}}) + // BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* {{.+}}) #pragma omp parallel #pragma omp single private(g) { @@ -85,13 +85,13 @@ int main() { // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = alloca double, // BLOCKS: store %{{.+}}* [[ARG]], %{{.+}}** [[ARG_REF:%.+]], g = 1; - // BLOCKS: call i32 @__kmpc_single( + // BLOCKS: call {{.*}}i32 @__kmpc_single( // BLOCKS: store volatile double 1.0{{.+}}, double* [[G_PRIVATE_ADDR]], // BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS: double* [[G_PRIVATE_ADDR]] // BLOCKS-NOT: [[G]]{{[[^:word:]]}} - // BLOCKS: call void {{%.+}}(i8 - // BLOCKS: call void @__kmpc_end_single( + // BLOCKS: call {{.*}}void {{%.+}}(i8 + // BLOCKS: call {{.*}}void @__kmpc_end_single( ^{ // BLOCKS: define {{.+}} void {{@.+}}(i8* g = 2; diff --git a/test/OpenMP/task_ast_print.cpp b/test/OpenMP/task_ast_print.cpp index 55407c10baae..5fd41038ad29 100644 --- a/test/OpenMP/task_ast_print.cpp +++ b/test/OpenMP/task_ast_print.cpp @@ -33,7 +33,7 @@ T tmain(T argc, T *argv) { T b = argc, c, d, e, f, g; static T a; S<T> s; -#pragma omp task untied +#pragma omp task untied depend(in : argc) a = 2; #pragma omp task default(none), private(argc, b) firstprivate(argv) shared(d) if (argc > 0) final(S<T>::TS > 0) foo(); @@ -46,7 +46,7 @@ T tmain(T argc, T *argv) { // CHECK-NEXT: int b = argc, c, d, e, f, g; // CHECK-NEXT: static int a; // CHECK-NEXT: S<int> s; -// CHECK-NEXT: #pragma omp task untied +// CHECK-NEXT: #pragma omp task untied depend(in : argc) // CHECK-NEXT: a = 2; // CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) final(S<int>::TS > 0) // CHECK-NEXT: foo() @@ -56,7 +56,7 @@ T tmain(T argc, T *argv) { // CHECK-NEXT: long b = argc, c, d, e, f, g; // CHECK-NEXT: static long a; // CHECK-NEXT: S<long> s; -// CHECK-NEXT: #pragma omp task untied +// CHECK-NEXT: #pragma omp task untied depend(in : argc) // CHECK-NEXT: a = 2; // CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) final(S<long>::TS > 0) // CHECK-NEXT: foo() @@ -66,7 +66,7 @@ T tmain(T argc, T *argv) { // CHECK-NEXT: T b = argc, c, d, e, f, g; // CHECK-NEXT: static T a; // CHECK-NEXT: S<T> s; -// CHECK-NEXT: #pragma omp task untied +// CHECK-NEXT: #pragma omp task untied depend(in : argc) // CHECK-NEXT: a = 2; // CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) final(S<T>::TS > 0) // CHECK-NEXT: foo() @@ -82,12 +82,12 @@ int main(int argc, char **argv) { #pragma omp threadprivate(a) Enum ee; // CHECK: Enum ee; -#pragma omp task untied mergeable - // CHECK-NEXT: #pragma omp task untied mergeable +#pragma omp task untied mergeable depend(out:argv[1]) + // CHECK-NEXT: #pragma omp task untied mergeable depend(out : argv[1]) a = 2; // CHECK-NEXT: a = 2; -#pragma omp task default(none), private(argc, b) firstprivate(argv) if (argc > 0) final(a > 0) - // CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) if(argc > 0) final(a > 0) +#pragma omp task default(none), private(argc, b) firstprivate(argv) if (argc > 0) final(a > 0) depend(inout : a) + // CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) if(argc > 0) final(a > 0) depend(inout : a) foo(); // CHECK-NEXT: foo(); return tmain<int, 5>(b, &b) + tmain<long, 1>(x, &x); diff --git a/test/OpenMP/task_codegen.cpp b/test/OpenMP/task_codegen.cpp index 1c28fbc0568e..cce0a13bc2e4 100644 --- a/test/OpenMP/task_codegen.cpp +++ b/test/OpenMP/task_codegen.cpp @@ -7,8 +7,10 @@ #define HEADER // CHECK-DAG: [[IDENT_T:%.+]] = type { i32, i32, i32, i32, i8* } -// CHECK-DAG: [[STRUCT_SHAREDS:%.+]] = type { i8*, [[STRUCT_S:%.+]]* } +// CHECK-DAG: [[STRUCT_SHAREDS:%.+]] = type { i8*, [2 x [[STRUCT_S:%.+]]]* } +// CHECK-DAG: [[STRUCT_SHAREDS1:%.+]] = type { [2 x [[STRUCT_S:%.+]]]* } // CHECK-DAG: [[KMP_TASK_T:%.+]] = type { i8*, i32 (i32, i8*)*, i32, i32 (i32, i8*)* } +// CHECK-DAG: [[KMP_DEPEND_INFO:%.+]] = type { i64, i64, i8 } struct S { int a; S() : a(0) {} @@ -19,14 +21,14 @@ int a; // CHECK-LABEL : @main int main() { // CHECK: [[B:%.+]] = alloca i8 -// CHECK: [[S:%.+]] = alloca [[STRUCT_S]] +// CHECK: [[S:%.+]] = alloca [2 x [[STRUCT_S]]] char b; - S s; + S s[2]; // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T]]* @{{.+}}) // CHECK: [[B_REF:%.+]] = getelementptr inbounds [[STRUCT_SHAREDS]], [[STRUCT_SHAREDS]]* [[CAPTURES:%.+]], i32 0, i32 0 // CHECK: store i8* [[B]], i8** [[B_REF]] // CHECK: [[S_REF:%.+]] = getelementptr inbounds [[STRUCT_SHAREDS]], [[STRUCT_SHAREDS]]* [[CAPTURES]], i32 0, i32 1 -// CHECK: store [[STRUCT_S]]* [[S]], [[STRUCT_S]]** [[S_REF]] +// CHECK: store [2 x [[STRUCT_S]]]* [[S]], [2 x [[STRUCT_S]]]** [[S_REF]] // CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 1, i64 32, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)* [[TASK_ENTRY1:@.+]] to i32 (i32, i8*)*)) // CHECK: [[SHAREDS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]], [[KMP_TASK_T]]* [[TASK_PTR:%.+]], i32 0, i32 0 // CHECK: [[SHAREDS_REF:%.+]] = load i8*, i8** [[SHAREDS_REF_PTR]] @@ -39,7 +41,47 @@ int main() { { a = 15; b = a; - s.a = 10; + s[0].a = 10; + } +// CHECK: [[S_REF:%.+]] = getelementptr inbounds [[STRUCT_SHAREDS1]], [[STRUCT_SHAREDS1]]* [[CAPTURES:%.+]], i32 0, i32 0 +// CHECK: store [2 x [[STRUCT_S]]]* [[S]], [2 x [[STRUCT_S]]]** [[S_REF]] +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc([[IDENT_T]]* @{{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 8, +// CHECK: [[SHAREDS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]], [[KMP_TASK_T]]* [[TASK_PTR:%.+]], i32 0, i32 0 +// CHECK: [[SHAREDS_REF:%.+]] = load i8*, i8** [[SHAREDS_REF_PTR]] +// CHECK: [[BITCAST:%.+]] = bitcast [[STRUCT_SHAREDS1]]* [[CAPTURES]] to i8* +// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[SHAREDS_REF]], i8* [[BITCAST]], i64 8, i32 8, i1 false) +// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]], [[KMP_TASK_T]]* [[TASK_PTR]], i32 0, i32 3 +// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** [[DESTRUCTORS_REF_PTR]] +// CHECK: getelementptr inbounds [3 x [[KMP_DEPEND_INFO]]], [3 x [[KMP_DEPEND_INFO]]]* %{{[^,]+}}, i32 0, i32 0 +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 0 +// CHECK: store i64 ptrtoint (i32* @{{.+}} to i64), i64* +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 1 +// CHECK: store i64 4, i64* +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 2 +// CHECK: store i8 1, i8* +// CHECK: getelementptr inbounds [3 x [[KMP_DEPEND_INFO]]], [3 x [[KMP_DEPEND_INFO]]]* %{{[^,]+}}, i32 0, i32 1 +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 0 +// CHECK: ptrtoint i8* [[B]] to i64 +// CHECK: store i64 %{{[^,]+}}, i64* +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 1 +// CHECK: store i64 1, i64* +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 2 +// CHECK: store i8 1, i8* +// CHECK: getelementptr inbounds [3 x [[KMP_DEPEND_INFO]]], [3 x [[KMP_DEPEND_INFO]]]* %{{[^,]+}}, i32 0, i32 2 +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 0 +// CHECK: ptrtoint [2 x [[STRUCT_S]]]* [[S]] to i64 +// CHECK: store i64 %{{[^,]+}}, i64* +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 1 +// CHECK: store i64 8, i64* +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 2 +// CHECK: store i8 1, i8* +// CHECK: getelementptr inbounds [3 x [[KMP_DEPEND_INFO]]], [3 x [[KMP_DEPEND_INFO]]]* %{{[^,]+}}, i32 0, i32 0 +// CHECK: bitcast [[KMP_DEPEND_INFO]]* %{{.+}} to i8* +// CHECK: call i32 @__kmpc_omp_task_with_deps([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i8* [[ORIG_TASK_PTR]], i32 3, i8* %{{[^,]+}}, i32 0, i8* null) +#pragma omp task shared(a, s) depend(in : a, b, s) + { + a = 15; + s[1].a = 10; } // CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 0, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)* [[TASK_ENTRY2:@.+]] to i32 (i32, i8*)*)) // CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]]{{.*}}* {{%.+}}, i32 0, i32 3 @@ -49,6 +91,51 @@ int main() { { a = 1; } +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 0, i64 32, i64 1, +// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]]{{.*}}* {{%.+}}, i32 0, i32 3 +// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** [[DESTRUCTORS_REF_PTR]] +// CHECK: getelementptr inbounds [2 x [[STRUCT_S]]], [2 x [[STRUCT_S]]]* [[S]], i32 0, i64 0 +// CHECK: getelementptr inbounds [1 x [[KMP_DEPEND_INFO]]], [1 x [[KMP_DEPEND_INFO]]]* %{{[^,]+}}, i32 0, i32 0 +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 0 +// CHECK: ptrtoint [[STRUCT_S]]* %{{.+}} to i64 +// CHECK: store i64 %{{[^,]+}}, i64* +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 1 +// CHECK: store i64 4, i64* +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 2 +// CHECK: store i8 2, i8* +// CHECK: getelementptr inbounds [1 x [[KMP_DEPEND_INFO]]], [1 x [[KMP_DEPEND_INFO]]]* %{{[^,]+}}, i32 0, i32 0 +// CHECK: bitcast [[KMP_DEPEND_INFO]]* %{{.+}} to i8* +// CHECK: call i32 @__kmpc_omp_task_with_deps([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i8* [[ORIG_TASK_PTR]], i32 1, i8* %{{[^,]+}}, i32 0, i8* null) +#pragma omp task untied depend(out : s[0]) + { + a = 1; + } +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 3, i64 32, i64 1, +// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]]{{.*}}* {{%.+}}, i32 0, i32 3 +// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** [[DESTRUCTORS_REF_PTR]] +// CHECK: getelementptr inbounds [2 x [[KMP_DEPEND_INFO]]], [2 x [[KMP_DEPEND_INFO]]]* %{{[^,]+}}, i32 0, i32 0 +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 0 +// CHECK: store i64 ptrtoint (i32* @{{.+}} to i64), i64* +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 1 +// CHECK: store i64 4, i64* +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 2 +// CHECK: store i8 3, i8* +// CHECK: getelementptr inbounds [2 x [[STRUCT_S]]], [2 x [[STRUCT_S]]]* [[S]], i32 0, i64 1 +// CHECK: getelementptr inbounds [2 x [[KMP_DEPEND_INFO]]], [2 x [[KMP_DEPEND_INFO]]]* %{{[^,]+}}, i32 0, i32 1 +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 0 +// CHECK: ptrtoint [[STRUCT_S]]* %{{.+}} to i64 +// CHECK: store i64 %{{[^,]+}}, i64* +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 1 +// CHECK: store i64 4, i64* +// CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]], [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 2 +// CHECK: store i8 3, i8* +// CHECK: getelementptr inbounds [2 x [[KMP_DEPEND_INFO]]], [2 x [[KMP_DEPEND_INFO]]]* %{{[^,]+}}, i32 0, i32 0 +// CHECK: bitcast [[KMP_DEPEND_INFO]]* %{{.+}} to i8* +// CHECK: call i32 @__kmpc_omp_task_with_deps([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i8* [[ORIG_TASK_PTR]], i32 2, i8* %{{[^,]+}}, i32 0, i8* null) +#pragma omp task final(true) depend(inout: a, s[1]) + { + a = 2; + } // CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 3, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)* [[TASK_ENTRY3:@.+]] to i32 (i32, i8*)*)) // CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]]{{.*}}* {{%.+}}, i32 0, i32 3 // CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** [[DESTRUCTORS_REF_PTR]] diff --git a/test/OpenMP/task_depend_messages.cpp b/test/OpenMP/task_depend_messages.cpp new file mode 100644 index 000000000000..152350cca93a --- /dev/null +++ b/test/OpenMP/task_depend_messages.cpp @@ -0,0 +1,39 @@ +// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -o - %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +class vector { + public: + int operator[](int index) { return 0; } +}; + +int main(int argc, char **argv) { + vector vec; + typedef float V __attribute__((vector_size(16))); + V a; + + #pragma omp task depend // expected-error {{expected '(' after 'depend'}} + #pragma omp task depend ( // expected-error {{expected 'in', 'out' or 'inout' in OpenMP clause 'depend'}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-warning {{missing ':' after dependency type - ignoring}} + #pragma omp task depend () // expected-error {{expected 'in', 'out' or 'inout' in OpenMP clause 'depend'}} expected-warning {{missing ':' after dependency type - ignoring}} + #pragma omp task depend (argc // expected-error {{expected 'in', 'out' or 'inout' in OpenMP clause 'depend'}} expected-warning {{missing ':' after dependency type - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task depend (in : argc)) // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}} + #pragma omp task depend (out: ) // expected-error {{expected expression}} + #pragma omp task depend (inout : foobool(argc)), depend (in, argc) // expected-error {{expected variable name, array element or array section}} expected-warning {{missing ':' after dependency type - ignoring}} expected-error {{expected expression}} + #pragma omp task depend (out :S1) // expected-error {{'S1' does not refer to a value}} + #pragma omp task depend(in : argv[1][1] = '2') // expected-error {{expected variable name, array element or array section}} + #pragma omp task depend (in : vec[1]) // expected-error {{expected variable name, array element or array section}} + #pragma omp task depend (in : argv[0]) + #pragma omp task depend (in : ) // expected-error {{expected expression}} + #pragma omp task depend (in : main) // expected-error {{expected variable name, array element or array section}} + #pragma omp task depend(in : a[0]) // expected-error{{expected variable name, array element or array section}} + foo(); + + return 0; +} diff --git a/test/OpenMP/task_if_codegen.cpp b/test/OpenMP/task_if_codegen.cpp index d4fd6bb1ebb3..be9b47b79a41 100644 --- a/test/OpenMP/task_if_codegen.cpp +++ b/test/OpenMP/task_if_codegen.cpp @@ -11,6 +11,10 @@ void fn3(); void fn4(); void fn5(); void fn6(); +void fn7(); +void fn8(); +void fn9(); +void fn10(); int Arg; @@ -46,25 +50,31 @@ int tmain(T Arg) { fn2(); #pragma omp task if (Arg) fn3(); +#pragma omp task if (Arg) depend(in : Arg) + fn4(); +#pragma omp task if (Arg) depend(out : Arg) + fn5(); +#pragma omp task if (Arg) depend(inout : Arg) + fn6(); return 0; } // CHECK-LABEL: @main int main() { // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num( -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN4:[^ ]+]] to i32 (i32, i8*)*)) +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN7:[^ ]+]] to i32 (i32, i8*)*)) // CHECK: call i32 @__kmpc_omp_task(%{{.+}}* @{{.+}}, i32 [[GTID]], i8* [[ORIG_TASK_PTR]]) #pragma omp task if (true) - fn4(); -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc( + fn7(); +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN8:[^ ]+]] to i32 (i32, i8*)*)) // CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to // CHECK: call void @__kmpc_omp_task_begin_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) -// CHECK: call i32 [[CAP_FN5:@.+]](i32 [[GTID]], %{{.+}}* [[TASK_PTR]]) +// CHECK: call i32 [[CAP_FN8]](i32 [[GTID]], %{{.+}}* [[TASK_PTR]]) // CHECK: call void @__kmpc_omp_task_complete_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) #pragma omp task if (false) - fn5(); + fn8(); -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN6:[^ ]+]] to i32 (i32, i8*)*)) +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN9:[^ ]+]] to i32 (i32, i8*)*)) // CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to // CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]] // CHECK: [[OMP_THEN]] @@ -72,26 +82,45 @@ int main() { // CHECK: br label %[[OMP_END:.+]] // CHECK: [[OMP_ELSE]] // CHECK: call void @__kmpc_omp_task_begin_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) -// CHECK: call i32 [[CAP_FN6:@.+]](i32 [[GTID]], %{{.+}}* [[TASK_PTR]]) +// CHECK: call i32 [[CAP_FN9]](i32 [[GTID]], %{{.+}}* [[TASK_PTR]]) // CHECK: call void @__kmpc_omp_task_complete_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) // CHECK: br label %[[OMP_END]] // CHECK: [[OMP_END]] #pragma omp task if (Arg) - fn6(); + fn9(); +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN10:[^ ]+]] to i32 (i32, i8*)*)) +// CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to +// CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]] +// CHECK: [[OMP_THEN]] +// CHECK: call i32 @__kmpc_omp_task_with_deps(%{{.+}}* @{{.+}}, i32 [[GTID]], i8* [[ORIG_TASK_PTR]], i32 1, i8* [[LIST:%[^,]+]], i32 0, i8* null) +// CHECK: br label %[[OMP_END:.+]] +// CHECK: [[OMP_ELSE]] +// CHECK: call void @__kmpc_omp_wait_deps(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 1, i8* [[LIST]], i32 0, i8* null) +// CHECK: call void @__kmpc_omp_task_begin_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) +// CHECK: call i32 [[CAP_FN10]](i32 [[GTID]], %{{.+}}* [[TASK_PTR]]) +// CHECK: call void @__kmpc_omp_task_complete_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) +// CHECK: br label %[[OMP_END]] +// CHECK: [[OMP_END]] +#pragma omp task if (Arg) depend(inout : Arg) + fn10(); // CHECK: = call {{.*}}i{{.+}} @{{.+}}tmain return tmain(Arg); } -// CHECK: define internal i32 [[CAP_FN4]] -// CHECK: call void @{{.+}}fn4 +// CHECK: define internal i32 [[CAP_FN7]] +// CHECK: call void @{{.+}}fn7 // CHECK: ret i32 -// CHECK: define internal i32 [[CAP_FN5]] -// CHECK: call void @{{.+}}fn5 +// CHECK: define internal i32 [[CAP_FN8]] +// CHECK: call void @{{.+}}fn8 // CHECK: ret i32 -// CHECK: define internal i32 [[CAP_FN6]] -// CHECK: call void @{{.+}}fn6 +// CHECK: define internal i32 [[CAP_FN9]] +// CHECK: call void @{{.+}}fn9 +// CHECK: ret i32 + +// CHECK: define internal i32 [[CAP_FN10]] +// CHECK: call void @{{.+}}fn10 // CHECK: ret i32 // CHECK-LABEL: define {{.+}} @{{.+}}tmain @@ -113,7 +142,49 @@ int main() { // CHECK: br label %[[OMP_END:.+]] // CHECK: [[OMP_ELSE]] // CHECK: call void @__kmpc_omp_task_begin_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) -// CHECK: call i32 [[CAP_FN3:@.+]](i32 [[GTID]], %{{.+}}* [[TASK_PTR]]) +// CHECK: call i32 [[CAP_FN3]](i32 [[GTID]], %{{.+}}* [[TASK_PTR]]) +// CHECK: call void @__kmpc_omp_task_complete_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) +// CHECK: br label %[[OMP_END]] +// CHECK: [[OMP_END]] + +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN4:[^ ]+]] to i32 (i32, i8*)*)) +// CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to +// CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]] +// CHECK: [[OMP_THEN]] +// CHECK: call i32 @__kmpc_omp_task_with_deps(%{{.+}}* @{{.+}}, i32 [[GTID]], i8* [[ORIG_TASK_PTR]], i32 1, i8* [[LIST:%.+]], i32 0, i8* null) +// CHECK: br label %[[OMP_END:.+]] +// CHECK: [[OMP_ELSE]] +// CHECK: call void @__kmpc_omp_wait_deps(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 1, i8* [[LIST]], i32 0, i8* null) +// CHECK: call void @__kmpc_omp_task_begin_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) +// CHECK: call i32 [[CAP_FN4]](i32 [[GTID]], %{{.+}}* [[TASK_PTR]]) +// CHECK: call void @__kmpc_omp_task_complete_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) +// CHECK: br label %[[OMP_END]] +// CHECK: [[OMP_END]] + +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN5:[^ ]+]] to i32 (i32, i8*)*)) +// CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to +// CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]] +// CHECK: [[OMP_THEN]] +// CHECK: call i32 @__kmpc_omp_task_with_deps(%{{.+}}* @{{.+}}, i32 [[GTID]], i8* [[ORIG_TASK_PTR]], i32 1, i8* [[LIST:%.+]], i32 0, i8* null) +// CHECK: br label %[[OMP_END:.+]] +// CHECK: [[OMP_ELSE]] +// CHECK: call void @__kmpc_omp_wait_deps(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 1, i8* [[LIST]], i32 0, i8* null) +// CHECK: call void @__kmpc_omp_task_begin_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) +// CHECK: call i32 [[CAP_FN5]](i32 [[GTID]], %{{.+}}* [[TASK_PTR]]) +// CHECK: call void @__kmpc_omp_task_complete_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) +// CHECK: br label %[[OMP_END]] +// CHECK: [[OMP_END]] + +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN6:[^ ]+]] to i32 (i32, i8*)*)) +// CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to +// CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]] +// CHECK: [[OMP_THEN]] +// CHECK: call i32 @__kmpc_omp_task_with_deps(%{{.+}}* @{{.+}}, i32 [[GTID]], i8* [[ORIG_TASK_PTR]], i32 1, i8* [[LIST:%.+]], i32 0, i8* null) +// CHECK: br label %[[OMP_END:.+]] +// CHECK: [[OMP_ELSE]] +// CHECK: call void @__kmpc_omp_wait_deps(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 1, i8* [[LIST]], i32 0, i8* null) +// CHECK: call void @__kmpc_omp_task_begin_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) +// CHECK: call i32 [[CAP_FN6]](i32 [[GTID]], %{{.+}}* [[TASK_PTR]]) // CHECK: call void @__kmpc_omp_task_complete_if0(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]]) // CHECK: br label %[[OMP_END]] // CHECK: [[OMP_END]] @@ -130,4 +201,16 @@ int main() { // CHECK: call void @{{.+}}fn3 // CHECK: ret i32 +// CHECK: define internal i32 [[CAP_FN4]] +// CHECK: call void @{{.+}}fn4 +// CHECK: ret i32 + +// CHECK: define internal i32 [[CAP_FN5]] +// CHECK: call void @{{.+}}fn5 +// CHECK: ret i32 + +// CHECK: define internal i32 [[CAP_FN6]] +// CHECK: call void @{{.+}}fn6 +// CHECK: ret i32 + #endif diff --git a/test/OpenMP/task_private_codegen.cpp b/test/OpenMP/task_private_codegen.cpp index 3a9ed7c58d63..463913f926a4 100644 --- a/test/OpenMP/task_private_codegen.cpp +++ b/test/OpenMP/task_private_codegen.cpp @@ -26,11 +26,11 @@ volatile double g; // CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32, i32 (i32, i8*)* } // CHECK-DAG: [[S_DOUBLE_TY:%.+]] = type { double } -// CHECK-DAG: [[CAP_MAIN_TY:%.+]] = type { [2 x i32]*, i32*, [2 x [[S_DOUBLE_TY]]]*, [[S_DOUBLE_TY]]* } +// CHECK-DAG: [[CAP_MAIN_TY:%.+]] = type { i8 } // CHECK-DAG: [[PRIVATES_MAIN_TY:%.+]] = type {{.?}}{ [[S_DOUBLE_TY]], [2 x [[S_DOUBLE_TY]]], i32, [2 x i32] // CHECK-DAG: [[KMP_TASK_MAIN_TY:%.+]] = type { [[KMP_TASK_T_TY]], [[PRIVATES_MAIN_TY]] } // CHECK-DAG: [[S_INT_TY:%.+]] = type { i32 } -// CHECK-DAG: [[CAP_TMAIN_TY:%.+]] = type { [2 x i32]*, i32*, [2 x [[S_INT_TY]]]*, [[S_INT_TY]]* } +// CHECK-DAG: [[CAP_TMAIN_TY:%.+]] = type { i8 } // CHECK-DAG: [[PRIVATES_TMAIN_TY:%.+]] = type { i32, [2 x i32], [2 x [[S_INT_TY]]], [[S_INT_TY]] } // CHECK-DAG: [[KMP_TASK_TMAIN_TY:%.+]] = type { [[KMP_TASK_T_TY]], [[PRIVATES_TMAIN_TY]] } template <typename T> @@ -55,7 +55,7 @@ int main() { // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]]( [&]() { // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]]( - // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 40, i64 8, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) + // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 40, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // LAMBDA: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0 // LAMBDA: call i32 @__kmpc_omp_task(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]]) @@ -86,7 +86,7 @@ int main() { // BLOCKS: call void {{%.+}}(i8 ^{ // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* - // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 40, i64 8, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) + // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 40, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0 // BLOCKS: call i32 @__kmpc_omp_task(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]]) @@ -135,31 +135,18 @@ int main() { // CHECK: call {{.*}} [[S_DOUBLE_TY_DEF_CONSTR:@.+]]([[S_DOUBLE_TY]]* [[TEST]]) -// Store original variables in capture struct. -// CHECK: [[VEC_REF:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0 -// CHECK: store [2 x i32]* [[VEC_ADDR]], [2 x i32]** [[VEC_REF]], -// CHECK: [[T_VAR_REF:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1 -// CHECK: store i32* [[T_VAR_ADDR]], i32** [[T_VAR_REF]], -// CHECK: [[S_ARR_REF:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2 -// CHECK: store [2 x [[S_DOUBLE_TY]]]* [[S_ARR_ADDR]], [2 x [[S_DOUBLE_TY]]]** [[S_ARR_REF]], -// CHECK: [[VAR_REF:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 3 -// CHECK: store [[S_DOUBLE_TY]]* [[VAR_ADDR]], [[S_DOUBLE_TY]]** [[VAR_REF]], +// Do not store original variables in capture struct. +// CHECK-NOT: getelementptr inbounds [[CAP_MAIN_TY]], // Allocate task. // Returns struct kmp_task_t { // [[KMP_TASK_T_TY]] task_data; // [[KMP_TASK_MAIN_TY]] privates; // }; -// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32 [[GTID]], i32 1, i64 72, i64 32, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) +// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32 [[GTID]], i32 1, i64 72, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // CHECK: [[RES_KMP_TASK:%.+]] = bitcast i8* [[RES]] to [[KMP_TASK_MAIN_TY]]* -// Fill kmp_task_t->shareds by copying from original capture argument. // CHECK: [[TASK:%.+]] = getelementptr inbounds [[KMP_TASK_MAIN_TY]], [[KMP_TASK_MAIN_TY]]* [[RES_KMP_TASK]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 -// CHECK: [[SHAREDS_REF_ADDR:%.+]] = getelementptr inbounds [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 -// CHECK: [[SHAREDS_REF:%.+]] = load i8*, i8** [[SHAREDS_REF_ADDR]], -// CHECK: [[CAPTURES_ADDR:%.+]] = bitcast [[CAP_MAIN_TY]]* %{{.+}} to i8* -// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[SHAREDS_REF]], i8* [[CAPTURES_ADDR]], i64 32, i32 8, i1 false) - // Initialize kmp_task_t->privates with default values (no init for simple types, default constructors for classes). // Also copy address of private copy to the corresponding shareds reference. // CHECK: [[PRIVATES:%.+]] = getelementptr inbounds [[KMP_TASK_MAIN_TY]], [[KMP_TASK_MAIN_TY]]* [[RES_KMP_TASK]], i{{[0-9]+}} 0, i{{[0-9]+}} 1 @@ -257,30 +244,18 @@ int main() { // CHECK: call {{.*}} [[S_INT_TY_DEF_CONSTR:@.+]]([[S_INT_TY]]* [[TEST]]) -// Store original variables in capture struct. -// CHECK: [[VEC_REF:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0 -// CHECK: store [2 x i32]* [[VEC_ADDR]], [2 x i32]** [[VEC_REF]], -// CHECK: [[T_VAR_REF:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1 -// CHECK: store i32* [[T_VAR_ADDR]], i32** [[T_VAR_REF]], -// CHECK: [[S_ARR_REF:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2 -// CHECK: store [2 x [[S_INT_TY]]]* [[S_ARR_ADDR]], [2 x [[S_INT_TY]]]** [[S_ARR_REF]], -// CHECK: [[VAR_REF:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 3 -// CHECK: store [[S_INT_TY]]* [[VAR_ADDR]], [[S_INT_TY]]** [[VAR_REF]], +// Do not store original variables in capture struct. +// CHECK-NOT: getelementptr inbounds [[CAP_TMAIN_TY]], // Allocate task. // Returns struct kmp_task_t { // [[KMP_TASK_T_TY]] task_data; // [[KMP_TASK_TMAIN_TY]] privates; // }; -// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32 [[GTID]], i32 1, i64 56, i64 32, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_TMAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) +// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32 [[GTID]], i32 1, i64 56, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_TMAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // CHECK: [[RES_KMP_TASK:%.+]] = bitcast i8* [[RES]] to [[KMP_TASK_TMAIN_TY]]* -// Fill kmp_task_t->shareds by copying from original capture argument. // CHECK: [[TASK:%.+]] = getelementptr inbounds [[KMP_TASK_TMAIN_TY]], [[KMP_TASK_TMAIN_TY]]* [[RES_KMP_TASK]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 -// CHECK: [[SHAREDS_REF_ADDR:%.+]] = getelementptr inbounds [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 -// CHECK: [[SHAREDS_REF:%.+]] = load i8*, i8** [[SHAREDS_REF_ADDR]], -// CHECK: [[CAPTURES_ADDR:%.+]] = bitcast [[CAP_TMAIN_TY]]* %{{.+}} to i8* -// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[SHAREDS_REF]], i8* [[CAPTURES_ADDR]], i64 32, i32 8, i1 false) // Initialize kmp_task_t->privates with default values (no init for simple types, default constructors for classes). // CHECK: [[PRIVATES:%.+]] = getelementptr inbounds [[KMP_TASK_TMAIN_TY]], [[KMP_TASK_TMAIN_TY]]* [[RES_KMP_TASK]], i{{[0-9]+}} 0, i{{[0-9]+}} 1 diff --git a/test/OpenMP/taskgroup_codegen.cpp b/test/OpenMP/taskgroup_codegen.cpp index a6aec1f5b8c7..eb45f3187fa5 100644 --- a/test/OpenMP/taskgroup_codegen.cpp +++ b/test/OpenMP/taskgroup_codegen.cpp @@ -9,7 +9,7 @@ // CHECK: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* } -// CHECK: define void [[FOO:@.+]]() +// CHECK: define {{.*}}void [[FOO:@.+]]() void foo() {} @@ -19,19 +19,19 @@ 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: [[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]]) +// 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]]) +// 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 +// CHECK-NOT: call {{.*}}void @__kmpc_taskgroup +// CHECK-NOT: call {{.*}}void @__kmpc_end_taskgroup return a; } diff --git a/test/PCH/cxx-mangling.cpp b/test/PCH/cxx-mangling.cpp index d086f26465aa..280268750ae5 100644 --- a/test/PCH/cxx-mangling.cpp +++ b/test/PCH/cxx-mangling.cpp @@ -17,11 +17,11 @@ struct A { template<typename T> void f(T) {} -// CHECK-LABEL: define void @_Z1g1A( +// CHECK-LABEL: define {{.*}}void @_Z1g1A( void g(A a) { - // CHECK: call void @_Z1fIN1AUt0_EEvT_( + // CHECK: call {{.*}}void @_Z1fIN1AUt0_EEvT_( f(a.b); - // CHECK: call void @_Z1fIN1AUt_EEvT_( + // CHECK: call {{.*}}void @_Z1fIN1AUt_EEvT_( f(a.a); } diff --git a/test/PCH/objc_container.m b/test/PCH/objc_container.m index 44aac709d43a..2af51cbcf424 100644 --- a/test/PCH/objc_container.m +++ b/test/PCH/objc_container.m @@ -14,7 +14,7 @@ // CHECK-PRINT: oldObject = dictionary[key]; // CHECK-PRINT: dictionary[key] = newObject; -// CHECK-IR: define void @all() #0 +// CHECK-IR: define {{.*}}void @all() #0 // CHECK-IR: {{call.*objc_msgSend}} // CHECK-IR: {{call.*objc_msgSend}} // CHECK-IR: {{call.*objc_msgSend}} diff --git a/test/PCH/objc_literals.m b/test/PCH/objc_literals.m index f96d4afe2aa0..f65bbe7f0774 100644 --- a/test/PCH/objc_literals.m +++ b/test/PCH/objc_literals.m @@ -39,7 +39,7 @@ typedef unsigned char BOOL; + (id)dictionaryWithObjects:(const id [])objects forKeys:(const id [])keys count:(unsigned long)cnt; @end -// CHECK-IR: define internal void @test_numeric_literals() +// CHECK-IR: define internal {{.*}}void @test_numeric_literals() static inline void test_numeric_literals() { // CHECK-PRINT: id intlit = @17 // CHECK-IR: {{call.*17}} diff --git a/test/PCH/objc_literals.mm b/test/PCH/objc_literals.mm index 777046ef29f2..7baf4a8907bd 100644 --- a/test/PCH/objc_literals.mm +++ b/test/PCH/objc_literals.mm @@ -50,7 +50,7 @@ pair<T, U> make_pair(const T& first, const U& second) { return { first, second }; } -// CHECK-IR: define linkonce_odr void @_Z29variadic_dictionary_expansionIJP8NSStringS1_EJP8NSNumberS3_EEvDp4pairIT_T0_E +// CHECK-IR: define linkonce_odr {{.*}}void @_Z29variadic_dictionary_expansionIJP8NSStringS1_EJP8NSNumberS3_EEvDp4pairIT_T0_E template<typename ...Ts, typename ... Us> void variadic_dictionary_expansion(pair<Ts, Us>... key_values) { // CHECK-PRINT: id dict = @{ key_values.first : key_values.second... }; diff --git a/test/PCH/subscripting-literals.m b/test/PCH/subscripting-literals.m index 1675373441c0..725e5802a5dd 100644 --- a/test/PCH/subscripting-literals.m +++ b/test/PCH/subscripting-literals.m @@ -30,6 +30,14 @@ @class NSString; +@interface NSValue ++ (NSValue *)valueWithBytes:(const void *)bytes objCType:(const char *)type; +@end + +typedef struct __attribute__((objc_boxable)) _some_struct { + int dummy; +} some_struct; + id testArray(int idx, id p) { NSMutableArray *array; array[idx] = p; @@ -44,4 +52,9 @@ void testDict(NSString *key, id newObject, id oldObject) { NSDictionary *dict = @{ key: newObject, key: oldObject }; } +void testBoxableValue() { + some_struct ss; + id value = @(ss); +} + #endif diff --git a/test/Parser/cxx-class.cpp b/test/Parser/cxx-class.cpp index 38eef1756d0f..9e907f1b1c12 100644 --- a/test/Parser/cxx-class.cpp +++ b/test/Parser/cxx-class.cpp @@ -24,6 +24,16 @@ public: ; // expected-warning{{extra ';' inside a class}} virtual int vf() const volatile = 0; + + virtual int vf0() = 0l; // expected-error {{does not look like a pure-specifier}} + virtual int vf1() = 1; // expected-error {{does not look like a pure-specifier}} + virtual int vf2() = 00; // expected-error {{does not look like a pure-specifier}} + virtual int vf3() = 0x0; // expected-error {{does not look like a pure-specifier}} + virtual int vf4() = 0.0; // expected-error {{does not look like a pure-specifier}} + virtual int vf5(){0}; // expected-error +{{}} expected-warning {{unused}} + virtual int vf5a(){0;}; // function definition, expected-warning {{unused}} + virtual int vf6()(0); // expected-error +{{}} expected-note +{{}} + virtual int vf7() = { 0 }; // expected-error {{does not look like a pure-specifier}} private: int x,f(),y,g(); diff --git a/test/Parser/cxx-concept-declaration.cpp b/test/Parser/cxx-concept-declaration.cpp new file mode 100644 index 000000000000..591629ca2856 --- /dev/null +++ b/test/Parser/cxx-concept-declaration.cpp @@ -0,0 +1,30 @@ + +// Support parsing of function concepts and variable concepts + +// RUN: %clang_cc1 -std=c++14 -fconcepts-ts -x c++ -verify %s + +template<typename T> concept bool C1 = true; + +template<typename T> concept bool C2() { return true; } + +template<typename T> +struct A { typedef bool Boolean; }; + +template<int N> +A<void>::Boolean concept C3(!0); + +template<typename T, int = 0> +concept auto C4(void) -> bool { return true; } + +constexpr int One = 1; + +template <typename> +static concept decltype(!0) C5 { bool(One) }; + +template<typename T> concept concept bool C6 = true; // expected-warning {{duplicate 'concept' declaration specifier}} + +template<typename T> concept concept bool C7() { return true; } // expected-warning {{duplicate 'concept' declaration specifier}} + +concept D1 = true; // expected-error {{C++ requires a type specifier for all declarations}} + +template<concept T> concept bool D2 = true; // expected-error {{unknown type name 'T'}} diff --git a/test/Parser/cxx-concepts-ambig-constraint-expr.cpp b/test/Parser/cxx-concepts-ambig-constraint-expr.cpp new file mode 100644 index 000000000000..12ab338a6b00 --- /dev/null +++ b/test/Parser/cxx-concepts-ambig-constraint-expr.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -std=c++14 -fconcepts-ts -x c++ %s -verify + +// Test parsing of constraint-expressions in cases where the grammar is +// ambiguous with the expectation that the longest token sequence which matches +// the syntax is consumed without backtracking. + +// type-specifier-seq in conversion-type-id +template <typename T> requires (bool)&T::operator short +unsigned int foo(); // expected-error {{C++ requires a type specifier for all declarations}} + +// type-specifier-seq in new-type-id +template <typename T> requires (bool)sizeof new (T::f()) short +unsigned int bar(); // expected-error {{C++ requires a type specifier for all declarations}} + +template<typename T> requires (bool)sizeof new (T::f()) unsigned // expected-error {{'struct' cannot be signed or unsigned}} +struct X { }; // expected-error {{'X' cannot be defined in a type specifier}} + +// C-style cast +// of function call on function-style cast +template <typename T> requires (bool(T())) +T (*fp)(); // expected-error {{use of undeclared identifier 'fp'}} + +// function-style cast +// as the callee in a function call +struct A { + static int t; + template <typename T> requires bool(T()) + (A(T (&t))) { } // expected-error {{called object type 'bool' is not a function or function pointer}} +}; diff --git a/test/Parser/cxx-concepts-requires-clause.cpp b/test/Parser/cxx-concepts-requires-clause.cpp new file mode 100644 index 000000000000..01893a94cbc9 --- /dev/null +++ b/test/Parser/cxx-concepts-requires-clause.cpp @@ -0,0 +1,82 @@ +// RUN: %clang_cc1 -std=c++14 -fconcepts-ts -x c++ %s -verify +// expected-no-diagnostics + +// Test parsing of the optional requires-clause in a template-declaration. + +template <typename T> requires true +void foo() { } + + +template <typename T> requires !0 +struct A { + void foo(); + struct AA; + enum E : int; + static int x; + + template <typename> requires true + void Mfoo(); + + template <typename> requires true + struct M; + + template <typename> requires true + static int Mx; + + template <typename TT> requires true + using MQ = M<TT>; +}; + +template <typename T> requires !0 +void A<T>::foo() { } + +template <typename T> requires !0 +struct A<T>::AA { }; + +template <typename T> requires !0 +enum A<T>::E : int { E0 }; + +template <typename T> requires !0 +int A<T>::x = 0; + +template <typename T> requires !0 +template <typename> requires true +void A<T>::Mfoo() { } + +template <typename T> requires !0 +template <typename> requires true +struct A<T>::M { }; + +template <typename T> requires !0 +template <typename> requires true +int A<T>::Mx = 0; + + +template <typename T> requires true +int x = 0; + +template <typename T> requires true +using Q = A<T>; + +struct C { + template <typename> requires true + void Mfoo(); + + template <typename> requires true + struct M; + + template <typename> requires true + static int Mx; + + template <typename T> requires true + using MQ = M<T>; +}; + +template <typename> requires true +void C::Mfoo() { } + +template <typename> requires true +struct C::M { }; + +template <typename> requires true +int C::Mx = 0; diff --git a/test/Parser/nullability.c b/test/Parser/nullability.c index f2b6abf73dcf..7117bce4bb74 100644 --- a/test/Parser/nullability.c +++ b/test/Parser/nullability.c @@ -1,14 +1,14 @@ // 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}} +_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 +_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 +#if !__has_feature(nullability) +# error Nullability should always be supported #endif #if !__has_extension(nullability) diff --git a/test/Preprocessor/cxx_true.cpp b/test/Preprocessor/cxx_true.cpp index 39cb349b2a81..f6dc459e2c1f 100644 --- a/test/Preprocessor/cxx_true.cpp +++ b/test/Preprocessor/cxx_true.cpp @@ -1,15 +1,18 @@ -/* RUN: %clang_cc1 -E %s -x c++ | grep block_1 - RUN: %clang_cc1 -E %s -x c++ | not grep block_2 - RUN: %clang_cc1 -E %s -x c | not grep block +/* RUN: %clang_cc1 -E %s -x c++ | FileCheck -check-prefix CPP %s + RUN: %clang_cc1 -E %s -x c | FileCheck -check-prefix C %s RUN: %clang_cc1 -E %s -x c++ -verify -Wundef */ // expected-no-diagnostics #if true -block_1 +// CPP: test block_1 +// C-NOT: test block_1 +test block_1 #endif #if false -block_2 +// CPP-NOT: test block_2 +// C-NOT: test block_2 +test block_2 #endif diff --git a/test/Preprocessor/predefined-nullability.c b/test/Preprocessor/predefined-nullability.c new file mode 100644 index 000000000000..d736afa9b082 --- /dev/null +++ b/test/Preprocessor/predefined-nullability.c @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 %s -E -dM -triple i386-apple-darwin10 -o - | FileCheck %s --check-prefix=CHECK-DARWIN + +// RUN: %clang_cc1 %s -E -dM -triple x86_64-unknown-linux -o - | FileCheck %s --check-prefix=CHECK-NONDARWIN + + +// CHECK-DARWIN: #define __nonnull _Nonnull +// CHECK-DARWIN: #define __null_unspecified _Null_unspecified +// CHECK-DARWIN: #define __nullable _Nullable + +// CHECK-NONDARWIN-NOT: __nonnull +// CHECK-NONDARWIN: #define __clang__ +// CHECK-NONDARWIN-NOT: __nonnull diff --git a/test/Profile/cxx-lambda.cpp b/test/Profile/cxx-lambda.cpp index 34e185715ba7..a111f0663e3e 100644 --- a/test/Profile/cxx-lambda.cpp +++ b/test/Profile/cxx-lambda.cpp @@ -13,14 +13,14 @@ // PGOGEN: @[[MAC:__llvm_profile_counters_main]] = private global [1 x i64] zeroinitializer // LMBGEN: @[[LFC:"__llvm_profile_counters_cxx-lambda.cpp:_ZZ7lambdasvENK3\$_0clEi"]] = private global [3 x i64] zeroinitializer -// PGOGEN-LABEL: define void @_Z7lambdasv() -// PGOUSE-LABEL: define void @_Z7lambdasv() +// PGOGEN-LABEL: define {{.*}}void @_Z7lambdasv() +// PGOUSE-LABEL: define {{.*}}void @_Z7lambdasv() // PGOGEN: store {{.*}} @[[LWC]], i64 0, i64 0 void lambdas() { int i = 1; - // LMBGEN-LABEL: define internal{{( x86_thiscallcc)?( zeroext)?}} i1 @"_ZZ7lambdasvENK3$_0clEi"( - // LMBUSE-LABEL: define internal{{( x86_thiscallcc)?( zeroext)?}} i1 @"_ZZ7lambdasvENK3$_0clEi"( + // LMBGEN-LABEL: define internal{{( [0-9_a-z]*cc)?( zeroext)?}} i1 @"_ZZ7lambdasvENK3$_0clEi"( + // LMBUSE-LABEL: define internal{{( [0-9_a-z]*cc)?( zeroext)?}} i1 @"_ZZ7lambdasvENK3$_0clEi"( // LMBGEN: store {{.*}} @[[LFC]], i64 0, i64 0 auto f = [&i](int k) { // LMBGEN: store {{.*}} @[[LFC]], i64 0, i64 1 diff --git a/test/Profile/cxx-rangefor.cpp b/test/Profile/cxx-rangefor.cpp index f30cdc746e60..23be0f5771a3 100644 --- a/test/Profile/cxx-rangefor.cpp +++ b/test/Profile/cxx-rangefor.cpp @@ -9,7 +9,7 @@ // PGOGEN: @[[RFC:__llvm_profile_counters__Z9range_forv]] = private global [5 x i64] zeroinitializer -// CHECK-LABEL: define void @_Z9range_forv() +// CHECK-LABEL: define {{.*}}void @_Z9range_forv() // PGOGEN: store {{.*}} @[[RFC]], i64 0, i64 0 void range_for() { int arr[] = {1, 2, 3, 4, 5}; diff --git a/test/Profile/cxx-templates.cpp b/test/Profile/cxx-templates.cpp index ce5651a25006..ca0e8614d09d 100644 --- a/test/Profile/cxx-templates.cpp +++ b/test/Profile/cxx-templates.cpp @@ -13,10 +13,10 @@ // T0GEN: @[[T0C:__llvm_profile_counters__Z4loopILj0EEvv]] = linkonce_odr hidden global [2 x i64] zeroinitializer // T100GEN: @[[T100C:__llvm_profile_counters__Z4loopILj100EEvv]] = linkonce_odr hidden global [2 x i64] zeroinitializer -// T0GEN-LABEL: define linkonce_odr void @_Z4loopILj0EEvv() -// T0USE-LABEL: define linkonce_odr void @_Z4loopILj0EEvv() -// T100GEN-LABEL: define linkonce_odr void @_Z4loopILj100EEvv() -// T100USE-LABEL: define linkonce_odr void @_Z4loopILj100EEvv() +// T0GEN-LABEL: define linkonce_odr {{.*}}void @_Z4loopILj0EEvv() +// T0USE-LABEL: define linkonce_odr {{.*}}void @_Z4loopILj0EEvv() +// T100GEN-LABEL: define linkonce_odr {{.*}}void @_Z4loopILj100EEvv() +// T100USE-LABEL: define linkonce_odr {{.*}}void @_Z4loopILj100EEvv() template <unsigned N> void loop() { // ALL-NOT: ret // T0GEN: store {{.*}} @[[T0C]], i64 0, i64 0 diff --git a/test/Profile/profile-does-not-exist.c b/test/Profile/profile-does-not-exist.c index 89609bd945d6..d45981faffed 100644 --- a/test/Profile/profile-does-not-exist.c +++ b/test/Profile/profile-does-not-exist.c @@ -1,4 +1,4 @@ // RUN: not %clang_cc1 -emit-llvm %s -o - -fprofile-instr-use=%t.nonexistent.profdata 2>&1 | FileCheck %s -// CHECK: error: Could not read profile: +// CHECK: error: Could not read profile {{.*}}.nonexistent.profdata: // CHECK-NOT: Assertion failed diff --git a/test/Sema/arm-microsoft-intrinsics.c b/test/Sema/arm-microsoft-intrinsics.c new file mode 100644 index 000000000000..0637d98d7606 --- /dev/null +++ b/test/Sema/arm-microsoft-intrinsics.c @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -triple armv7 -fms-extensions -fsyntax-only -ffreestanding -verify %s + +unsigned int test_MoveFromCoprocessor(const unsigned int value) { + return _MoveFromCoprocessor(value, 1, 2, 3, 4); // expected-error-re {{argument to {{.*}} must be a constant integer}} +} + +void test_MoveToCoprocessor(const unsigned int value) { + _MoveToCoprocessor(1, 2, value, 3, 4, 5); // expected-error-re {{argument to {{.*}} must be a constant integer}} +} diff --git a/test/Sema/attr-malloc.c b/test/Sema/attr-malloc.c index 5351d757a23f..6af15d2f682e 100644 --- a/test/Sema/attr-malloc.c +++ b/test/Sema/attr-malloc.c @@ -19,10 +19,10 @@ __attribute((malloc)) int (*g)(); // expected-warning{{attribute only applies to __attribute((malloc)) void * xalloc(unsigned n) { return malloc(n); } // no-warning -// RUN: grep 'define noalias .* @xalloc(' %t +// RUN: grep 'define .*noalias .* @xalloc(' %t %t #define malloc_like __attribute((__malloc__)) void * xalloc2(unsigned) malloc_like; void * xalloc2(unsigned n) { return malloc(n); } -// RUN: grep 'define noalias .* @xalloc2(' %t +// RUN: grep 'define .*noalias .* @xalloc2(' %t %t diff --git a/test/Sema/builtin-cpu-supports.c b/test/Sema/builtin-cpu-supports.c new file mode 100644 index 000000000000..c537b4140b27 --- /dev/null +++ b/test/Sema/builtin-cpu-supports.c @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -fsyntax-only -triple x86_64-pc-linux-gnu -verify %s +// RUN: %clang_cc1 -fsyntax-only -triple powerpc64le-linux-gnu -verify %s + +extern void a(const char *); + +extern const char *str; + +int main() { +#ifdef __x86_64__ + if (__builtin_cpu_supports("ss")) // expected-error {{invalid cpu feature string}} + a("sse4.2"); + + if (__builtin_cpu_supports(str)) // expected-error {{expression is not a string literal}} + a(str); +#else + if (__builtin_cpu_supports("vsx")) // expected-error {{use of unknown builtin}} + a("vsx"); +#endif + + return 0; +} diff --git a/test/Sema/enable_if.c b/test/Sema/enable_if.c index a3c4323c4c98..4644858593d6 100644 --- a/test/Sema/enable_if.c +++ b/test/Sema/enable_if.c @@ -49,7 +49,7 @@ size_t strnlen(const char *s, size_t maxlen) // expected-note{{candidate functi __attribute__((unavailable("'maxlen' is larger than the buffer size"))); void test2(const char *s, int i) { -// CHECK: define void @test2 +// CHECK: define {{.*}}void @test2 const char c[123]; strnlen(s, i); // CHECK: call {{.*}}strnlen_real1 diff --git a/test/Sema/non-null-warning.c b/test/Sema/non-null-warning.c index 6cd98e298e2c..024ef1eca667 100644 --- a/test/Sema/non-null-warning.c +++ b/test/Sema/non-null-warning.c @@ -7,29 +7,29 @@ #endif -int * __nullable foo(int * __nonnull x); +int * _Nullable foo(int * _Nonnull x); -int *__nonnull ret_nonnull(); +int *_Nonnull ret_nonnull(); int *foo(int *x) { return 0; } -int * __nullable foo1(int * __nonnull x); // expected-note {{previous declaration is here}} +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'}} +int *foo1(int * _Nullable x) { // expected-warning {{nullability specifier '_Nullable' conflicts with existing specifier '_Nonnull'}} return 0; } -int * __nullable foo2(int * __nonnull x); +int * _Nullable foo2(int * _Nonnull x); -int *foo2(int * __nonnull x) { +int *foo2(int * _Nonnull x) { return 0; } -int * __nullable foo3(int * __nullable x); // expected-note {{previous declaration is here}} +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'}} +int *foo3(int * _Nonnull x) { // expected-warning {{nullability specifier '_Nonnull' conflicts with existing specifier '_Nullable'}} return 0; } diff --git a/test/Sema/nullability.c b/test/Sema/nullability.c index 6144b7e8e9e8..59644c4193a8 100644 --- a/test/Sema/nullability.c +++ b/test/Sema/nullability.c @@ -8,88 +8,88 @@ 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; +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'}} +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'}} +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; +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 _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 _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'}} +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); +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'}} +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)); +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)')}} + 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'}} +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 * _Nonnull ambiguous_int_ptr; typedef int * ambiguous_int_ptr; -typedef int * __nullable 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 *'}} +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 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 * * _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'}} + 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); +// 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}} @@ -97,17 +97,17 @@ void test_accepts_nonnull_null_pointer_literal() { 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) { +// 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; + return (_Nonnull int *)0; } // Check nullable-to-nonnull conversions. -void nullable_to_nonnull(__nullable int *ptr) { +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'}} + _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/typo-correction.c b/test/Sema/typo-correction.c index d457257b3c3a..ff43064d5b75 100644 --- a/test/Sema/typo-correction.c +++ b/test/Sema/typo-correction.c @@ -40,3 +40,12 @@ int PR23101(__m128i __x) { return foo((__v2di)__x); // expected-warning {{implicit declaration of function 'foo'}} \ // expected-error {{use of undeclared identifier '__v2di'}} } + +void f(long *a, long b) { + __atomic_or_fetch(a, b, c); // expected-error {{use of undeclared identifier 'c'}} +} + +extern double cabs(_Complex double z); +void fn1() { + cabs(errij); // expected-error {{use of undeclared identifier 'errij'}} +} diff --git a/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp b/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp index a78f022e84c9..9456dd713aa8 100644 --- a/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp +++ b/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp @@ -275,3 +275,10 @@ namespace TemporaryInitListSourceRange_PR22367 { {0} ); } + +namespace ParameterPackNestedInitializerLists_PR23904c3 { + template <typename ...T> + void f(std::initializer_list<std::initializer_list<T>> ...tt); + + void foo() { f({{0}}, {{'\0'}}); } +} diff --git a/test/SemaCXX/cxx1y-generic-lambdas.cpp b/test/SemaCXX/cxx1y-generic-lambdas.cpp index f4c67fbba0cd..b49a6418ea85 100644 --- a/test/SemaCXX/cxx1y-generic-lambdas.cpp +++ b/test/SemaCXX/cxx1y-generic-lambdas.cpp @@ -933,3 +933,18 @@ namespace PR22117 { }; }(0)(0); } + +namespace PR23716 { +template<typename T> +auto f(T x) { + auto g = [](auto&&... args) { + auto h = [args...]() -> int { + return 0; + }; + return h; + }; + return g; +} + +auto x = f(0)(); +} diff --git a/test/SemaCXX/nullability-declspec.cpp b/test/SemaCXX/nullability-declspec.cpp index ef1a171c4ddb..1a3a321ab223 100644 --- a/test/SemaCXX/nullability-declspec.cpp +++ b/test/SemaCXX/nullability-declspec.cpp @@ -2,8 +2,8 @@ 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?}} +_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 index f0aa13be8fa3..edce6b057bd3 100644 --- a/test/SemaCXX/nullability.cpp +++ b/test/SemaCXX/nullability.cpp @@ -1,29 +1,34 @@ // RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wno-nullability-declspec %s -verify +#if __has_feature(nullability) +#else +# error nullability feature should be defined +#endif + 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'}} +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; +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 _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<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}} @@ -31,22 +36,22 @@ typedef AddNonNull<int>::type nonnull_non_pointer_1; // expected-note{{in instan // 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; + 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>'}} + 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; +// 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}} @@ -56,7 +61,7 @@ void test_accepts_nonnull_null_pointer_literal(X *x) { accepts_nonnull_5(0); // expected-warning{{null passed to a callee that requires a non-null argument}} } -template<void FP(__nonnull int*)> +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}} } diff --git a/test/SemaCXX/openmp_default_simd_align.cpp b/test/SemaCXX/openmp_default_simd_align.cpp new file mode 100644 index 000000000000..c869a946d06b --- /dev/null +++ b/test/SemaCXX/openmp_default_simd_align.cpp @@ -0,0 +1,83 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -triple x86_64-unknown-unknown -verify %s + +struct S0 { + int x; + static const int test0 = __builtin_omp_required_simd_align(x); // expected-error {{invalid application of '__builtin_omp_required_simd_align' to an expression, only type is allowed}} + static const int test1 = __builtin_omp_required_simd_align(decltype(S0::x)); + auto test2() -> char(&)[__builtin_omp_required_simd_align(decltype(x))]; +}; + +struct S1; // expected-note 6 {{forward declaration}} +extern S1 s1; +const int test3 = __builtin_omp_required_simd_align(decltype(s1)); // expected-error {{invalid application of '__builtin_omp_required_simd_align' to an incomplete type 'decltype(s1)' (aka 'S1')}} + +struct S2 { + S2(); + S1 &s; + int x; + + int test4 = __builtin_omp_required_simd_align(decltype(x)); // ok + int test5 = __builtin_omp_required_simd_align(decltype(s)); // expected-error {{invalid application of '__builtin_omp_required_simd_align' to an incomplete type 'S1'}} +}; + +const int test6 = __builtin_omp_required_simd_align(decltype(S2::x)); +const int test7 = __builtin_omp_required_simd_align(decltype(S2::s)); // expected-error {{invalid application of '__builtin_omp_required_simd_align' to an incomplete type 'S1'}} + +// Arguably, these should fail like the S1 cases do: the alignment of +// 's2.x' should depend on the alignment of both x-within-S2 and +// s2-within-S3 and thus require 'S3' to be complete. If we start +// doing the appropriate recursive walk to do that, we should make +// sure that these cases don't explode. +struct S3 { + S2 s2; + + static const int test8 = __builtin_omp_required_simd_align(decltype(s2.x)); + static const int test9 = __builtin_omp_required_simd_align(decltype(s2.s)); // expected-error {{invalid application of '__builtin_omp_required_simd_align' to an incomplete type 'S1'}} + auto test10() -> char(&)[__builtin_omp_required_simd_align(decltype(s2.x))]; + static const int test11 = __builtin_omp_required_simd_align(decltype(S3::s2.x)); + static const int test12 = __builtin_omp_required_simd_align(decltype(S3::s2.s)); // expected-error {{invalid application of '__builtin_omp_required_simd_align' to an incomplete type 'S1'}} + auto test13() -> char(&)[__builtin_omp_required_simd_align(decltype(s2.x))]; +}; + +// Same reasoning as S3. +struct S4 { + union { + int x; + }; + static const int test0 = __builtin_omp_required_simd_align(decltype(x)); + static const int test1 = __builtin_omp_required_simd_align(decltype(S0::x)); + auto test2() -> char(&)[__builtin_omp_required_simd_align(decltype(x))]; +}; + +// Regression test for asking for the alignment of a field within an invalid +// record. +struct S5 { + S1 s; // expected-error {{incomplete type}} + int x; +}; +const int test8 = __builtin_omp_required_simd_align(decltype(S5::x)); + +long long int test14[2]; + +static_assert(__builtin_omp_required_simd_align(decltype(test14)) == 16, "foo"); + +static_assert(__builtin_omp_required_simd_align(int[2]) == __builtin_omp_required_simd_align(int), ""); // ok + +namespace __builtin_omp_required_simd_align_array_expr { + alignas(32) extern int n[2]; + static_assert(__builtin_omp_required_simd_align(decltype(n)) == 16, ""); + + template<int> struct S { + static int a[]; + }; + template<int N> int S<N>::a[N]; + static_assert(__builtin_omp_required_simd_align(decltype(S<1>::a)) == __builtin_omp_required_simd_align(int), ""); + static_assert(__builtin_omp_required_simd_align(decltype(S<1128>::a)) == __builtin_omp_required_simd_align(int), ""); +} + +template <typename T> void n(T) { + alignas(T) int T1; + char k[__builtin_omp_required_simd_align(decltype(T1))]; + static_assert(sizeof(k) == __builtin_omp_required_simd_align(long long), ""); +} +template void n(long long); diff --git a/test/SemaCXX/typo-correction-cxx11.cpp b/test/SemaCXX/typo-correction-cxx11.cpp index 99cb1662b7a0..8c588203cc12 100644 --- a/test/SemaCXX/typo-correction-cxx11.cpp +++ b/test/SemaCXX/typo-correction-cxx11.cpp @@ -32,3 +32,29 @@ void f() { } } } + +namespace NewTypoExprFromResolvingTypoAmbiguity { +struct A { + void Swap(A *other); +}; + +struct pair { + int first; + A *second; +}; + +struct map { +public: + void swap(map &x); + pair find(int x); +}; + +void run(A *annotations) { + map new_annotations; + + auto &annotation = *annotations; + auto new_it = new_annotations.find(5); + auto &new_anotation = new_it.second; // expected-note {{'new_anotation' declared here}} + new_annotation->Swap(&annotation); // expected-error {{use of undeclared identifier 'new_annotation'; did you mean 'new_anotation'?}} +} +} diff --git a/test/SemaCXX/virtual-function-in-union.cpp b/test/SemaCXX/virtual-function-in-union.cpp new file mode 100644 index 000000000000..0c4ba5d32caa --- /dev/null +++ b/test/SemaCXX/virtual-function-in-union.cpp @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +union x { + virtual void f(); // expected-error {{unions cannot have virtual functions}} +}; diff --git a/test/SemaCXX/virtuals.cpp b/test/SemaCXX/virtuals.cpp index 6b8231d4e1e2..f8180745bd3b 100644 --- a/test/SemaCXX/virtuals.cpp +++ b/test/SemaCXX/virtuals.cpp @@ -51,3 +51,13 @@ namespace pr8264 { virtual virtual void func(); // expected-warning {{duplicate 'virtual' declaration specifier}} }; } + +namespace VirtualFriend { + // DR (filed but no number yet): reject meaningless pure-specifier on a friend declaration. + struct A { virtual int f(); }; + struct B { friend int A::f() = 0; }; // expected-error {{friend declaration cannot have a pure-specifier}} + struct C { + virtual int f(); + friend int C::f() = 0; // expected-error {{friend declaration cannot have a pure-specifier}} + }; +} diff --git a/test/SemaObjC/arc-unavailable-for-weakref.m b/test/SemaObjC/arc-unavailable-for-weakref.m index 53ceaa15c28c..35d5d9830445 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 * __nullable', 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 * __nullable', 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 * __nullable', 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/format-strings-objc.m b/test/SemaObjC/format-strings-objc.m index f4c528cc7ac0..079460cc76cb 100644 --- a/test/SemaObjC/format-strings-objc.m +++ b/test/SemaObjC/format-strings-objc.m @@ -251,3 +251,16 @@ void testUnicode() { NSLog(@"%C", 0x202200); // expected-warning{{format specifies type 'unichar' (aka 'unsigned short') but the argument has type 'int'}} } +// Test Objective-C modifier flags. +void testObjCModifierFlags() { + NSLog(@"%[]@", @"Foo"); // expected-warning {{missing object format flag}} + NSLog(@"%[", @"Foo"); // expected-warning {{incomplete format specifier}} + NSLog(@"%[tt", @"Foo"); // expected-warning {{incomplete format specifier}} + NSLog(@"%[tt]@", @"Foo"); // no-warning + NSLog(@"%[tt]@ %s", @"Foo", "hello"); // no-warning + NSLog(@"%s %[tt]@", "hello", @"Foo"); // no-warning + NSLog(@"%[blark]@", @"Foo"); // expected-warning {{'blark' is not a valid object format flag}} + NSLog(@"%2$[tt]@ %1$[tt]@", @"Foo", @"Bar"); // no-warning + NSLog(@"%2$[tt]@ %1$[tt]s", @"Foo", @"Bar"); // expected-warning {{object format flags cannot be used with 's' conversion specifier}} +} + diff --git a/test/SemaObjC/nullability-arc.m b/test/SemaObjC/nullability-arc.m index 917a808386dc..1c303e8300cb 100644 --- a/test/SemaObjC/nullability-arc.m +++ b/test/SemaObjC/nullability-arc.m @@ -5,6 +5,6 @@ __attribute__((objc_root_class)) @end // ARC qualifiers stacked with nullability. -void accepts_arc_qualified(NSFoo * __unsafe_unretained __nonnull obj) { +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 index ca8c2fcd321e..36ac6b9ddea2 100644 --- a/test/SemaObjC/nullability.m +++ b/test/SemaObjC/nullability.m @@ -2,29 +2,29 @@ __attribute__((objc_root_class)) @interface NSFoo -- (void)methodTakingIntPtr:(__nonnull int *)ptr; -- (__nonnull int *)methodReturningIntPtr; +- (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; +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; +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'}} +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)'}} +void testBlocksPrinting(NSFoo * _Nullable (^bp)(int)) { + int *ip = bp; // expected-error{{'NSFoo * _Nullable (^)(int)'}} } -// Check returning nil from a __nonnull-returning method. +// Check returning nil from a _Nonnull-returning method. @implementation NSFoo -- (void)methodTakingIntPtr:(__nonnull int *)ptr { } -- (__nonnull int *)methodReturningIntPtr { +- (void)methodTakingIntPtr:(_Nonnull int *)ptr { } +- (_Nonnull int *)methodReturningIntPtr { return 0; // no warning } @end @@ -35,15 +35,15 @@ __attribute__((objc_root_class)) - (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'}} +// 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'}} +// 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'}} @@ -52,19 +52,19 @@ __attribute__((objc_root_class)) @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'}} +// 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) { +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'}} + 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. @@ -82,7 +82,7 @@ void test_accepts_nonnull_null_pointer_literal(NSFoo *foo, __nonnull NSBar *bar) } - (NSFoo *)redundantMethod1 { int *ip = 0; - return ip; // expected-warning{{result type 'NSFoo * __nonnull'}} + return ip; // expected-warning{{result type 'NSFoo * _Nonnull'}} } @end @@ -95,8 +95,8 @@ __attribute__((objc_root_class)) @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'}} + 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'}} \ @@ -106,7 +106,7 @@ __attribute__((objc_root_class)) - (nonnull NSFoo *)methodC:(nullable NSFoo*)foo { int *ip = 0; - return ip; // expected-warning{{result type 'NSFoo * __nonnull'}} + return ip; // expected-warning{{result type 'NSFoo * _Nonnull'}} } @end @@ -119,27 +119,27 @@ __attribute__((objc_root_class)) @end void test_receiver_merge(NSMergeReceiver *none, - __nonnull NSMergeReceiver *nonnull, - __nullable NSMergeReceiver *nullable, - __null_unspecified NSMergeReceiver *null_unspecified) { + _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 = [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 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 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 returnsNullable]; // expected-warning{{'id _Nullable'}} ptr = [none returnsNullUnspecified]; // expected-warning{{'id'}} ptr = [none returnsNonNull]; // expected-warning{{'id'}} ptr = [none returnsNone]; // expected-warning{{'id'}} @@ -157,19 +157,19 @@ __attribute__((objc_root_class)) - (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; +- (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'}} +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'}} + 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. @@ -184,14 +184,14 @@ __attribute__((objc_root_class)) @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 *'}} + [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'}} + return ip; // expected-warning{{result type 'NSResettable * _Nonnull'}} } - (void)setResettable1:(NSResettable *)param { @@ -218,15 +218,15 @@ void test_null_resettable(NSResettable *r, int *ip) { 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)'}} + 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; }); + (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'}} + 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 index 617ff4ee5c62..faafd204675e 100644 --- a/test/SemaObjC/nullable-weak-property.m +++ b/test/SemaObjC/nullable-weak-property.m @@ -5,7 +5,7 @@ @interface NSObject @end @class NSFoo; -void foo (NSFoo * __nonnull); +void foo (NSFoo * _Nonnull); @interface NSBar : NSObject @property(weak) NSFoo *property1; @@ -13,6 +13,6 @@ void foo (NSFoo * __nonnull); @implementation NSBar - (void) Meth { - foo (self.property1); // expected-warning {{implicit conversion from nullable pointer 'NSFoo * __nullable' to non-nullable pointer type 'NSFoo * __nonnull'}} + foo (self.property1); // expected-warning {{implicit conversion from nullable pointer 'NSFoo * _Nullable' to non-nullable pointer type 'NSFoo * _Nonnull'}} } @end diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-1.h b/test/SemaObjCXX/Inputs/nullability-consistency-1.h index 4d6bf79f9a46..6ab48fe0cd8f 100644 --- a/test/SemaObjCXX/Inputs/nullability-consistency-1.h +++ b/test/SemaObjCXX/Inputs/nullability-consistency-1.h @@ -1,6 +1,6 @@ void f1(int *ptr); // expected-warning{{pointer is missing a nullability type specifier}} -void f2(int * __nonnull); +void f2(int * _Nonnull); #include "nullability-consistency-2.h" diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-2.h b/test/SemaObjCXX/Inputs/nullability-consistency-2.h index 8efdfa8394e1..4517738c552b 100644 --- a/test/SemaObjCXX/Inputs/nullability-consistency-2.h +++ b/test/SemaObjCXX/Inputs/nullability-consistency-2.h @@ -1,4 +1,4 @@ -void g1(int * __nonnull); +void g1(int * _Nonnull); void g2(int (^block)(int, int)); // expected-warning{{block pointer is missing a nullability type specifier}} diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-3.h b/test/SemaObjCXX/Inputs/nullability-consistency-3.h index a0c0d381bb8e..520d1a4b3442 100644 --- a/test/SemaObjCXX/Inputs/nullability-consistency-3.h +++ b/test/SemaObjCXX/Inputs/nullability-consistency-3.h @@ -1 +1 @@ -void double_declarator1(int *__nonnull *); // expected-warning{{pointer is missing a nullability type specifier (__nonnull, __nullable, or __null_unspecified)}} +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 index 984280c17ebe..ac227a0885bf 100644 --- a/test/SemaObjCXX/Inputs/nullability-consistency-4.h +++ b/test/SemaObjCXX/Inputs/nullability-consistency-4.h @@ -1 +1 @@ -void double_declarator1(int * * __nonnull); // expected-warning{{pointer is missing a nullability type specifier (__nonnull, __nullable, or __null_unspecified)}} +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 index 3a685af614ef..1c74ab882a17 100644 --- a/test/SemaObjCXX/Inputs/nullability-consistency-5.h +++ b/test/SemaObjCXX/Inputs/nullability-consistency-5.h @@ -8,7 +8,7 @@ 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 trigger5(int * _Nonnull); void suppress2(SUPPRESS_NULLABILITY_WARNING(int *) ptr); // no warning diff --git a/test/SemaObjCXX/Inputs/nullability-consistency-8.h b/test/SemaObjCXX/Inputs/nullability-consistency-8.h index 890bb4db5465..2425a70356d9 100644 --- a/test/SemaObjCXX/Inputs/nullability-consistency-8.h +++ b/test/SemaObjCXX/Inputs/nullability-consistency-8.h @@ -1,4 +1,4 @@ -typedef int* __nonnull mynonnull; +typedef int* _Nonnull mynonnull; __attribute__((objc_root_class)) @interface typedefClass @@ -13,15 +13,15 @@ void func3(int *); // expected-warning{{pointer is missing a nullability type sp 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 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 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); +void cf6(CFTypeRef * _Nullable CF_RETURNS_NOT_RETAINED p); +void cf7(CF_RETURNS_NOT_RETAINED CFTypeRef * _Nonnull p); -typedef CFTypeRef __nullable *CFTypeRefPtr; +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); +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 index 6dbca1663d5a..9161af1cf353 100644 --- a/test/SemaObjCXX/Inputs/nullability-consistency-system/nullability-consistency-system.h +++ b/test/SemaObjCXX/Inputs/nullability-consistency-system/nullability-consistency-system.h @@ -5,4 +5,4 @@ void system1(int *ptr); // expected-warning@-2{{pointer is missing a nullability type specifier}} #endif -void system2(int * __nonnull); +void system2(int * _Nonnull); diff --git a/test/SemaObjCXX/Inputs/nullability-pragmas-1.h b/test/SemaObjCXX/Inputs/nullability-pragmas-1.h index 950111692419..4ac813d99618 100644 --- a/test/SemaObjCXX/Inputs/nullability-pragmas-1.h +++ b/test/SemaObjCXX/Inputs/nullability-pragmas-1.h @@ -25,19 +25,19 @@ 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 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)); +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}} +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}} @@ -64,14 +64,14 @@ void g5(int (**fp)(int, int)); // expected-warning 2{{pointer is missing a nulla int *global_int_ptr; -// typedefs not inferred __nonnull +// 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'}} + 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 *')}} @@ -83,7 +83,7 @@ static inline void f30(void) { @interface AA : A { @public id ivar1; - __nonnull id ivar2; + _Nonnull id ivar2; } @end @@ -92,8 +92,8 @@ static inline void f30(void) { 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 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) diff --git a/test/SemaObjCXX/nullability-consistency.mm b/test/SemaObjCXX/nullability-consistency.mm index acb972da0b85..6921d8b9d3dd 100644 --- a/test/SemaObjCXX/nullability-consistency.mm +++ b/test/SemaObjCXX/nullability-consistency.mm @@ -13,4 +13,4 @@ void h1(int *ptr) { } // don't warn -void h2(int * __nonnull) { } +void h2(int * _Nonnull) { } diff --git a/test/SemaObjCXX/nullability-pragmas.mm b/test/SemaObjCXX/nullability-pragmas.mm index 0c61a30b333f..dbf4f37f4019 100644 --- a/test/SemaObjCXX/nullability-pragmas.mm +++ b/test/SemaObjCXX/nullability-pragmas.mm @@ -7,7 +7,11 @@ # error assume_nonnull feature is not set #endif -void test_pragmas_1(A * __nonnull a, AA * __nonnull aa) { +#if !__has_extension(assume_nonnull) +# error assume_nonnull extension 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}} @@ -23,19 +27,19 @@ void test_pragmas_1(A * __nonnull a, AA * __nonnull aa) { [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'}} + [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 = 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'}} + ptr = aa->ivar2; // expected-error{{from incompatible type 'id _Nonnull'}} } diff --git a/test/SemaTemplate/instantiate-explicitly-after-fatal.cpp b/test/SemaTemplate/instantiate-explicitly-after-fatal.cpp new file mode 100644 index 000000000000..9693d2fc6c05 --- /dev/null +++ b/test/SemaTemplate/instantiate-explicitly-after-fatal.cpp @@ -0,0 +1,9 @@ +// RUN: not %clang_cc1 -fsyntax-only -std=c++11 -ferror-limit 1 %s 2>&1 | FileCheck %s +unknown_type foo(unknown_type); +// CHECK: fatal error: too many errors emitted, stopping now + +template <typename> +class Bar {}; + +extern template class Bar<int>; +template class Bar<int>; diff --git a/test/SemaTemplate/instantiate-local-class.cpp b/test/SemaTemplate/instantiate-local-class.cpp index f58d7a496225..c0ea6a0bc870 100644 --- a/test/SemaTemplate/instantiate-local-class.cpp +++ b/test/SemaTemplate/instantiate-local-class.cpp @@ -394,3 +394,57 @@ void f() { void g() { f<void>(); } } + + +namespace PR21332 { + template<typename T> void f1() { + struct S { // expected-note{{in instantiation of member class 'S' requested here}} + void g1(int n = T::error); // expected-error{{type 'int' cannot be used prior to '::' because it has no members}} + }; + } + template void f1<int>(); // expected-note{{in instantiation of function template specialization 'PR21332::f1<int>' requested here}} + + template<typename T> void f2() { + struct S { // expected-note{{in instantiation of member class 'S' requested here}} + void g2() noexcept(T::error); // expected-error{{type 'int' cannot be used prior to '::' because it has no members}} + }; + } + template void f2<int>(); // expected-note{{in instantiation of function template specialization 'PR21332::f2<int>' requested here}} + + template<typename T> void f3() { + enum S { + val = T::error; // expected-error{{expected '}' or ','}} expected-error{{type 'int' cannot be used prior to '::' because it has no members}} + }; + } + template void f3<int>(); //expected-note{{in instantiation of function template specialization 'PR21332::f3<int>' requested here}} + + template<typename T> void f4() { + enum class S { + val = T::error; // expected-error{{expected '}' or ','}} expected-error{{type 'int' cannot be used prior to '::' because it has no members}} + }; + } + template void f4<int>(); // expected-note{{in instantiation of function template specialization 'PR21332::f4<int>' requested here}} + + template<typename T> void f5() { + class S { // expected-note {{in instantiation of default member initializer 'PR21332::f5()::S::val' requested here}} + int val = T::error; // expected-error {{type 'int' cannot be used prior to '::' because it has no members}} + }; + } + template void f5<int>(); // expected-note {{in instantiation of function template specialization 'PR21332::f5<int>' requested here}} + + template<typename T> void f6() { + class S { // expected-note {{in instantiation of member function 'PR21332::f6()::S::get' requested here}} + void get() { + class S2 { // expected-note {{in instantiation of member class 'S2' requested here}} + void g1(int n = T::error); // expected-error {{type 'int' cannot be used prior to '::' because it has no members}} + }; + } + }; + } + template void f6<int>(); // expected-note{{in instantiation of function template specialization 'PR21332::f6<int>' requested here}} + + template<typename T> void f7() { + struct S { void g() noexcept(undefined_val); }; // expected-error{{use of undeclared identifier 'undefined_val'}} + } + template void f7<int>(); +} diff --git a/test/lit.cfg b/test/lit.cfg index 51e1e4fdbc7d..0e947dd437bb 100644 --- a/test/lit.cfg +++ b/test/lit.cfg @@ -452,14 +452,13 @@ if lit.util.which('xmllint'): config.available_features.add('xmllint') # Sanitizers. -if config.llvm_use_sanitizer == "Address": +if 'Address' in config.llvm_use_sanitizer: config.available_features.add("asan") else: config.available_features.add("not_asan") -if (config.llvm_use_sanitizer == "Memory" or - config.llvm_use_sanitizer == "MemoryWithOrigins"): +if 'Memory' in config.llvm_use_sanitizer: config.available_features.add("msan") -if config.llvm_use_sanitizer == "Undefined": +if 'Undefined' in config.llvm_use_sanitizer: config.available_features.add("ubsan") else: config.available_features.add("not_ubsan") diff --git a/tools/clang-fuzzer/ClangFuzzer.cpp b/tools/clang-fuzzer/ClangFuzzer.cpp index 17ef0521e3c3..124911cd4a54 100644 --- a/tools/clang-fuzzer/ClangFuzzer.cpp +++ b/tools/clang-fuzzer/ClangFuzzer.cpp @@ -39,5 +39,8 @@ extern "C" void LLVMFuzzerTestOneInput(uint8_t *data, size_t size) { Invocation->getPreprocessorOpts().addRemappedFile("./test.cc", Input.release()); std::unique_ptr<tooling::ToolAction> action( tooling::newFrontendActionFactory<clang::SyntaxOnlyAction>()); - action->runInvocation(Invocation.release(), Files.get(), &Diags); + std::shared_ptr<PCHContainerOperations> PCHContainerOps = + std::make_shared<RawPCHContainerOperations>(); + action->runInvocation(Invocation.release(), Files.get(), PCHContainerOps, + &Diags); } diff --git a/tools/driver/cc1as_main.cpp b/tools/driver/cc1as_main.cpp index f7ac17f14301..aa92541953fa 100644 --- a/tools/driver/cc1as_main.cpp +++ b/tools/driver/cc1as_main.cpp @@ -161,68 +161,68 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts, const unsigned IncludedFlagsBitmask = options::CC1AsOption; unsigned MissingArgIndex, MissingArgCount; - std::unique_ptr<InputArgList> Args( - OptTbl->ParseArgs(Argv.begin(), Argv.end(), MissingArgIndex, MissingArgCount, - IncludedFlagsBitmask)); + InputArgList Args = OptTbl->ParseArgs(Argv, MissingArgIndex, MissingArgCount, + IncludedFlagsBitmask); // Check for missing argument error. if (MissingArgCount) { Diags.Report(diag::err_drv_missing_argument) - << Args->getArgString(MissingArgIndex) << MissingArgCount; + << Args.getArgString(MissingArgIndex) << MissingArgCount; Success = false; } // Issue errors on unknown arguments. - for (const Arg *A : Args->filtered(OPT_UNKNOWN)) { - Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(*Args); + for (const Arg *A : Args.filtered(OPT_UNKNOWN)) { + Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(Args); Success = false; } // Construct the invocation. // Target Options - Opts.Triple = llvm::Triple::normalize(Args->getLastArgValue(OPT_triple)); - Opts.CPU = Args->getLastArgValue(OPT_target_cpu); - Opts.Features = Args->getAllArgValues(OPT_target_feature); + Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple)); + Opts.CPU = Args.getLastArgValue(OPT_target_cpu); + Opts.Features = Args.getAllArgValues(OPT_target_feature); // Use the default target triple if unspecified. if (Opts.Triple.empty()) Opts.Triple = llvm::sys::getDefaultTargetTriple(); // Language Options - Opts.IncludePaths = Args->getAllArgValues(OPT_I); - Opts.NoInitialTextSection = Args->hasArg(OPT_n); - Opts.SaveTemporaryLabels = Args->hasArg(OPT_msave_temp_labels); - Opts.GenDwarfForAssembly = Args->hasArg(OPT_g_Flag); - Opts.CompressDebugSections = Args->hasArg(OPT_compress_debug_sections); - if (Args->hasArg(OPT_gdwarf_2)) + Opts.IncludePaths = Args.getAllArgValues(OPT_I); + Opts.NoInitialTextSection = Args.hasArg(OPT_n); + Opts.SaveTemporaryLabels = Args.hasArg(OPT_msave_temp_labels); + Opts.GenDwarfForAssembly = Args.hasArg(OPT_g_Flag); + Opts.CompressDebugSections = Args.hasArg(OPT_compress_debug_sections); + if (Args.hasArg(OPT_gdwarf_2)) Opts.DwarfVersion = 2; - if (Args->hasArg(OPT_gdwarf_3)) + if (Args.hasArg(OPT_gdwarf_3)) Opts.DwarfVersion = 3; - if (Args->hasArg(OPT_gdwarf_4)) + if (Args.hasArg(OPT_gdwarf_4)) Opts.DwarfVersion = 4; - Opts.DwarfDebugFlags = Args->getLastArgValue(OPT_dwarf_debug_flags); - Opts.DwarfDebugProducer = Args->getLastArgValue(OPT_dwarf_debug_producer); - Opts.DebugCompilationDir = Args->getLastArgValue(OPT_fdebug_compilation_dir); - Opts.MainFileName = Args->getLastArgValue(OPT_main_file_name); + Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags); + Opts.DwarfDebugProducer = Args.getLastArgValue(OPT_dwarf_debug_producer); + Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir); + Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name); // Frontend Options - if (Args->hasArg(OPT_INPUT)) { + if (Args.hasArg(OPT_INPUT)) { bool First = true; - for (arg_iterator it = Args->filtered_begin(OPT_INPUT), - ie = Args->filtered_end(); it != ie; ++it, First=false) { + for (arg_iterator it = Args.filtered_begin(OPT_INPUT), + ie = Args.filtered_end(); + it != ie; ++it, First = false) { const Arg *A = it; if (First) Opts.InputFile = A->getValue(); else { - Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(*Args); + Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(Args); Success = false; } } } - Opts.LLVMArgs = Args->getAllArgValues(OPT_mllvm); - Opts.OutputPath = Args->getLastArgValue(OPT_o); - if (Arg *A = Args->getLastArg(OPT_filetype)) { + Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm); + Opts.OutputPath = Args.getLastArgValue(OPT_o); + if (Arg *A = Args.getLastArg(OPT_filetype)) { StringRef Name = A->getValue(); unsigned OutputType = StringSwitch<unsigned>(Name) .Case("asm", FT_Asm) @@ -230,25 +230,24 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts, .Case("obj", FT_Obj) .Default(~0U); if (OutputType == ~0U) { - Diags.Report(diag::err_drv_invalid_value) - << A->getAsString(*Args) << Name; + Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name; Success = false; } else Opts.OutputType = FileType(OutputType); } - Opts.ShowHelp = Args->hasArg(OPT_help); - Opts.ShowVersion = Args->hasArg(OPT_version); + Opts.ShowHelp = Args.hasArg(OPT_help); + Opts.ShowVersion = Args.hasArg(OPT_version); // Transliterate Options Opts.OutputAsmVariant = - getLastArgIntValue(*Args.get(), OPT_output_asm_variant, 0, Diags); - Opts.ShowEncoding = Args->hasArg(OPT_show_encoding); - Opts.ShowInst = Args->hasArg(OPT_show_inst); + getLastArgIntValue(Args, OPT_output_asm_variant, 0, Diags); + Opts.ShowEncoding = Args.hasArg(OPT_show_encoding); + Opts.ShowInst = Args.hasArg(OPT_show_inst); // Assemble Options - Opts.RelaxAll = Args->hasArg(OPT_mrelax_all); - Opts.NoExecStack = Args->hasArg(OPT_mno_exec_stack); - Opts.FatalWarnings = Args->hasArg(OPT_massembler_fatal_warnings); + Opts.RelaxAll = Args.hasArg(OPT_mrelax_all); + Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack); + Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings); return Success; } diff --git a/tools/driver/driver.cpp b/tools/driver/driver.cpp index ff81b8ac401c..5925447841fc 100644 --- a/tools/driver/driver.cpp +++ b/tools/driver/driver.cpp @@ -321,16 +321,16 @@ static void FixupDiagPrefixExeName(TextDiagnosticPrinter *DiagClient, // This lets us create the DiagnosticsEngine with a properly-filled-out // DiagnosticOptions instance. static DiagnosticOptions * -CreateAndPopulateDiagOpts(SmallVectorImpl<const char *> &argv) { +CreateAndPopulateDiagOpts(ArrayRef<const char *> argv) { auto *DiagOpts = new DiagnosticOptions; std::unique_ptr<OptTable> Opts(createDriverOptTable()); unsigned MissingArgIndex, MissingArgCount; - std::unique_ptr<InputArgList> Args(Opts->ParseArgs( - argv.begin() + 1, argv.end(), MissingArgIndex, MissingArgCount)); + InputArgList Args = + Opts->ParseArgs(argv.slice(1), MissingArgIndex, MissingArgCount); // We ignore MissingArgCount and the return value of ParseDiagnosticArgs. // Any errors that would be diagnosed here will also be diagnosed later, // when the DiagnosticsEngine actually exists. - (void) ParseDiagnosticArgs(*DiagOpts, *Args); + (void)ParseDiagnosticArgs(*DiagOpts, Args); return DiagOpts; } diff --git a/tools/libclang/CIndex.cpp b/tools/libclang/CIndex.cpp index 2216ec61afa7..bf5b58253ad0 100644 --- a/tools/libclang/CIndex.cpp +++ b/tools/libclang/CIndex.cpp @@ -1880,6 +1880,9 @@ public: void VisitOMPBarrierDirective(const OMPBarrierDirective *D); void VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D); void VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *D); + void + VisitOMPCancellationPointDirective(const OMPCancellationPointDirective *D); + void VisitOMPCancelDirective(const OMPCancelDirective *D); void VisitOMPFlushDirective(const OMPFlushDirective *D); void VisitOMPOrderedDirective(const OMPOrderedDirective *D); void VisitOMPAtomicDirective(const OMPAtomicDirective *D); @@ -1934,8 +1937,8 @@ void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) { } void EnqueueVisitor::EnqueueChildren(const Stmt *S) { unsigned size = WL.size(); - for (Stmt::const_child_range Child = S->children(); Child; ++Child) { - AddStmt(*Child); + for (const Stmt *SubStmt : S->children()) { + AddStmt(SubStmt); } if (size == WL.size()) return; @@ -2098,6 +2101,9 @@ OMPClauseEnqueue::VisitOMPCopyprivateClause(const OMPCopyprivateClause *C) { void OMPClauseEnqueue::VisitOMPFlushClause(const OMPFlushClause *C) { VisitOMPClauseList(C); } +void OMPClauseEnqueue::VisitOMPDependClause(const OMPDependClause *C) { + VisitOMPClauseList(C); +} } void EnqueueVisitor::EnqueueChildren(const OMPClause *S) { @@ -2504,6 +2510,15 @@ void EnqueueVisitor::VisitOMPTeamsDirective(const OMPTeamsDirective *D) { VisitOMPExecutableDirective(D); } +void EnqueueVisitor::VisitOMPCancellationPointDirective( + const OMPCancellationPointDirective *D) { + VisitOMPExecutableDirective(D); +} + +void EnqueueVisitor::VisitOMPCancelDirective(const OMPCancelDirective *D) { + VisitOMPExecutableDirective(D); +} + void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) { EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S); } @@ -3827,12 +3842,11 @@ CXString clang_Cursor_getMangling(CXCursor C) { // Now apply backend mangling. std::unique_ptr<llvm::DataLayout> DL( new llvm::DataLayout(Ctx.getTargetInfo().getTargetDescription())); - llvm::Mangler BackendMangler(DL.get()); std::string FinalBuf; llvm::raw_string_ostream FinalBufOS(FinalBuf); - BackendMangler.getNameWithPrefix(FinalBufOS, - llvm::Twine(FrontendBufOS.str())); + llvm::Mangler::getNameWithPrefix(FinalBufOS, llvm::Twine(FrontendBufOS.str()), + *DL); return cxstring::createDup(FinalBufOS.str()); } @@ -4281,6 +4295,10 @@ CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) { return cxstring::createRef("OMPTargetDirective"); case CXCursor_OMPTeamsDirective: return cxstring::createRef("OMPTeamsDirective"); + case CXCursor_OMPCancellationPointDirective: + return cxstring::createRef("OMPCancellationPointDirective"); + case CXCursor_OMPCancelDirective: + return cxstring::createRef("OMPCancelDirective"); case CXCursor_OverloadCandidate: return cxstring::createRef("OverloadCandidate"); } diff --git a/tools/libclang/CXCursor.cpp b/tools/libclang/CXCursor.cpp index b8bb28ed8530..fe9ba4eac1b1 100644 --- a/tools/libclang/CXCursor.cpp +++ b/tools/libclang/CXCursor.cpp @@ -588,6 +588,12 @@ CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent, case Stmt::OMPTeamsDirectiveClass: K = CXCursor_OMPTeamsDirective; break; + case Stmt::OMPCancellationPointDirectiveClass: + K = CXCursor_OMPCancellationPointDirective; + break; + case Stmt::OMPCancelDirectiveClass: + K = CXCursor_OMPCancelDirective; + break; } CXCursor C = { K, 0, { Parent, S, TU } }; diff --git a/tools/scan-build/ccc-analyzer b/tools/scan-build/ccc-analyzer index ffe6859672cf..14591aef57c8 100755 --- a/tools/scan-build/ccc-analyzer +++ b/tools/scan-build/ccc-analyzer @@ -22,6 +22,33 @@ use File::Basename; use Text::ParseWords; ##===----------------------------------------------------------------------===## +# List form 'system' with STDOUT and STDERR captured. +##===----------------------------------------------------------------------===## + +sub silent_system { + my $HtmlDir = shift; + my $Command = shift; + + # Save STDOUT and STDERR and redirect to a temporary file. + open OLDOUT, ">&", \*STDOUT; + open OLDERR, ">&", \*STDERR; + my ($TmpFH, $TmpFile) = tempfile("temp_buf_XXXXXX", + DIR => $HtmlDir, + UNLINK => 1); + open(STDOUT, ">$TmpFile"); + open(STDERR, ">&", \*STDOUT); + + # Invoke 'system', STDOUT and STDERR are output to a temporary file. + system $Command, @_; + + # Restore STDOUT and STDERR. + open STDOUT, ">&", \*OLDOUT; + open STDERR, ">&", \*OLDERR; + + return $TmpFH; +} + +##===----------------------------------------------------------------------===## # Compiler command setup. ##===----------------------------------------------------------------------===## @@ -145,7 +172,7 @@ sub ProcessClangFailure { print OUT "@$Args\n"; close OUT; `uname -a >> $PPFile.info.txt 2>&1`; - `$Compiler -v >> $PPFile.info.txt 2>&1`; + `"$Compiler" -v >> $PPFile.info.txt 2>&1`; rename($ofile, "$PPFile.stderr.txt"); return (basename $PPFile); } @@ -155,27 +182,15 @@ sub ProcessClangFailure { ##----------------------------------------------------------------------------## sub GetCCArgs { + my $HtmlDir = shift; my $mode = shift; my $Args = shift; - - pipe (FROM_CHILD, TO_PARENT); - my $pid = fork(); - if ($pid == 0) { - close FROM_CHILD; - open(STDOUT,">&", \*TO_PARENT); - open(STDERR,">&", \*TO_PARENT); - exec $Clang, "-###", $mode, @$Args; - } - close(TO_PARENT); my $line; - while (<FROM_CHILD>) { + my $OutputStream = silent_system($HtmlDir, $Clang, "-###", $mode, @$Args); + while (<$OutputStream>) { next if (!/\s"?-cc1"?\s/); $line = $_; } - - waitpid($pid,0); - close(FROM_CHILD); - die "could not find clang line\n" if (!defined $line); # Strip leading and trailing whitespace characters. $line =~ s/^\s+|\s+$//g; @@ -207,7 +222,7 @@ sub Analyze { $Cmd = $Clang; # Create arguments for doing regular parsing. - my $SyntaxArgs = GetCCArgs("-fsyntax-only", \@Args); + my $SyntaxArgs = GetCCArgs($HtmlDir, "-fsyntax-only", \@Args); @CmdArgsSansAnalyses = @$SyntaxArgs; # Create arguments for doing static analysis. @@ -230,7 +245,7 @@ sub Analyze { push @Args, "-Xclang", "-analyzer-viz-egraph-ubigraph"; } - my $AnalysisArgs = GetCCArgs("--analyze", \@Args); + my $AnalysisArgs = GetCCArgs($HtmlDir, "--analyze", \@Args); @CmdArgs = @$AnalysisArgs; } @@ -255,31 +270,19 @@ sub Analyze { print STDERR "#SHELL (cd '$dir' && @PrintArgs)\n"; } - # Capture the STDERR of clang and send it to a temporary file. - # Capture the STDOUT of clang and reroute it to ccc-analyzer's STDERR. + # Save STDOUT and STDERR of clang to a temporary file and reroute + # all clang output to ccc-analyzer's STDERR. # We save the output file in the 'crashes' directory if clang encounters # any problems with the file. - pipe (FROM_CHILD, TO_PARENT); - my $pid = fork(); - if ($pid == 0) { - close FROM_CHILD; - open(STDOUT,">&", \*TO_PARENT); - open(STDERR,">&", \*TO_PARENT); - exec $Cmd, @CmdArgs; - } - - close TO_PARENT; my ($ofh, $ofile) = tempfile("clang_output_XXXXXX", DIR => $HtmlDir); - - while (<FROM_CHILD>) { + + my $OutputStream = silent_system($HtmlDir, $Cmd, @CmdArgs); + while ( <$OutputStream> ) { print $ofh $_; print STDERR $_; } - close $ofh; - - waitpid($pid,0); - close(FROM_CHILD); my $Result = $?; + close $ofh; # Did the command die because of a signal? if ($ReportFailures) { diff --git a/tools/scan-build/scan-build b/tools/scan-build/scan-build index ac8e22e8cc72..d7cadc3e59e1 100755 --- a/tools/scan-build/scan-build +++ b/tools/scan-build/scan-build @@ -1232,16 +1232,9 @@ ENDTEXT } my %EnabledCheckers; foreach my $lang ("c", "objective-c", "objective-c++", "c++") { - pipe(FROM_CHILD, TO_PARENT); - my $pid = fork(); - if ($pid == 0) { - close FROM_CHILD; - open(STDOUT,">&", \*TO_PARENT); - open(STDERR,">&", \*TO_PARENT); - exec $Clang, ( @PluginLoadCommandline_xclang, '--analyze', '-x', $lang, '-', '-###'); - } - close(TO_PARENT); - while(<FROM_CHILD>) { + my $ExecLine = join(' ', qq/"$Clang"/, @PluginLoadCommandline_xclang, "--analyze", "-x", $lang, "-", "-###", "2>&1", "|"); + open(PS, $ExecLine); + while (<PS>) { foreach my $val (split /\s+/) { $val =~ s/\"//g; if ($val =~ /-analyzer-checker\=([^\s]+)/) { @@ -1249,23 +1242,14 @@ ENDTEXT } } } - waitpid($pid,0); - close(FROM_CHILD); } # Query clang for complete list of checkers. if (defined $Clang && -x $Clang) { - pipe(FROM_CHILD, TO_PARENT); - my $pid = fork(); - if ($pid == 0) { - close FROM_CHILD; - open(STDOUT,">&", \*TO_PARENT); - open(STDERR,">&", \*TO_PARENT); - exec $Clang, ('-cc1', @PluginsToLoad , '-analyzer-checker-help'); - } - close(TO_PARENT); + my $ExecLine = join(' ', qq/"$Clang"/, "-cc1", @PluginsToLoad, "-analyzer-checker-help", "2>&1", "|"); + open(PS, $ExecLine); my $foundCheckers = 0; - while(<FROM_CHILD>) { + while (<PS>) { if (/CHECKERS:/) { $foundCheckers = 1; last; @@ -1277,7 +1261,7 @@ ENDTEXT else { print("\nAVAILABLE CHECKERS:\n\n"); my $skip = 0; - while(<FROM_CHILD>) { + while(<PS>) { if (/experimental/) { $skip = 1; next; @@ -1314,10 +1298,9 @@ ENDTEXT } print $_; } - print "\nNOTE: \"+\" indicates that an analysis is enabled by default.\n" + print "\nNOTE: \"+\" indicates that an analysis is enabled by default.\n"; } - waitpid($pid,0); - close(FROM_CHILD); + close PS; } print <<ENDTEXT diff --git a/unittests/ASTMatchers/ASTMatchersTest.cpp b/unittests/ASTMatchers/ASTMatchersTest.cpp index ae363e974b5d..8ef3f15e4c08 100644 --- a/unittests/ASTMatchers/ASTMatchersTest.cpp +++ b/unittests/ASTMatchers/ASTMatchersTest.cpp @@ -482,6 +482,10 @@ TEST(DeclarationMatcher, MatchAnyOf) { EXPECT_TRUE(matches("int F() { return 1 + 2; }", MixedTypes)); EXPECT_TRUE(matches("int F() { if (true) return 1; }", MixedTypes)); EXPECT_TRUE(notMatches("int F() { return 1; }", MixedTypes)); + + EXPECT_TRUE( + matches("void f() try { } catch (int) { } catch (...) { }", + catchStmt(anyOf(hasDescendant(varDecl()), isCatchAll())))); } TEST(DeclarationMatcher, MatchHas) { @@ -3321,6 +3325,10 @@ TEST(ExceptionHandling, SimpleCases) { throwExpr())); EXPECT_TRUE(matches("void foo() try { throw 5;} catch(int X) { }", throwExpr())); + EXPECT_TRUE(matches("void foo() try { throw; } catch(...) { }", + catchStmt(isCatchAll()))); + EXPECT_TRUE(notMatches("void foo() try { throw; } catch(int) { }", + catchStmt(isCatchAll()))); } TEST(HasConditionVariableStatement, DoesNotMatchCondition) { diff --git a/unittests/CodeGen/BufferSourceTest.cpp b/unittests/CodeGen/BufferSourceTest.cpp index b2a8ba580844..e80e83bd2887 100644 --- a/unittests/CodeGen/BufferSourceTest.cpp +++ b/unittests/CodeGen/BufferSourceTest.cpp @@ -62,6 +62,8 @@ TEST(BufferSourceTest, EmitCXXGlobalInitFunc) { CreateLLVMCodeGen( compiler.getDiagnostics(), "EmitCXXGlobalInitFuncTest", + compiler.getHeaderSearchOpts(), + compiler.getPreprocessorOpts(), compiler.getCodeGenOpts(), llvm::getGlobalContext()))); diff --git a/unittests/Format/FormatTest.cpp b/unittests/Format/FormatTest.cpp index ed2658b3c143..0d85789a1ddb 100644 --- a/unittests/Format/FormatTest.cpp +++ b/unittests/Format/FormatTest.cpp @@ -2391,6 +2391,27 @@ TEST_F(FormatTest, FormatObjCTryCatch) { "});\n"); } +TEST_F(FormatTest, FormatObjCAutoreleasepool) { + FormatStyle Style = getLLVMStyle(); + verifyFormat("@autoreleasepool {\n" + " f();\n" + "}\n" + "@autoreleasepool {\n" + " f();\n" + "}\n", + Style); + Style.BreakBeforeBraces = FormatStyle::BS_Allman; + verifyFormat("@autoreleasepool\n" + "{\n" + " f();\n" + "}\n" + "@autoreleasepool\n" + "{\n" + " f();\n" + "}\n", + Style); +} + TEST_F(FormatTest, StaticInitializers) { verifyFormat("static SomeClass SC = {1, 'a'};"); @@ -3163,6 +3184,8 @@ TEST_F(FormatTest, LayoutNestedBlocks) { "}, a);", Style); + verifyFormat("SomeFunction({MACRO({ return output; }), b});"); + verifyNoCrash("^{v^{a}}"); } @@ -3900,10 +3923,12 @@ TEST_F(FormatTest, BreaksDesireably) { " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); - // Indent consistently independent of call expression. + // Indent consistently independent of call expression and unary operator. + verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" + " dddddddddddddddddddddddddddddd));"); + verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" + " dddddddddddddddddddddddddddddd));"); verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" - " dddddddddddddddddddddddddddddd));\n" - "aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" " dddddddddddddddddddddddddddddd));"); // This test case breaks on an incorrect memoization, i.e. an optimization not @@ -4595,30 +4620,50 @@ TEST_F(FormatTest, AlignsStringLiterals) { " \"c\";"); } -TEST_F(FormatTest, AlwaysBreakAfterDefinitionReturnType) { - FormatStyle AfterType = getLLVMStyle(); - AfterType.AlwaysBreakAfterDefinitionReturnType = true; +TEST_F(FormatTest, DefinitionReturnTypeBreakingStyle) { + FormatStyle Style = getLLVMStyle(); + Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_TopLevel; + verifyFormat("class C {\n" + " int f() { return 1; }\n" + "};\n" + "int\n" + "f() {\n" + " return 1;\n" + "}", + Style); + Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; + verifyFormat("class C {\n" + " int\n" + " f() {\n" + " return 1;\n" + " }\n" + "};\n" + "int\n" + "f() {\n" + " return 1;\n" + "}", + Style); verifyFormat("const char *\n" "f(void) {\n" // Break here. " return \"\";\n" "}\n" "const char *bar(void);\n", // No break here. - AfterType); + Style); verifyFormat("template <class T>\n" "T *\n" "f(T &c) {\n" // Break here. " return NULL;\n" "}\n" "template <class T> T *f(T &c);\n", // No break here. - AfterType); - AfterType.BreakBeforeBraces = FormatStyle::BS_Stroustrup; + Style); + Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; verifyFormat("const char *\n" "f(void)\n" // Break here. "{\n" " return \"\";\n" "}\n" "const char *bar(void);\n", // No break here. - AfterType); + Style); verifyFormat("template <class T>\n" "T *\n" // Problem here: no line break "f(T &c)\n" // Break here. @@ -4626,7 +4671,7 @@ TEST_F(FormatTest, AlwaysBreakAfterDefinitionReturnType) { " return NULL;\n" "}\n" "template <class T> T *f(T &c);\n", // No break here. - AfterType); + Style); } TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { @@ -5169,7 +5214,7 @@ TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { " aaaaa)) {\n" "}"); verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" - " aaaaa));"); + " aaaaa));"); verifyFormat("*aaa = aaaaaaa( // break\n" " bbbbbb);"); } @@ -5213,11 +5258,6 @@ TEST_F(FormatTest, UnderstandsOverloadedOperators) { verifyGoogleFormat("operator ::A();"); verifyFormat("using A::operator+;"); - - verifyFormat("string // break\n" - "operator()() & {}"); - verifyFormat("string // break\n" - "operator()() && {}"); } TEST_F(FormatTest, UnderstandsFunctionRefQualification) { @@ -5481,6 +5521,14 @@ TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { verifyFormat("A = new SomeType *[Length]();", PointerMiddle); verifyFormat("A = new SomeType *[Length];", PointerMiddle); verifyFormat("T ** t = new T *;", PointerMiddle); + + // Member function reference qualifiers aren't binary operators. + verifyFormat("string // break\n" + "operator()() & {}"); + verifyFormat("string // break\n" + "operator()() && {}"); + verifyGoogleFormat("template <typename T>\n" + "auto x() & -> int {}"); } TEST_F(FormatTest, UnderstandsAttributes) { @@ -9018,7 +9066,6 @@ TEST_F(FormatTest, ParsesConfigurationBools) { CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine); CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); - CHECK_PARSE_BOOL(AlwaysBreakAfterDefinitionReturnType); CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations); CHECK_PARSE_BOOL(BinPackParameters); CHECK_PARSE_BOOL(BinPackArguments); @@ -9151,6 +9198,15 @@ TEST_F(FormatTest, ParsesConfiguration) { FormatStyle::BS_Allman); CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); + Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; + CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", + AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); + CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", + AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); + CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", + AlwaysBreakAfterDefinitionReturnType, + FormatStyle::DRTBS_TopLevel); + Style.NamespaceIndentation = FormatStyle::NI_All; CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, FormatStyle::NI_None); diff --git a/unittests/Format/FormatTestJS.cpp b/unittests/Format/FormatTestJS.cpp index 15d62eb66c33..e6c12f4ce0f1 100644 --- a/unittests/Format/FormatTestJS.cpp +++ b/unittests/Format/FormatTestJS.cpp @@ -579,6 +579,7 @@ TEST_F(FormatTestJS, RegexLiteralClassification) { verifyFormat("var x = a && /abc/.test(y);"); verifyFormat("var x = a || /abc/.test(y);"); verifyFormat("var x = a + /abc/.search(y);"); + verifyFormat("/abc/.search(y);"); verifyFormat("var regexs = {/abc/, /abc/};"); verifyFormat("return /abc/;"); @@ -624,10 +625,23 @@ TEST_F(FormatTestJS, RegexLiteralSpecialCharacters) { verifyFormat("var regex = /\a\\//g;"); verifyFormat("var regex = /a\\//;\n" "var x = 0;"); + EXPECT_EQ("var regex = /'/g;", format("var regex = /'/g ;")); + EXPECT_EQ("var regex = /'/g; //'", format("var regex = /'/g ; //'")); EXPECT_EQ("var regex = /\\/*/;\n" "var x = 0;", format("var regex = /\\/*/;\n" "var x=0;")); + EXPECT_EQ("var x = /a\\//;", format("var x = /a\\// \n;")); + verifyFormat("var regex = /\"/;", getGoogleJSStyleWithColumns(16)); + verifyFormat("var regex =\n" + " /\"/;", + getGoogleJSStyleWithColumns(15)); + verifyFormat("var regex = //\n" + " /a/;"); + verifyFormat("var regexs = [\n" + " /d/, //\n" + " /aa/, //\n" + "];"); } TEST_F(FormatTestJS, RegexLiteralModifiers) { @@ -789,15 +803,11 @@ TEST_F(FormatTestJS, TemplateStrings) { " ${ name }\n" " !`;")); - // FIXME: +1 / -1 offsets are to work around clang-format miscalculating - // widths for unknown tokens that are not whitespace (e.g. '`'). Remove when - // the code is corrected. - verifyFormat("var x =\n" " `hello ${world}` >= some();", getGoogleJSStyleWithColumns(34)); // Barely doesn't fit. verifyFormat("var x = `hello ${world}` >= some();", - getGoogleJSStyleWithColumns(35 + 1)); // Barely fits. + getGoogleJSStyleWithColumns(35)); // Barely fits. EXPECT_EQ("var x = `hello\n" " ${world}` >=\n" " some();", @@ -812,10 +822,14 @@ TEST_F(FormatTestJS, TemplateStrings) { " ${world}` >= some();", getGoogleJSStyleWithColumns(22))); // Barely fits. - verifyFormat("var x =\n `h`;", getGoogleJSStyleWithColumns(13 - 1)); + verifyFormat("var x =\n" + " `h`;", + getGoogleJSStyleWithColumns(11)); EXPECT_EQ( "var x =\n `multi\n line`;", - format("var x = `multi\n line`;", getGoogleJSStyleWithColumns(14 - 1))); + format("var x = `multi\n line`;", getGoogleJSStyleWithColumns(13))); + verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`);"); // Make sure template strings get a proper ColumnWidth assigned, even if they // are first token in line. @@ -869,6 +883,8 @@ TEST_F(FormatTestJS, TypeArguments) { verifyFormat("class C extends D<E> implements F<G>, H<I> {}"); verifyFormat("function f(a: List<any> = null) {}"); verifyFormat("function f(): List<any> {}"); + verifyFormat("function aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa():\n" + " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}"); } TEST_F(FormatTestJS, OptionalTypes) { diff --git a/unittests/Format/FormatTestJava.cpp b/unittests/Format/FormatTestJava.cpp index 4c161e0180af..8e590879f6e2 100644 --- a/unittests/Format/FormatTestJava.cpp +++ b/unittests/Format/FormatTestJava.cpp @@ -67,6 +67,8 @@ TEST_F(FormatTestJava, FormatsInstanceOfLikeOperators) { verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaa instanceof\n" " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", Style); + verifyFormat("return aaaaaaaaaaaaaaaaaaa instanceof bbbbbbbbbbbbbbbbbbbbbbb\n" + " && ccccccccccccccccccc instanceof dddddddddddddddddddddd;"); } TEST_F(FormatTestJava, Chromium) { diff --git a/unittests/Format/FormatTestProto.cpp b/unittests/Format/FormatTestProto.cpp index ac8fcbdda4fc..74f7005b219f 100644 --- a/unittests/Format/FormatTestProto.cpp +++ b/unittests/Format/FormatTestProto.cpp @@ -63,6 +63,10 @@ TEST_F(FormatTestProto, FormatsMessages) { "}"); } +TEST_F(FormatTestProto, KeywordsInOtherLanguages) { + verifyFormat("optional string operator = 1;"); +} + TEST_F(FormatTestProto, FormatsEnums) { verifyFormat("enum Type {\n" " UNKNOWN = 0;\n" diff --git a/utils/analyzer/CmpRuns.py b/utils/analyzer/CmpRuns.py index 30157bed3d42..a1f7a5649c5e 100755 --- a/utils/analyzer/CmpRuns.py +++ b/utils/analyzer/CmpRuns.py @@ -300,7 +300,7 @@ def dumpScanBuildResultsDiff(dirA, dirB, opts, deleteEmpty=True): print >>auxLog, "('TOTAL NEW REPORTS', %r)" % TotalReports print >>auxLog, "('TOTAL DIFFERENCES', %r)" % foundDiffs - return foundDiffs + return foundDiffs, len(resultsA.diagnostics), len(resultsB.diagnostics) def main(): from optparse import OptionParser diff --git a/utils/analyzer/SATestBuild.py b/utils/analyzer/SATestBuild.py index 0a2c836b26f0..20839c24e18a 100644 --- a/utils/analyzer/SATestBuild.py +++ b/utils/analyzer/SATestBuild.py @@ -46,6 +46,7 @@ import math import shutil import time import plistlib +import argparse from subprocess import check_call, CalledProcessError #------------------------------------------------------------------------------ @@ -216,6 +217,8 @@ def runScanBuild(Dir, SBOutputDir, PBuildLogFile): SBPrefix = "scan-build " + SBOptions + " " for Command in SBCommandFile: Command = Command.strip() + if len(Command) == 0: + continue; # If using 'make', auto imply a -jX argument # to speed up analysis. xcodebuild will # automatically use the maximum number of cores. @@ -277,7 +280,7 @@ def runAnalyzePreprocessed(Dir, SBOutputDir, Mode): # Build and call the analyzer command. OutputOption = "-o " + os.path.join(PlistPath, FileName) + ".plist " - Command = CmdPrefix + OutputOption + os.path.join(Dir, FileName) + Command = CmdPrefix + OutputOption + FileName LogFile = open(os.path.join(FailPath, FileName + ".stderr.txt"), "w+b") try: if Verbose == 1: @@ -404,7 +407,11 @@ class Discarder(object): pass # do nothing # Compare the warnings produced by scan-build. -def runCmpResults(Dir): +# Strictness defines the success criteria for the test: +# 0 - success if there are no crashes or analyzer failure. +# 1 - success if there are no difference in the number of reported bugs. +# 2 - success if all the bug reports are identical. +def runCmpResults(Dir, Strictness = 0): TBegin = time.time() RefDir = os.path.join(Dir, SBOutputDirReferencePrefix + SBOutputDirName) @@ -448,11 +455,18 @@ def runCmpResults(Dir): OLD_STDOUT = sys.stdout sys.stdout = Discarder() # Scan the results, delete empty plist files. - NumDiffs = CmpRuns.dumpScanBuildResultsDiff(RefDir, NewDir, Opts, False) + NumDiffs, ReportsInRef, ReportsInNew = \ + CmpRuns.dumpScanBuildResultsDiff(RefDir, NewDir, Opts, False) sys.stdout = OLD_STDOUT if (NumDiffs > 0) : print "Warning: %r differences in diagnostics. See %s" % \ (NumDiffs, DiffsPath,) + if Strictness >= 2 and NumDiffs > 0: + print "Error: Diffs found in strict mode (2)." + sys.exit(-1) + elif Strictness >= 1 and ReportsInRef != ReportsInNew: + print "Error: The number of results are different in strict mode (1)." + sys.exit(-1) print "Diagnostic comparison complete (time: %.2f)." % (time.time()-TBegin) return (NumDiffs > 0) @@ -486,7 +500,7 @@ def updateSVN(Mode, ProjectsMap): print "Error: SVN update failed." sys.exit(-1) -def testProject(ID, ProjectBuildMode, IsReferenceBuild=False, Dir=None): +def testProject(ID, ProjectBuildMode, IsReferenceBuild=False, Dir=None, Strictness = 0): print " \n\n--- Building project %s" % (ID,) TBegin = time.time() @@ -505,12 +519,12 @@ def testProject(ID, ProjectBuildMode, IsReferenceBuild=False, Dir=None): checkBuild(SBOutputDir) if IsReferenceBuild == False: - runCmpResults(Dir) + runCmpResults(Dir, Strictness) print "Completed tests for project %s (time: %.2f)." % \ (ID, (time.time()-TBegin)) -def testAll(IsReferenceBuild = False, UpdateSVN = False): +def testAll(IsReferenceBuild = False, UpdateSVN = False, Strictness = 0): PMapFile = open(getProjectMapPath(), "rb") try: # Validate the input. @@ -532,7 +546,7 @@ def testAll(IsReferenceBuild = False, UpdateSVN = False): # Test the projects. PMapFile.seek(0) for I in csv.reader(PMapFile): - testProject(I[0], int(I[1]), IsReferenceBuild) + testProject(I[0], int(I[1]), IsReferenceBuild, None, Strictness) # Add reference results to SVN. if UpdateSVN == True: @@ -545,18 +559,25 @@ def testAll(IsReferenceBuild = False, UpdateSVN = False): PMapFile.close() if __name__ == '__main__': + # Parse command line arguments. + Parser = argparse.ArgumentParser(description='Test the Clang Static Analyzer.') + Parser.add_argument('--strictness', dest='strictness', type=int, default=0, + help='0 to fail on runtime errors, 1 to fail when the number\ + of found bugs are different from the reference, 2 to \ + fail on any difference from the reference. Default is 0.') + Parser.add_argument('-r', dest='regenerate', action='store_true', default=False, + help='Regenerate reference output.') + Parser.add_argument('-rs', dest='update_reference', action='store_true', + default=False, help='Regenerate reference output and update svn.') + Args = Parser.parse_args() + IsReference = False UpdateSVN = False - if len(sys.argv) >= 2: - if sys.argv[1] == "-r": - IsReference = True - elif sys.argv[1] == "-rs": - IsReference = True - UpdateSVN = True - else: - print >> sys.stderr, 'Usage: ', sys.argv[0],\ - '[-r|-rs]' \ - 'Use -r to regenerate reference output' \ - 'Use -rs to regenerate reference output and update svn' - - testAll(IsReference, UpdateSVN) + Strictness = Args.strictness + if Args.regenerate: + IsReference = True + elif Args.update_reference: + IsReference = True + UpdateSVN = True + + testAll(IsReference, UpdateSVN, Strictness) |