3 <style type="text/css">
4 .none { background-color: #FFCCCC }
5 .partial { background-color: #FFFF99 }
6 .good { background-color: #CCFF99 }
17 When Clang compiles C++ code for Windows, it attempts to be compatible with
18 MSVC. There are multiple dimensions to compatibility.
20 First, Clang attempts to be ABI-compatible, meaning that Clang-compiled code
21 should be able to link against MSVC-compiled code successfully. However, C++
22 ABIs are particularly large and complicated, and Clang's support for MSVC's C++
23 ABI is a work in progress. If you don't require MSVC ABI compatibility or don't
24 want to use Microsoft's C and C++ runtimes, the mingw32 toolchain might be a
25 better fit for your project.
27 Second, Clang implements many MSVC language extensions, such as
28 ``__declspec(dllexport)`` and a handful of pragmas. These are typically
29 controlled by ``-fms-extensions``.
31 Third, MSVC accepts some C++ code that Clang will typically diagnose as
32 invalid. When these constructs are present in widely included system headers,
33 Clang attempts to recover and continue compiling the user's program. Most
34 parsing and semantic compatibility tweaks are controlled by
35 ``-fms-compatibility`` and ``-fdelayed-template-parsing``, and they are a work
38 Finally, there is :ref:`clang-cl`, a driver program for clang that attempts to
39 be compatible with MSVC's cl.exe.
44 The status of major ABI-impacting C++ features:
46 * Record layout: :good:`Complete`. We've tested this with a fuzzer and have
49 * Class inheritance: :good:`Mostly complete`. This covers all of the standard
50 OO features you would expect: virtual method inheritance, multiple
51 inheritance, and virtual inheritance. Every so often we uncover a bug where
52 our tables are incompatible, but this is pretty well in hand. This feature
53 has also been fuzz tested.
55 * Name mangling: :good:`Ongoing`. Every new C++ feature generally needs its own
56 mangling. For example, member pointer template arguments have an interesting
57 and distinct mangling. Fortunately, incorrect manglings usually do not result
58 in runtime errors. Non-inline functions with incorrect manglings usually
59 result in link errors, which are relatively easy to diagnose. Incorrect
60 manglings for inline functions and templates result in multiple copies in the
61 final image. The C++ standard requires that those addresses be equal, but few
62 programs rely on this.
64 * Member pointers: :good:`Mostly complete`. Standard C++ member pointers are
65 fully implemented and should be ABI compatible. Both `#pragma
66 pointers_to_members`_ and the `/vm`_ flags are supported. However, MSVC
67 supports an extension to allow creating a `pointer to a member of a virtual
68 base class`_. Clang does not yet support this.
70 .. _#pragma pointers_to_members:
71 http://msdn.microsoft.com/en-us/library/83cch5a6.aspx
72 .. _/vm: http://msdn.microsoft.com/en-us/library/yad46a6z.aspx
73 .. _pointer to a member of a virtual base class: http://llvm.org/PR15713
75 * Debug info: :partial:`Minimal`. Clang emits both CodeView line tables
76 (similar to what MSVC emits when given the ``/Z7`` flag) and DWARF debug
77 information into the object file.
78 Microsoft's link.exe will transform the CodeView line tables into a PDB,
79 enabling stack traces in all modern Windows debuggers. Clang does not emit
80 any CodeView-compatible type info or description of variable layout.
81 Binaries linked with either binutils' ld or LLVM's lld should be usable with
82 GDB however sophisticated C++ expressions are likely to fail.
84 * RTTI: :good:`Complete`. Generation of RTTI data structures has been
85 finished, along with support for the ``/GR`` flag.
87 * Exceptions and SEH: :partial:`Partial`.
88 C++ exceptions (``try`` / ``catch`` / ``throw``) and
89 structured exceptions (``__try`` / ``__except`` / ``__finally``) mostly
90 work on x64. 32-bit exception handling support is being worked on. LLVM does
91 not model asynchronous exceptions, so it is currently impossible to catch an
92 asynchronous exception generated in the same frame as the catching ``__try``.
93 C++ exception specifications are ignored, but this is `consistent with Visual
96 .. _consistent with Visual C++:
97 https://msdn.microsoft.com/en-us/library/wfa0edys.aspx
99 * Thread-safe initialization of local statics: :good:`Complete`. MSVC 2015
100 added support for thread-safe initialization of such variables by taking an
102 We are ABI compatible with both the MSVC 2013 and 2015 ABI for static local
105 * Lambdas: :good:`Mostly complete`. Clang is compatible with Microsoft's
106 implementation of lambdas except for providing overloads for conversion to
107 function pointer for different calling conventions. However, Microsoft's
108 extension is non-conforming.
110 Template instantiation and name lookup
111 ======================================
113 MSVC allows many invalid constructs in class templates that Clang has
114 historically rejected. In order to parse widely distributed headers for
115 libraries such as the Active Template Library (ATL) and Windows Runtime Library
116 (WRL), some template rules have been relaxed or extended in Clang on Windows.
118 The first major semantic difference is that MSVC appears to defer all parsing
119 an analysis of inline method bodies in class templates until instantiation
120 time. By default on Windows, Clang attempts to follow suit. This behavior is
121 controlled by the ``-fdelayed-template-parsing`` flag. While Clang delays
122 parsing of method bodies, it still parses the bodies *before* template argument
123 substitution, which is not what MSVC does. The following compatibility tweaks
124 are necessary to parse the template in those cases.
126 MSVC allows some name lookup into dependent base classes. Even on other
127 platforms, this has been a `frequently asked question`_ for Clang users. A
128 dependent base class is a base class that depends on the value of a template
129 parameter. Clang cannot see any of the names inside dependent bases while it
130 is parsing your template, so the user is sometimes required to use the
131 ``typename`` keyword to assist the parser. On Windows, Clang attempts to
132 follow the normal lookup rules, but if lookup fails, it will assume that the
133 user intended to find the name in a dependent base. While parsing the
134 following program, Clang will recover as if the user had written the
137 .. _frequently asked question:
138 http://clang.llvm.org/compatibility.html#dep_lookup
142 template <typename T>
145 /*typename*/ T::UnknownType x = /*this->*/unknownMember;
149 After recovery, Clang warns the user that this code is non-standard and issues
150 a hint suggesting how to fix the problem.
152 As of this writing, Clang is able to compile a simple ATL hello world
153 application. There are still issues parsing WRL headers for modern Windows 8
154 apps, but they should be addressed soon.