Lines Matching +refs:clang +refs:prefix +refs:header
16 `Clang Web Site <http://clang.llvm.org>`_ or the `LLVM Web
23 `Clang Static Analyzer <http://clang-analyzer.llvm.org>`_, please see its web
47 Clang also provides an alternative driver, :ref:`clang-cl`, that is designed
245 .. option:: -fdiagnostics-format=clang/msvc/vi
253 **clang** (default)
529 Disable auto-generation of preprocessed source files during a clang crash.
563 $ clang -O2 -Rpass=inline code.cc -o code
683 by running '``clang --print-diagnostic-categories``'.
711 particularly useful when writing a header file that will be compiled by
720 #pragma clang diagnostic push
721 #pragma clang diagnostic ignored "-Wmultichar"
725 #pragma clang diagnostic pop
765 an included file is treated as a system header if it is found in an
770 being a system header. No warnings will be produced from the location of
777 #pragma clang system_header
781 The :option:`--system-header-prefix=` and :option:`--no-system-header-prefix=`
784 is found within a header search path and starts with a system prefix, the
785 header is treated as a system header. The last prefix on the
786 command-line which matches the specified header name takes precedence.
791 $ clang -Ifoo -isystem bar --system-header-prefix=x/ \
792 --no-system-header-prefix=x/y/
794 Here, ``#include "x/a.h"`` is treated as including a system header, even
795 if the header is found in ``foo``, and ``#include "x/y/b.h"`` is treated
796 as not including a system header, even if the header is found in
800 directory is treated as including a system header if the including file
801 is treated as a system header.
820 `static analyzer <http://clang-analyzer.llvm.org>`_ can also be
822 `annotations <http://clang-analyzer.llvm.org/annotations.html>`_ and the
824 page <http://clang-analyzer.llvm.org/faq.html#exclude_code>`_ for more
835 the same (and often large) header files to be included by multiple
838 headers. Precompiled header files, which represent one of many ways to
841 some of the work needed to process a corresponding header file. While
850 :option:`-x <language>-header` option. This mirrors the interface in GCC
855 $ gcc -x c-header test.h -o test.h.gch
856 $ clang -x c-header test.h -o test.h.pch
861 A PCH file can then be used as a prefix header when a :option:`-include`
862 option is passed to ``clang``:
866 $ clang -include test.h test.c -o test
868 The ``clang`` driver will first check if a PCH file for ``test.h`` is
881 $ clang -x c-header test.h -o test.h.pch
884 $ clang test.c -o test
886 In this example, ``clang`` will not automatically use the PCH file for
893 It is sometimes necessary to build a precompiled header from headers
895 might build a precompiled header within the build tree that is then
901 To build a relocatable precompiled header, place your headers into a
903 if you want to build a precompiled header for the header ``mylib.h``
905 ``build/usr/include`` and place the header ``mylib.h`` into that
910 Building a relocatable precompiled header requires two additional
918 # clang -x c-header --relocatable-pch -isysroot /path/to/build /path/to/build/mylib.h mylib.h.pch
921 PCH file are found from the system header root. For example, ``mylib.h``
930 and the precompiled header cannot be generated after headers have been
1218 $ clang++ -O2 -gline-tables-only code.cc -o code
1260 $ clang++ -O2 -gline-tables-only -fprofile-sample-use=code.prof code.cc -o code
1326 function header specify how many total samples were accumulated in the
1345 defined. So, if the function has its header at line 280, the offset
1428 $ clang++ -O2 -fprofile-instr-generate code.cc -o code
1443 the input expected by clang. Use the ``merge`` command of the
1458 $ clang++ -O2 -fprofile-instr-use=code.profdata code.cc -o code
1461 profile. As you make changes to your code, clang may no longer be able to
1481 $ clang++ -O2 -fprofile-generate=yyy/zzz code.cc -o code
1623 The support for standard C in clang is feature-complete except for the
1626 Extensions supported by clang
1634 clang supports the -std option, which changes what language mode clang
1637 specified, clang defaults to gnu11 mode. Many C99 and C11 features are
1689 clang tries to be compatible with gcc as much as possible, but some gcc
1692 - clang does not support #pragma weak (`bug
1696 - clang does not support decimal floating point types (``_Decimal32`` and
1700 - clang does not support nested functions; this is a complex feature
1713 - clang does not support global register variables; this is unlikely to
1716 - clang does not support static initialization of flexible array
1719 - clang does not support
1723 that because clang pretends to be like GCC 4.2, and this extension
1725 extension with clang at the moment.
1726 - clang does not support the gcc extension for forward-declaring
1742 - clang does not support the gcc extension that allows variable-length
1745 the extension appears to be rarely used. Note that clang *does*
1748 - clang does not have an equivalent to gcc's "fold"; this means that
1749 clang doesn't accept some constructs gcc might accept in contexts
1752 - clang does not support ``__builtin_apply`` and friends; this extension
1760 clang has some experimental support for extensions from Microsoft Visual
1768 clang has a ``-fms-compatibility`` flag that makes clang accept enough
1771 <http://clang.llvm.org/compatibility.html#dep_lookup_bases>`_, which is
1772 a common compatibility issue with clang. This flag is enabled by default
1775 ``-fdelayed-template-parsing`` lets clang delay parsing of function template
1779 - clang allows setting ``_MSC_VER`` with ``-fmsc-version=``. It defaults to
1781 and can greatly affect what Windows SDK and c++stdlib headers clang
1783 - clang does not support the Microsoft extension where anonymous record
1785 - clang supports the Microsoft ``#pragma pack`` feature for controlling
1787 where MSVC and GCC are incompatible clang follows the MSVC
1789 - clang supports the Microsoft ``#pragma comment(lib, "foo.lib")`` feature for
1792 - clang supports the Microsoft ``#pragma comment(linker, "/flag:foo")`` feature
1795 - clang defaults to C++11 for Windows targets.
1802 clang fully implements all of standard C++98 except for exported
1886 For the X86 target, clang supports the :option:`-m16` command line
1913 clang currently contains some support for other architectures (e.g. Sparc);
1917 clang contains limited support for the MSP430 embedded processor, but
1918 both the clang support and the LLVM backend support are highly
1923 platform is quite easy; see ``lib/Basic/Targets.cpp`` in the clang source
1969 - ``GCC versions 4.5.0 to 4.5.3, 4.6.0 to 4.6.2, or 4.7.0 (for the C++ header search path)``
1971 - ``some_directory/bin/clang.exe``
1972 - ``some_directory/bin/clang++.exe``
1992 clang-cl
1995 clang-cl is an alternative command-line interface to Clang driver, designed for
1998 To enable clang-cl to find system headers, libraries, and the linker when run
2003 clang-cl can also be used from inside Visual Studio by using an LLVM Platform
2009 To be compatible with cl.exe, clang-cl supports most of the same command-line
2013 Options that are known to clang-cl, but not currently supported, are ignored
2018 clang-cl.exe: warning: argument unused during compilation: '/AI'
2022 Options that are not known to clang-cl will cause errors. If they are spelled with a
2027 clang-cl.exe: error: no such file or directory: '/foobar'
2029 Please `file a bug <http://llvm.org/bugs/enter_bug.cgi?product=clang&component=Driver>`_
2030 for any valid cl.exe flags that clang-cl does not understand.
2032 Execute ``clang-cl /?`` to see a list of supported options:
2045 /fallback Fall back to cl.exe if clang-cl fails to compile
2160 -Xclang <arg> Pass <arg> to the clang compiler
2165 When clang-cl is run with the ``/fallback`` option, it will first try to
2170 clang-cl cannot successfully compile all the files. clang-cl may fail to compile