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
723 #pragma clang diagnostic ignored "-Wextra-tokens"
728 #pragma clang diagnostic pop
768 an included file is treated as a system header if it is found in an
773 being a system header. No warnings will be produced from the location of
781 #pragma clang system_header
786 The :option:`--system-header-prefix=` and :option:`--no-system-header-prefix=`
789 is found within a header search path and starts with a system prefix, the
790 header is treated as a system header. The last prefix on the
791 command-line which matches the specified header name takes precedence.
796 $ clang -Ifoo -isystem bar --system-header-prefix=x/ \
797 --no-system-header-prefix=x/y/
799 Here, ``#include "x/a.h"`` is treated as including a system header, even
800 if the header is found in ``foo``, and ``#include "x/y/b.h"`` is treated
801 as not including a system header, even if the header is found in
805 directory is treated as including a system header if the including file
806 is treated as a system header.
825 `static analyzer <http://clang-analyzer.llvm.org>`_ can also be
827 `annotations <http://clang-analyzer.llvm.org/annotations.html>`_ and the
829 page <http://clang-analyzer.llvm.org/faq.html#exclude_code>`_ for more
840 the same (and often large) header files to be included by multiple
843 headers. Precompiled header files, which represent one of many ways to
846 some of the work needed to process a corresponding header file. While
855 :option:`-x <language>-header` option. This mirrors the interface in GCC
860 $ gcc -x c-header test.h -o test.h.gch
861 $ clang -x c-header test.h -o test.h.pch
866 A PCH file can then be used as a prefix header when a :option:`-include`
867 option is passed to ``clang``:
871 $ clang -include test.h test.c -o test
873 The ``clang`` driver will first check if a PCH file for ``test.h`` is
886 $ clang -x c-header test.h -o test.h.pch
889 $ clang test.c -o test
891 In this example, ``clang`` will not automatically use the PCH file for
898 It is sometimes necessary to build a precompiled header from headers
900 might build a precompiled header within the build tree that is then
906 To build a relocatable precompiled header, place your headers into a
908 if you want to build a precompiled header for the header ``mylib.h``
910 ``build/usr/include`` and place the header ``mylib.h`` into that
915 Building a relocatable precompiled header requires two additional
923 # clang -x c-header --relocatable-pch -isysroot /path/to/build /path/to/build/mylib.h mylib.h.pch
926 PCH file are found from the system header root. For example, ``mylib.h``
935 and the precompiled header cannot be generated after headers have been
1259 $ clang++ -O2 -gline-tables-only code.cc -o code
1301 $ clang++ -O2 -gline-tables-only -fprofile-sample-use=code.prof code.cc -o code
1367 function header specify how many total samples were accumulated in the
1386 defined. So, if the function has its header at line 280, the offset
1469 $ clang++ -O2 -fprofile-instr-generate code.cc -o code
1484 the input expected by clang. Use the ``merge`` command of the
1499 $ clang++ -O2 -fprofile-instr-use=code.profdata code.cc -o code
1502 profile. As you make changes to your code, clang may no longer be able to
1522 $ clang++ -O2 -fprofile-generate=yyy/zzz code.cc -o code
1664 The support for standard C in clang is feature-complete except for the
1667 Extensions supported by clang
1675 clang supports the -std option, which changes what language mode clang
1678 specified, clang defaults to gnu11 mode. Many C99 and C11 features are
1730 clang tries to be compatible with gcc as much as possible, but some gcc
1733 - clang does not support decimal floating point types (``_Decimal32`` and
1737 - clang does not support nested functions; this is a complex feature
1750 - clang does not support static initialization of flexible array
1753 - clang does not support
1757 that because clang pretends to be like GCC 4.2, and this extension
1759 extension with clang at the moment.
1760 - clang does not support the gcc extension for forward-declaring
1776 - clang does not support the gcc extension that allows variable-length
1779 the extension appears to be rarely used. Note that clang *does*
1782 - clang does not have an equivalent to gcc's "fold"; this means that
1783 clang doesn't accept some constructs gcc might accept in contexts
1786 - clang does not support ``__builtin_apply`` and friends; this extension
1794 clang has support for many extensions from Microsoft Visual C++. To enable these
1800 clang has a ``-fms-compatibility`` flag that makes clang accept enough
1803 <http://clang.llvm.org/compatibility.html#dep_lookup_bases>`_, which is
1804 a common compatibility issue with clang. This flag is enabled by default
1807 ``-fdelayed-template-parsing`` lets clang delay parsing of function template
1811 For compatibility with existing code that compiles with MSVC, clang defines the
1813 and 180000000 respectively, making clang look like an early release of Visual
1816 compatibility version makes clang behave more like that version of MSVC. For
1825 clang fully implements all of standard C++98 except for exported
1909 For the X86 target, clang supports the :option:`-m16` command line
1936 clang currently contains some support for other architectures (e.g. Sparc);
1940 clang contains limited support for the MSP430 embedded processor, but
1941 both the clang support and the LLVM backend support are highly
1946 platform is quite easy; see ``lib/Basic/Targets.cpp`` in the clang source
1992 - ``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)``
1994 - ``some_directory/bin/clang.exe``
1995 - ``some_directory/bin/clang++.exe``
2015 clang-cl
2018 clang-cl is an alternative command-line interface to Clang driver, designed for
2021 To enable clang-cl to find system headers, libraries, and the linker when run
2026 clang-cl can also be used from inside Visual Studio by using an LLVM Platform
2032 To be compatible with cl.exe, clang-cl supports most of the same command-line
2036 Options that are known to clang-cl, but not currently supported, are ignored
2041 clang-cl.exe: warning: argument unused during compilation: '/AI'
2045 Options that are not known to clang-cl will be ignored by default. Use the
2051 clang-cl.exe: error: no such file or directory: '/foobar'
2053 Please `file a bug <http://llvm.org/bugs/enter_bug.cgi?product=clang&component=Driver>`_
2054 for any valid cl.exe flags that clang-cl does not understand.
2056 Execute ``clang-cl /?`` to see a list of supported options:
2071 /fallback Fall back to cl.exe if clang-cl fails to compile
2186 -Xclang <arg> Pass <arg> to the clang compiler
2191 When clang-cl is run with the ``/fallback`` option, it will first try to
2196 clang-cl cannot successfully compile all the files. clang-cl may fail to compile