1 # Some additional configuration options.
\r
2 option(MSVC_ENABLE_ALL_WARNINGS "If enabled, pass /Wall to the compiler." ON)
\r
3 option(MSVC_ENABLE_CPP_LATEST "If enabled, pass /std:c++latest to the compiler" ON)
\r
4 option(MSVC_ENABLE_DEBUG_INLINING "If enabled, enable inlining in the debug configuration. This allows /Zc:inline to be far more effective." OFF)
\r
5 option(MSVC_ENABLE_FAST_LINK "If enabled, pass /DEBUG:FASTLINK to the linker. This makes linking faster, but the gtest integration for Visual Studio can't currently handle the .pdbs generated." OFF)
\r
6 option(MSVC_ENABLE_LEAN_AND_MEAN_WINDOWS "If enabled, define WIN32_LEAN_AND_MEAN to include a smaller subset of Windows.h" ON)
\r
7 option(MSVC_ENABLE_LTCG "If enabled, use Link Time Code Generation for Release builds." OFF)
\r
8 option(MSVC_ENABLE_PARALLEL_BUILD "If enabled, build multiple source files in parallel." ON)
\r
9 option(MSVC_ENABLE_STATIC_ANALYSIS "If enabled, do more complex static analysis and generate warnings appropriately." OFF)
\r
10 option(MSVC_USE_STATIC_RUNTIME "If enabled, build against the static, rather than the dynamic, runtime." OFF)
\r
12 # Alas, option() doesn't support string values.
\r
13 set(MSVC_FAVORED_ARCHITECTURE "blend" CACHE STRING "One of 'blend', 'AMD64', 'INTEL64', or 'ATOM'. This tells the compiler to generate code optimized to run best on the specified architecture.")
\r
14 # Add a pretty drop-down selector for these values when using the GUI.
\r
16 CACHE MSVC_FAVORED_ARCHITECTURE
\r
23 # Validate, and then add the favored architecture.
\r
24 if (NOT MSVC_FAVORED_ARCHITECTURE STREQUAL "blend" AND NOT MSVC_FAVORED_ARCHITECTURE STREQUAL "AMD64" AND NOT MSVC_FAVORED_ARCHITECTURE STREQUAL "INTEL64" AND NOT MSVC_FAVORED_ARCHITECTURE STREQUAL "ATOM")
\r
25 message(FATAL_ERROR "MSVC_FAVORED_ARCHITECTURE must be set to one of exactly, 'blend', 'AMD64', 'INTEL64', or 'ATOM'! Got '${MSVC_FAVORED_ARCHITECTURE}' instead!")
\r
28 ############################################################
\r
29 # We need to adjust a couple of the default option sets.
\r
30 ############################################################
\r
32 # If the static runtime is requested, we have to
\r
33 # overwrite some of CMake's defaults.
\r
34 if (MSVC_USE_STATIC_RUNTIME)
\r
36 CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
\r
37 CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
\r
38 CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
\r
39 CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
\r
40 if (${flag_var} MATCHES "/MD")
\r
41 string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
\r
46 # The Ninja generator doesn't de-dup the exception mode flag, so remove the
\r
47 # default flag so that MSVC doesn't warn about it on every single file.
\r
48 if ("${CMAKE_GENERATOR}" STREQUAL "Ninja")
\r
50 CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
\r
51 CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
\r
52 CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
\r
53 CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
\r
54 if (${flag_var} MATCHES "/EHsc")
\r
55 string(REGEX REPLACE "/EHsc" "" ${flag_var} "${${flag_var}}")
\r
60 # In order for /Zc:inline, which speeds up the build significantly, to work
\r
61 # we need to remove the /Ob0 parameter that CMake adds by default, because that
\r
62 # would normally disable all inlining.
\r
63 foreach(flag_var CMAKE_C_FLAGS_DEBUG CMAKE_CXX_FLAGS_DEBUG)
\r
64 if (${flag_var} MATCHES "/Ob0")
\r
65 string(REGEX REPLACE "/Ob0" "" ${flag_var} "${${flag_var}}")
\r
69 # Apply the option set for Folly to the specified target.
\r
70 function(apply_folly_compile_options_to_target THETARGET)
\r
71 # The general options passed:
\r
72 target_compile_options(${THETARGET}
\r
74 /EHa # Enable both SEH and C++ Exceptions.
\r
75 /Zc:referenceBinding # Disallow temporaries from binding to non-const lvalue references.
\r
76 /Zc:rvalueCast # Enforce the standard rules for explicit type conversion.
\r
77 /Zc:implicitNoexcept # Enable implicit noexcept specifications where required, such as destructors.
\r
78 /Zc:strictStrings # Don't allow conversion from a string literal to mutable characters.
\r
79 /Zc:threadSafeInit # Enable thread-safe function-local statics initialization.
\r
80 /Zc:throwingNew # Assume operator new throws on failure.
\r
82 $<$<BOOL:${MSVC_ENABLE_CPP_LATEST}>:/std:c++latest> # Build in C++ Latest mode if requested.
\r
84 # This is only supported by MSVC 2017
\r
85 $<$<BOOL:${MSVC_IS_2017}>:/permissive-> # Be mean, don't allow bad non-standard stuff (C++/CLI, __declspec, etc. are all left intact).
\r
87 /bigobj # Support objects with > 65k sections. Needed due to templates.
\r
88 /favor:${MSVC_FAVORED_ARCHITECTURE} # Architecture to prefer when generating code.
\r
89 /Zc:inline # Have the compiler eliminate unreferenced COMDAT functions and data before emitting the object file.
\r
91 $<$<BOOL:${MSVC_ENABLE_ALL_WARNINGS}>:/Wall> # Enable all warnings if requested.
\r
92 $<$<BOOL:${MSVC_ENABLE_PARALLEL_BUILD}>:/MP> # Enable multi-processor compilation if requested.
\r
93 $<$<BOOL:${MSVC_ENABLE_STATIC_ANALYSIS}>:/analyze> # Enable static analysis if requested.
\r
97 /Gy- # Disable function level linking.
\r
98 /GF- # Disable string pooling.
\r
100 $<$<BOOL:${MSVC_ENABLE_DEBUG_INLINING}>:/Ob2> # Add /Ob2 if allowing inlining in debug mode.
\r
104 $<$<NOT:$<CONFIG:DEBUG>>:
\r
105 /GF # Enable string pooling. (this is enabled by default by the optimization level, but we enable it here for clarity)
\r
106 /Gw # Optimize global data. (-fdata-sections)
\r
107 /Gy # Enable function level linking. (-ffunction-sections)
\r
108 /Qpar # Enable parallel code generation.
\r
109 /Oi # Enable intrinsic functions.
\r
110 /Ot # Favor fast code.
\r
112 $<$<BOOL:${MSVC_ENABLE_LTCG}>:/GL> # Enable link time code generation.
\r
116 target_compile_options(${THETARGET}
\r
118 /wd4191 # 'type cast' unsafe conversion of function pointers
\r
119 /wd4291 # no matching operator delete found
\r
120 /wd4309 # '=' truncation of constant value
\r
121 /wd4310 # cast truncates constant value
\r
122 /wd4366 # result of unary '&' operator may be unaligned
\r
123 /wd4587 # behavior change; constructor no longer implicitly called
\r
124 /wd4592 # symbol will be dynamically initialized (implementation limitation)
\r
125 /wd4723 # potential divide by 0
\r
126 /wd4724 # potential mod by 0
\r
127 /wd4868 # compiler may not enforce left-to-right evaluation order
\r
128 /wd4996 # user deprecated
\r
130 # The warnings that are disabled:
\r
131 /wd4068 # Unknown pragma.
\r
132 /wd4091 # 'typedef' ignored on left of '' when no variable is declared.
\r
133 /wd4146 # Unary minus applied to unsigned type, result still unsigned.
\r
134 /wd4800 # Values being forced to bool, this happens many places, and is a "performance warning".
\r
136 # NOTE: glog/logging.h:1116 change to `size_t pcount() const { return size_t(pptr() - pbase()); }`
\r
137 # NOTE: gmock/gmock-spec-builders.h:1177 change to `*static_cast<const Action<F>*>(untyped_actions_[size_t(count - 1)]) :`
\r
138 # NOTE: gmock/gmock-spec-builders.h:1749 change to `const size_t count = untyped_expectations_.size();`
\r
139 # NOTE: gmock/gmock-spec-builders.h:1754 change to `for (size_t i = 0; i < count; i++) {`
\r
140 # NOTE: gtest/gtest-printers.h:173 change to `const internal::BiggestInt kBigInt = internal::BiggestInt(value);`
\r
141 # NOTE: gtest/internal/gtest-internal.h:890 add `GTEST_DISABLE_MSC_WARNINGS_PUSH_(4365)`
\r
142 # NOTE: gtest/internal/gtest-internal.h:894 ass `GTEST_DISABLE_MSC_WARNINGS_POP_()`
\r
143 # NOTE: boost/crc.hpp:578 change to `{ return static_cast<unsigned char>(x ^ rem); }`
\r
144 # NOTE: boost/regex/v4/match_results.hpp:126 change to `return m_subs[size_type(sub)].length();`
\r
145 # NOTE: boost/regex/v4/match_results.hpp:226 change to `return m_subs[size_type(sub)];`
\r
146 # NOTE: boost/date_time/adjust_functors.hpp:67 change to `origDayOfMonth_ = short(ymd.day);`
\r
147 # NOTE: boost/date_time/adjust_functors.hpp:75 change to `wrap_int2 wi(short(ymd.month));`
\r
148 # NOTE: boost/date_time/adjust_functors.hpp:82 change to `day_type resultingEndOfMonthDay(cal_type::end_of_month_day(static_cast<unsigned short>(year), static_cast<unsigned short>(wi.as_int())));`
\r
149 # NOTE: boost/date_time/adjust_functors.hpp:85 change to `return date_type(static_cast<unsigned short>(year), static_cast<unsigned short>(wi.as_int()), resultingEndOfMonthDay) - d;`
\r
150 # NOTE: boost/date_time/adjust_functors.hpp:87 change to `day_type dayOfMonth = static_cast<unsigned short>(origDayOfMonth_);`
\r
151 # NOTE: boost/date_time/adjust_functors.hpp:91 change to `return date_type(static_cast<unsigned short>(year), static_cast<unsigned short>(wi.as_int()), dayOfMonth) - d;`
\r
152 # NOTE: boost/date_time/adjust_functors.hpp:98 change to `origDayOfMonth_ = short(ymd.day);`
\r
153 # NOTE: boost/date_time/adjust_functors.hpp:106 change to `wrap_int2 wi(short(ymd.month));`
\r
154 # NOTE: boost/date_time/adjust_functors.hpp:111 change to `day_type resultingEndOfMonthDay(cal_type::end_of_month_day(static_cast<unsigned short>(year), static_cast<unsigned short>(wi.as_int())));`
\r
155 # NOTE: boost/date_time/adjust_functors.hpp:114 change to `return date_type(static_cast<unsigned short>(year), static_cast<unsigned short>(wi.as_int()), resultingEndOfMonthDay) - d;`
\r
156 # NOTE: boost/date_time/adjust_functors.hpp:116 change to `day_type dayOfMonth = static_cast<unsigned short>(origDayOfMonth_);`
\r
157 # NOTE: boost/date_time/adjust_functors.hpp:120 change to `return date_type(static_cast<unsigned short>(year), static_cast<unsigned short>(wi.as_int()), dayOfMonth) - d;`
\r
158 # NOTE: boost/date_time/gregorian_calendar.ipp:81 change to `unsigned long d = static_cast<unsigned long>(ymd.day + ((153*m + 2)/5) + 365*y + (y/4) - (y/100) + (y/400) - 32045);`
\r
159 # NOTE: boost/date_time/gregorian/greg_date.hpp:122 change to `unsigned short eom_day = gregorian_calendar::end_of_month_day(ymd.year, ymd.month);`
\r
160 # NOTE: boost/thread/future.hpp:1050 change to `locks[std::ptrdiff_t(i)]=BOOST_THREAD_MAKE_RV_REF(boost::unique_lock<boost::mutex>(futures[i].future_->mutex));`
\r
161 # NOTE: boost/thread/future.hpp:1063 change to `locks[std::ptrdiff_t(i)].unlock();`
\r
162 # NOTE: boost/thread/win32/basic_recursive_mutex.hpp:47 change to `long const current_thread_id=long(win32::GetCurrentThreadId());`
\r
163 # NOTE: boost/thread/win32/basic_recursive_mutex.hpp:53 change to `long const current_thread_id=long(win32::GetCurrentThreadId());`
\r
164 # NOTE: boost/thread/win32/basic_recursive_mutex.hpp:64 change to `long const current_thread_id=long(win32::GetCurrentThreadId());`
\r
165 # NOTE: boost/thread/win32/basic_recursive_mutex.hpp:78 change to `long const current_thread_id=long(win32::GetCurrentThreadId());`
\r
166 # NOTE: boost/thread/win32/basic_recursive_mutex.hpp:84 change to `long const current_thread_id=long(win32::GetCurrentThreadId());`
\r
167 # NOTE: boost/thread/win32/condition_variable.hpp:79 change to `detail::win32::ReleaseSemaphore(semaphore,long(count_to_release),0);`
\r
168 # NOTE: boost/thread/win32/condition_variable.hpp:84 change to `release(unsigned(detail::interlocked_read_acquire(&waiters)));`
\r
169 # NOTE: boost/algorithm/string/detail/classification.hpp:85 change to `std::size_t Size=std::size_t(::boost::distance(Range));`
\r
170 /wd4018 # Signed/unsigned mismatch.
\r
171 /wd4365 # Signed/unsigned mismatch.
\r
172 /wd4388 # Signed/unsigned mismatch on relative comparison operator.
\r
173 /wd4389 # Signed/unsigned mismatch on equality comparison operator.
\r
176 /wd4100 # Unreferenced formal parameter.
\r
177 /wd4459 # Declaration of parameter hides global declaration.
\r
178 /wd4505 # Unreferenced local function has been removed.
\r
179 /wd4701 # Potentially uninitialized local variable used.
\r
180 /wd4702 # Unreachable code.
\r
182 # These warnings are disabled because we've
\r
183 # enabled all warnings. If all warnings are
\r
184 # not enabled, we still need to disable them
\r
185 # for consuming libs.
\r
186 /wd4061 # Enum value not handled by a case in a switch on an enum. This isn't very helpful because it is produced even if a default statement is present.
\r
187 /wd4127 # Conditional expression is constant.
\r
188 /wd4200 # Non-standard extension, zero sized array.
\r
189 /wd4201 # Non-standard extension used: nameless struct/union.
\r
190 /wd4296 # '<' Expression is always false.
\r
191 /wd4316 # Object allocated on the heap may not be aligned to 128.
\r
192 /wd4324 # Structure was padded due to alignment specifier.
\r
193 /wd4355 # 'this' used in base member initializer list.
\r
194 /wd4371 # Layout of class may have changed due to fixes in packing.
\r
195 /wd4435 # Object layout under /vd2 will change due to virtual base.
\r
196 /wd4514 # Unreferenced inline function has been removed. (caused by /Zc:inline)
\r
197 /wd4548 # Expression before comma has no effect. I wouldn't disable this normally, but malloc.h triggers this warning.
\r
198 /wd4574 # ifdef'd macro was defined to 0.
\r
199 /wd4582 # Constructor is not implicitly called.
\r
200 /wd4583 # Destructor is not implicitly called.
\r
201 /wd4619 # Invalid warning number used in #pragma warning.
\r
202 /wd4623 # Default constructor was implicitly defined as deleted.
\r
203 /wd4625 # Copy constructor was implicitly defined as deleted.
\r
204 /wd4626 # Assignment operator was implicitly defined as deleted.
\r
205 /wd4647 # Behavior change in __is_pod.
\r
206 /wd4668 # Macro was not defined, replacing with 0.
\r
207 /wd4706 # Assignment within conditional expression.
\r
208 /wd4710 # Function was not inlined.
\r
209 /wd4711 # Function was selected for automated inlining.
\r
210 /wd4714 # Function marked as __forceinline not inlined.
\r
211 /wd4820 # Padding added after data member.
\r
212 /wd5026 # Move constructor was implicitly defined as deleted.
\r
213 /wd5027 # Move assignment operator was implicitly defined as deleted.
\r
214 /wd5031 # #pragma warning(pop): likely mismatch, popping warning state pushed in different file. This is needed because of how boost does things.
\r
216 # Warnings to treat as errors:
\r
217 /we4099 # Mixed use of struct and class on same type names.
\r
218 /we4129 # Unknown escape sequence. This is usually caused by incorrect escaping.
\r
219 /we4566 # Character cannot be represented in current charset. This is remidied by prefixing string with "u8".
\r
222 # Warnings disabled for /analyze
\r
223 $<$<BOOL:${MSVC_ENABLE_STATIC_ANALYSIS}>:
\r
224 /wd6001 # Using uninitialized memory. This is disabled because it is wrong 99% of the time.
\r
225 /wd6011 # Dereferencing potentially NULL pointer.
\r
226 /wd6031 # Return value ignored.
\r
227 /wd6235 # (<non-zero constant> || <expression>) is always a non-zero constant.
\r
228 /wd6237 # (<zero> && <expression>) is always zero. <expression> is never evaluated and may have side effects.
\r
229 /wd6239 # (<non-zero constant> && <expression>) always evaluates to the result of <expression>.
\r
230 /wd6240 # (<expression> && <non-zero constant>) always evaluates to the result of <expression>.
\r
231 /wd6246 # Local declaration hides declaration of same name in outer scope.
\r
232 /wd6248 # Setting a SECURITY_DESCRIPTOR's DACL to NULL will result in an unprotected object. This is done by one of the boost headers.
\r
233 /wd6255 # _alloca indicates failure by raising a stack overflow exception.
\r
234 /wd6262 # Function uses more than x bytes of stack space.
\r
235 /wd6271 # Extra parameter passed to format function. The analysis pass doesn't recognize %j or %z, even though the runtime does.
\r
236 /wd6285 # (<non-zero constant> || <non-zero constant>) is always true.
\r
237 /wd6297 # 32-bit value is shifted then cast to 64-bits. The places this occurs never use more than 32 bits.
\r
238 /wd6308 # Realloc might return null pointer: assigning null pointer to '<name>', which is passed as an argument to 'realloc', will cause the original memory to leak.
\r
239 /wd6326 # Potential comparison of a constant with another constant.
\r
240 /wd6330 # Unsigned/signed mismatch when passed as a parameter.
\r
241 /wd6340 # Mismatch on sign when passed as format string value.
\r
242 /wd6387 # '<value>' could be '0': This does not adhere to the specification for a function.
\r
243 /wd28182 # Dereferencing NULL pointer. '<value>' contains the same NULL value as '<expression>'.
\r
244 /wd28251 # Inconsistent annotation for function. This is because we only annotate the declaration and not the definition.
\r
245 /wd28278 # Function appears with no prototype in scope.
\r
249 # And the extra defines:
\r
250 target_compile_definitions(${THETARGET}
\r
252 _CRT_NONSTDC_NO_WARNINGS # Don't deprecate posix names of functions.
\r
253 _CRT_SECURE_NO_WARNINGS # Don't deprecate the non _s versions of various standard library functions, because safety is for chumps.
\r
254 _SCL_SECURE_NO_WARNINGS # Don't deprecate the non _s versions of various standard library functions, because safety is for chumps.
\r
256 _STL_EXTRA_DISABLED_WARNINGS=4774\ 4987
\r
258 $<$<BOOL:${MSVC_ENABLE_CPP_LATEST}>:_HAS_AUTO_PTR_ETC=1> # We're building in C++ 17 or greater mode, but certain dependencies (Boost) still have dependencies on unary_function and binary_function, so we have to make sure not to remove them.
\r
259 $<$<BOOL:${MSVC_ENABLE_LEAN_AND_MEAN_WINDOWS}>:WIN32_LEAN_AND_MEAN> # Don't include most of Windows.h
\r
262 # Ignore a warning about an object file not defining any symbols,
\r
263 # these are known, and we don't care.
\r
264 set_property(TARGET ${THETARGET} APPEND_STRING PROPERTY STATIC_LIBRARY_FLAGS " /ignore:4221")
\r
266 # The options to pass to the linker:
\r
267 set_property(TARGET ${THETARGET} APPEND_STRING PROPERTY LINK_FLAGS_DEBUG " /INCREMENTAL") # Do incremental linking.
\r
268 if (NOT $<TARGET_PROPERTY:${THETARGET},TYPE> STREQUAL "STATIC_LIBRARY")
\r
269 set_property(TARGET ${THETARGET} APPEND_STRING PROPERTY LINK_FLAGS_DEBUG " /OPT:NOREF") # No unreferenced data elimination.
\r
270 set_property(TARGET ${THETARGET} APPEND_STRING PROPERTY LINK_FLAGS_DEBUG " /OPT:NOICF") # No Identical COMDAT folding.
\r
272 set_property(TARGET ${THETARGET} APPEND_STRING PROPERTY LINK_FLAGS_RELEASE " /OPT:REF") # Remove unreferenced functions and data.
\r
273 set_property(TARGET ${THETARGET} APPEND_STRING PROPERTY LINK_FLAGS_RELEASE " /OPT:ICF") # Identical COMDAT folding.
\r
276 if (MSVC_ENABLE_FAST_LINK)
\r
277 set_property(TARGET ${THETARGET} APPEND_STRING PROPERTY LINK_FLAGS_DEBUG " /DEBUG:FASTLINK") # Generate a partial PDB file that simply references the original object and library files.
\r
280 # Add /GL to the compiler, and /LTCG to the linker
\r
281 # if link time code generation is enabled.
\r
282 if (MSVC_ENABLE_LTCG)
\r
283 set_property(TARGET ${THETARGET} APPEND_STRING PROPERTY LINK_FLAGS_RELEASE " /LTCG")
\r