[CMake][NFC] Limit the use of uppercase_CMAKE_BUILD_TYPE

[ctetreau]

Summary

uppercase_CMAKE_BUILD_TYPE is often defined to be
toupper(CMAKE_BUILD_TYPE). This is sometimes neccesary when trying to
programatically inspect the values of builtin cmake variables that have
the build type as part of the name. However, this variable is also often
used to just check the build type.

The use of this variable is error prone because it is not a builtin variable.
Users may add a usage of it without defining it. Since CMake treats undefined
variables as being defined to the empty string, this will not cause any sort
of error. It may even be the case that it appears to work for the author
and bad code makes it into master. (D89807)

This patch removes unneccesary usages of uppercase_CMAKE_BUILD_TYPE.
Remaining usages of it are needed to construct variable names such as
CMAKE_CXX_FLAGS_DEBUG.

[lebedev.ri]

libcxx/utils/google-benchmark/test/CMakeLists.txt

8–9

How is this an unnecessary usage?

[ldionne]

I quite like this. We should strive to use the same name as CMake uses for its build types, i.e. Debug, Release, etc.

If I configure CMake with -DCMAKE_BUILD_TYPE=DEBUG, is CMAKE_BUILD_TYPE normalized back to Debug by CMake, or is it defined to DEBUG? If the latter, then I suggest we might want to add a temporary error message when the CMAKE_BUILD_TYPE is defined to something all-uppercase. This would help catch cases where this patch will be a change in behavior. That would be a nice place to tell users to use the right build type names.

[ctetreau]

In D89813#2342463, @ldionne wrote:

I quite like this. We should strive to use the same name as CMake uses for its build types, i.e. Debug, Release, etc.

If I configure CMake with -DCMAKE_BUILD_TYPE=DEBUG, is CMAKE_BUILD_TYPE normalized back to Debug by CMake, or is it defined to DEBUG? If the latter, then I suggest we might want to add a temporary error message when the CMAKE_BUILD_TYPE is defined to something all-uppercase. This would help catch cases where this patch will be a change in behavior. That would be a nice place to tell users to use the right build type names.

My interpretation of https://cmake.org/cmake/help/v3.13/variable/CMAKE_BUILD_TYPE.html, is that it can be the empty string, or CamelCase. However, experimentation shows that passing -DCMAKE_BUILD_TYPE=RELEASE results in an all-capitals version. Given this, I don't think this patch is correct.

It looks like we had case-sensitive CMAKE_BUILD_TYPE, but it was removed in 2015 (https://github.com/llvm/llvm-project/commit/74009be05158c72893e02c2930b771a334543f1b), so making it case sensitive again is probably going to be controversial.

[ldionne]

Are generator expressions expanded in if()? If so, we could at least change those to if ("$<UPPER_CASE:CMAKE_BUILD_TYPE>" STREQUAL "DEBUG"). This would preserve the case-insensitivity while solving the problem you were concerned about, and make the code easier to read.

[ctetreau]

I would assume so. I'll take a look.

[ctetreau]

In D89813#2342552, @ctetreau wrote:

I would assume so. I'll take a look.

It doesn't seem to work.

compiler-rt/cmake/Modules/AddCompilerRT.cmake

if(NOT COMPILER_RT_EXTERNALIZE_DEBUGINFO)
     return()
   endif()
 
   if(NOT COMPILER_RT_EXTERNALIZE_DEBUGINFO_SKIP_STRIP)
     set(strip_command COMMAND xcrun strip -Sl $<TARGET_FILE:${name}>)
   endif()
 
   if(APPLE)
+    string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
     if(CMAKE_CXX_FLAGS MATCHES "-flto"
       OR CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} MATCHES "-flto")
 
       set(lto_object ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${name}-lto.o)
       set_property(TARGET ${name} APPEND_STRING PROPERTY
         LINK_FLAGS " -Wl,-object_path_lto -Wl,${lto_object}")
     endif()
     add_custom_command(TARGET ${name} POST_BUILD

libcxx/CMakeLists.txt

 include(config-ix)
 
 # Configure coverage options.
 if (LIBCXX_GENERATE_COVERAGE)
   include(CodeCoverage)
   set(CMAKE_BUILD_TYPE "COVERAGE" CACHE STRING "" FORCE)
 endif()
 
-string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
-if (uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
   set(LIBCXX_DEBUG_BUILD ON)
 else()
   set(LIBCXX_DEBUG_BUILD OFF)
 endif()
 
 #===============================================================================
 # Setup Compiler Flags
 #===============================================================================
function(get_sanitizer_flags OUT_VAR  USE_SANITIZER)
   set(SANITIZER_FLAGS)
   set(USE_SANITIZER "${USE_SANITIZER}")
   # NOTE: LLVM_USE_SANITIZER checks for a UNIX like system instead of MSVC.
   # But we don't have LLVM_ON_UNIX so checking for MSVC is the best we can do.
   if (USE_SANITIZER AND NOT MSVC)
     append_flags_if_supported(SANITIZER_FLAGS "-fno-omit-frame-pointer")
     append_flags_if_supported(SANITIZER_FLAGS "-gline-tables-only")
 
-    if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND
-            NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")
+    if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug" AND
+            NOT CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
       append_flags_if_supported(SANITIZER_FLAGS "-gline-tables-only")
     endif()
     if (USE_SANITIZER STREQUAL "Address")
       append_flags(SANITIZER_FLAGS "-fsanitize=address")
     elseif (USE_SANITIZER MATCHES "Memory(WithOrigins)?")
       append_flags(SANITIZER_FLAGS -fsanitize=memory)
       if (USE_SANITIZER STREQUAL "MemoryWithOrigins")
         append_flags(SANITIZER_FLAGS "-fsanitize-memory-track-origins")

libcxx/utils/google-benchmark/test/CMakeLists.txt

 # Enable the tests
 
 find_package(Threads REQUIRED)
 include(CheckCXXCompilerFlag)
 
 # NOTE: Some tests use `<cassert>` to perform the test. Therefore we must
 # strip -DNDEBUG from the default CMake flags in DEBUG mode.
-string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
-if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
+if( NOT CMAKE_BUILD_TYPE STREQUAL "Debug" )
   add_definitions( -UNDEBUG )
   add_definitions(-DTEST_BENCHMARK_LIBRARY_HAS_NO_ASSERTIONS)
   # Also remove /D NDEBUG to avoid MSVC warnings about conflicting defines.
   foreach (flags_var_to_scrub
       CMAKE_CXX_FLAGS_RELEASE
       CMAKE_CXX_FLAGS_RELWITHDEBINFO
       CMAKE_CXX_FLAGS_MINSIZEREL
       CMAKE_C_FLAGS_RELEASE

libcxxabi/CMakeLists.txt

if (LIBCXXABI_ENABLE_EXCEPTIONS)
   add_c_compile_flags_if_supported(-funwind-tables)
 else()
   add_compile_flags_if_supported(-fno-exceptions)
   add_compile_flags_if_supported(-EHs-)
   add_compile_flags_if_supported(-EHa-)
 endif()
 
 # Assert
-string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 if (LIBCXXABI_ENABLE_ASSERTIONS)
   # MSVC doesn't like _DEBUG on release builds. See PR 4379.
   if (NOT MSVC)
     list(APPEND LIBCXXABI_COMPILE_FLAGS -D_DEBUG)
   endif()
   # On Release builds cmake automatically defines NDEBUG, so we
   # explicitly undefine it:
-  if (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
+  if (CMAKE_BUILD_TYPE STREQUAL "Release")
     list(APPEND LIBCXXABI_COMPILE_FLAGS -UNDEBUG)
   endif()
 else()
-  if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
+  if (NOT CMAKE_BUILD_TYPE STREQUAL "Release")
     list(APPEND LIBCXXABI_COMPILE_FLAGS -DNDEBUG)
   endif()
 endif()
 
 # Threading
 if (NOT LIBCXXABI_ENABLE_THREADS)
   if (LIBCXXABI_HAS_PTHREAD_API)
     message(FATAL_ERROR "LIBCXXABI_HAS_PTHREAD_API can only"

libunwind/CMakeLists.txt

if (LIBUNWIND_HAS_NOSTDINCXX_FLAG)
   # Remove -stdlib flags to prevent them from causing an unused flag warning.
   string(REPLACE "--stdlib=libc++" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
   string(REPLACE "--stdlib=libstdc++" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
   string(REPLACE "-stdlib=libc++" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
   string(REPLACE "-stdlib=libstdc++" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 endif()
 
 # Assert
-string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 if (LIBUNWIND_ENABLE_ASSERTIONS)
   # MSVC doesn't like _DEBUG on release builds. See PR 4379.
   if (NOT MSVC)
     add_compile_flags(-D_DEBUG)
   endif()
 
   # On Release builds cmake automatically defines NDEBUG, so we
   # explicitly undefine it:
-  if (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
+  if (CMAKE_BUILD_TYPE STREQUAL "Release")
     add_compile_flags(-UNDEBUG)
   endif()
 else()
-  if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
+  if (NOT CMAKE_BUILD_TYPE STREQUAL "Release")
     add_compile_flags(-DNDEBUG)
   endif()
 endif()
 
 # Cross-unwinding
 if (NOT LIBUNWIND_ENABLE_CROSS_UNWINDING)
   add_compile_flags(-D_LIBUNWIND_IS_NATIVE_ONLY)
 endif()

lldb/CMakeLists.txt

if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   set(CMAKE_CXX_STANDARD_REQUIRED YES)
   set(CMAKE_CXX_EXTENSIONS NO)
 endif()
 
 include(LLDBConfig)
 include(AddLLDB)
 
 # Define the LLDB_CONFIGURATION_xxx matching the build type.
-if(uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
+if(CMAKE_BUILD_TYPE STREQUAL "Debug" )
   add_definitions(-DLLDB_CONFIGURATION_DEBUG)
 endif()
 
 if (WIN32)
   add_definitions(-D_ENABLE_EXTENDED_ALIGNED_STORAGE)
 endif()
 
 if (LLDB_ENABLE_PYTHON)

llvm/CMakeLists.txt

 if( CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR AND NOT MSVC_IDE )
   message(FATAL_ERROR "In-source builds are not allowed.
 Please create a directory and run cmake from there, passing the path
 to this source directory as the last argument.
 This process created the file `CMakeCache.txt' and the directory `CMakeFiles'.
 Please delete them.")
 endif()
 
-string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
-
 if (CMAKE_BUILD_TYPE AND
-    NOT uppercase_CMAKE_BUILD_TYPE MATCHES "^(DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL)$")
+    NOT CMAKE_BUILD_TYPE MATCHES "^(Debug|Release|RelWithDebInfo|MinSizeRel)$")
   message(FATAL_ERROR "Invalid value for CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
 endif()
 
 set(LLVM_LIBDIR_SUFFIX "" CACHE STRING "Define suffix of library directory name (32/64)" )
 
 set(LLVM_TOOLS_INSTALL_DIR "bin" CACHE STRING "Path for binary subdirectory (defaults to 'bin')")
 mark_as_advanced(LLVM_TOOLS_INSTALL_DIR)
 

 option(LLVM_ENABLE_LIBCXX "Use libc++ if available." OFF)
 option(LLVM_STATIC_LINK_CXX_STDLIB "Statically link the standard library." OFF)
 option(LLVM_ENABLE_LLD "Use lld as C and C++ linker." OFF)
 option(LLVM_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
 option(LLVM_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
 
 option(LLVM_ENABLE_DUMP "Enable dump functions even when assertions are disabled" OFF)
 
-if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
+if( NOT CMAKE_BUILD_TYPE STREQUAL "Debug" )
   option(LLVM_ENABLE_ASSERTIONS "Enable assertions" OFF)
 else()
   option(LLVM_ENABLE_ASSERTIONS "Enable assertions" ON)
 endif()
 
 option(LLVM_ENABLE_EXPENSIVE_CHECKS "Enable expensive checks" OFF)
 
 # While adding scalable vector support to LLVM, we temporarily want to

 set(LLVM_INTEGRATED_CRT_ALLOC "" CACHE PATH "Replace the Windows CRT allocator with any of {rpmalloc|mimalloc|snmalloc}. Only works with /MT enabled.")
 if(LLVM_INTEGRATED_CRT_ALLOC)
   if(NOT WIN32)
     message(FATAL_ERROR "LLVM_INTEGRATED_CRT_ALLOC is only supported on Windows.")
   endif()
   if(LLVM_USE_SANITIZER)
     message(FATAL_ERROR "LLVM_INTEGRATED_CRT_ALLOC cannot be used along with LLVM_USE_SANITIZER!")
   endif()
-  if(CMAKE_BUILD_TYPE AND uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+  if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     message(FATAL_ERROR "The Debug target isn't supported along with LLVM_INTEGRATED_CRT_ALLOC!")
   endif()
 endif()
 
 # Define options to control the inclusion and default build behavior for
 # components which may not strictly be necessary (tools, examples, and tests).
 #
 # This is primarily to support building smaller or faster project files.

llvm/cmake/modules/AddLLVM.cmake

else()
       message(STATUS "Linker detection: unknown")
     endif()
   endif()
 endif()
 
 function(add_link_opts target_name)
   # Don't use linker optimizations in debug builds since it slows down the
   # linker in a context where the optimizations are not important.
-  if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+  if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
 
     # Pass -O3 to the linker. This enabled different optimizations on different
     # linkers.
     if(NOT (CMAKE_SYSTEM_NAME MATCHES "Darwin|SunOS|AIX|OS390" OR WIN32))
       set_property(TARGET ${target_name} APPEND_STRING PROPERTY
                    LINK_FLAGS " -Wl,-O3")
     endif()
 
if(APPLE)
     set(output_name "$<TARGET_FILE_NAME:${name}>.${file_ext}")
 
     if(LLVM_EXTERNALIZE_DEBUGINFO_OUTPUT_DIR)
       set(output_path "-o=${LLVM_EXTERNALIZE_DEBUGINFO_OUTPUT_DIR}/${output_name}")
     else()
       set(output_path "-o=${output_name}")
     endif()
 
+    string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
     if(CMAKE_CXX_FLAGS MATCHES "-flto"
       OR CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} MATCHES "-flto")
 
       set(lto_object ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${name}-lto.o)
       set_property(TARGET ${name} APPEND_STRING PROPERTY
         LINK_FLAGS " -Wl,-object_path_lto,${lto_object}")
     endif()
     if(NOT CMAKE_DSYMUTIL)

llvm/cmake/modules/AddOCaml.cmake

function(add_ocaml_library name)
 
   string(REPLACE ";" " " ARG_CFLAGS "${ARG_CFLAGS}")
   set(c_flags "${ARG_CFLAGS} ${LLVM_DEFINITIONS}")
   foreach( include_dir ${LLVM_INCLUDE_DIR} ${LLVM_MAIN_INCLUDE_DIR} )
     set(c_flags "${c_flags} -I${include_dir}")
   endforeach()
   # include -D/-UNDEBUG to match dump function visibility
   # regex from HandleLLVMOptions.cmake
+  string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
   string(REGEX MATCH "(^| )[/-][UD] *NDEBUG($| )" flag_matches
          "${CMAKE_C_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${CMAKE_C_FLAGS}")
   set(c_flags "${c_flags} ${flag_matches}")
 
   foreach( ocaml_file ${ARG_OCAML} )
     list(APPEND sources "${ocaml_file}.mli" "${ocaml_file}.ml")
 
     list(APPEND ocaml_inputs "${bin}/${ocaml_file}.mli" "${bin}/${ocaml_file}.ml")

llvm/cmake/modules/HandleLLVMOptions.cmake

 # This CMake module is responsible for interpreting the user defined LLVM_
 # options and executing the appropriate CMake commands to realize the users'
 # selections.
 
-# This is commonly needed so make sure it's defined before we include anything
-# else.
-string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
-
 include(CheckCompilerVersion)
 include(HandleLLVMStdlib)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 include(CheckSymbolExists)
 include(CMakeDependentOption)
 include(LLVMProcessSources)
 

 
 if( LLVM_ENABLE_ASSERTIONS )
   # MSVC doesn't like _DEBUG on release builds. See PR 4379.
   if( NOT MSVC )
     add_definitions( -D_DEBUG )
   endif()
   # On non-Debug builds cmake automatically defines NDEBUG, so we
   # explicitly undefine it:
-  if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
+  if( NOT CMAKE_BUILD_TYPE STREQUAL "Debug" )
     # NOTE: use `add_compile_options` rather than `add_definitions` since
     # `add_definitions` does not support generator expressions.
     add_compile_options($<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-UNDEBUG>)
 
     # Also remove /D NDEBUG to avoid MSVC warnings about conflicting defines.
     foreach (flags_var_to_scrub
         CMAKE_CXX_FLAGS_RELEASE
         CMAKE_CXX_FLAGS_RELWITHDEBINFO
if( XCODE )
     message(WARNING "-fPIC not supported with Xcode.")
   elseif( WIN32 OR CYGWIN)
     # On Windows all code is PIC. MinGW warns if -fPIC is used.
   else()
     add_flag_or_print_warning("-fPIC" FPIC)
   endif()
   # GCC for MIPS can miscompile LLVM due to PR37701.
   if(CMAKE_COMPILER_IS_GNUCXX AND LLVM_NATIVE_ARCH STREQUAL "Mips" AND
-         NOT Uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+         NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
     add_flag_or_print_warning("-fno-shrink-wrap" FNO_SHRINK_WRAP)
   endif()
   # gcc with -O3 -fPIC generates TLS sequences that violate the spec on
   # Solaris/sparcv9, causing executables created with the system linker
   # to SEGV (GCC PR target/96607).
   # clang with -O3 -fPIC generates code that SEGVs.
   # Both can be worked around by compiling with -O instead.
   if(${CMAKE_SYSTEM_NAME} STREQUAL "SunOS" AND LLVM_NATIVE_ARCH STREQUAL "Sparc")
if( MSVC )
   # https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
   append("/Zc:__cplusplus" CMAKE_CXX_FLAGS)
 
   # Allow users to request PDBs in release mode. CMake offeres the
   # RelWithDebInfo configuration, but it uses different optimization settings
   # (/Ob1 vs /Ob2 or -O2 vs -O3). LLVM provides this flag so that users can get
   # PDBs without changing codegen.
   option(LLVM_ENABLE_PDB OFF)
-  if (LLVM_ENABLE_PDB AND uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
+  if (LLVM_ENABLE_PDB AND CMAKE_BUILD_TYPE STREQUAL "Release")
     append("/Zi" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     # /DEBUG disables linker GC and ICF, but we want those in Release mode.
     append("/DEBUG /OPT:REF /OPT:ICF"
           CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS
           CMAKE_SHARED_LINKER_FLAGS)
   endif()
 
   # Disable string literal const->non-const type conversion.
if ( LLVM_COMPILER_IS_GCC_COMPATIBLE AND LLVM_ENABLE_MODULES )
   if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     # On Darwin -fmodules does not imply -fcxx-modules.
     set(module_flags "${module_flags} -fcxx-modules")
   endif()
   if (LLVM_ENABLE_LOCAL_SUBMODULE_VISIBILITY)
     set(module_flags "${module_flags} -Xclang -fmodules-local-submodule-visibility")
   endif()
   if (LLVM_ENABLE_MODULE_DEBUGGING AND
-      ((uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG") OR
-       (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")))
+      ((CMAKE_BUILD_TYPE STREQUAL "Debug") OR
+       (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")))
     set(module_flags "${module_flags} -gmodules")
   endif()
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${module_flags}")
 
   # Check that we can build code with modules enabled, and that repeatedly
   # including <cassert> still manages to respect NDEBUG properly.
   CHECK_CXX_SOURCE_COMPILES("#undef NDEBUG
                              #include <cassert>
if (LLVM_COMPILER_IS_GCC_COMPATIBLE AND NOT LLVM_ENABLE_WARNINGS)
   append("-w" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 endif()
 
 macro(append_common_sanitizer_flags)
   if (NOT MSVC)
     # Append -fno-omit-frame-pointer and turn on debug info to get better
     # stack traces.
     add_flag_if_supported("-fno-omit-frame-pointer" FNO_OMIT_FRAME_POINTER)
-    if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND
-        NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")
+    if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug" AND
+        NOT CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
       add_flag_if_supported("-gline-tables-only" GLINE_TABLES_ONLY)
     endif()
     # Use -O1 even in debug mode, otherwise sanitizers slowdown is too large.
-    if (uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND LLVM_OPTIMIZE_SANITIZED_BUILDS)
+    if (CMAKE_BUILD_TYPE STREQUAL "Debug" AND LLVM_OPTIMIZE_SANITIZED_BUILDS)
       add_flag_if_supported("-O1" O1)
     endif()
   elseif (CLANG_CL)
     # Keep frame pointers around.
     append("/Oy-" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     # Always ask the linker to produce symbols with asan.
     append("/Z7" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     append("-debug" CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
if (EXISTS "${BLACKLIST_FILE}")
       append("-fsanitize-blacklist=${BLACKLIST_FILE}"
              CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     endif()
   endif()
 endif()
 
 # Turn on -gsplit-dwarf if requested in debug builds.
 if (LLVM_USE_SPLIT_DWARF AND
-    ((uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG") OR
-     (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")))
+    ((CMAKE_BUILD_TYPE STREQUAL "Debug") OR
+     (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")))
   # Limit to clang and gcc so far. Add compilers supporting this option.
   if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR
       CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     add_compile_options(-gsplit-dwarf)
   endif()
 endif()
 
 add_definitions( -D__STDC_CONSTANT_MACROS )

 endif()
 
 # Add flags for add_dead_strip().
 # FIXME: With MSVS, consider compiling with /Gy and linking with /OPT:REF?
 # But MinSizeRel seems to add that automatically, so maybe disable these
 # flags instead if LLVM_NO_DEAD_STRIP is set.
 if(NOT CYGWIN AND NOT WIN32)
   if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND
-     NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+     NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
     check_c_compiler_flag("-Werror -fno-function-sections" C_SUPPORTS_FNO_FUNCTION_SECTIONS)
     if (C_SUPPORTS_FNO_FUNCTION_SECTIONS)
       # Don't add -ffunction-sections if it can't be disabled with -fno-function-sections.
       # Doing so will break sanitizers.
       add_flag_if_supported("-ffunction-sections" FFUNCTION_SECTIONS)
     elseif (CMAKE_CXX_COMPILER_ID MATCHES "XL")
       append("-qfuncsect" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     endif()
     add_flag_if_supported("-fdata-sections" FDATA_SECTIONS)
   endif()
 elseif(MSVC)
-  if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
+  if( NOT CMAKE_BUILD_TYPE STREQUAL "Debug" )
     append("/Gw" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
   endif()
 endif()
 
 if(MSVC)
   # Remove flags here, for exceptions and RTTI.
   # Each target property or source property should be responsible to control
   # them.

llvm/cmake/modules/TableGen.cmake

if (LLVM_ENABLE_GISEL_COV)
     list(FIND ARGN "-gen-global-isel" idx)
     if( NOT idx EQUAL -1 )
       list(APPEND LLVM_TABLEGEN_FLAGS "-instrument-gisel-coverage")
       list(APPEND LLVM_TABLEGEN_FLAGS "-gisel-coverage-file=${LLVM_GISEL_COV_PREFIX}all")
     endif()
   endif()
   # Comments are only useful for Debug builds. Omit them if the backend
   # supports it.
-  if (NOT (uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" OR
-           uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO"))
+  if (NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR
+           CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo"))
     list(FIND ARGN "-gen-dag-isel" idx)
     if (NOT idx EQUAL -1)
       list(APPEND LLVM_TABLEGEN_FLAGS "-omit-comments")
     endif()
   endif()
 
   # MSVC can't support long string literals ("long" > 65534 bytes)[1], so if there's
   # a possibility of generated tables being consumed by MSVC, generate arrays of

llvm/lib/Support/CMakeLists.txt

 endif()
 
 # Link Z3 if the user wants to build it.
 if(LLVM_WITH_Z3)
   set(system_libs ${system_libs} ${Z3_LIBRARIES})
 endif()
 
 # Override the C runtime allocator on Windows and embed it into LLVM tools & libraries
+string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 if(LLVM_INTEGRATED_CRT_ALLOC)
   if (CMAKE_BUILD_TYPE AND NOT ${LLVM_USE_CRT_${uppercase_CMAKE_BUILD_TYPE}} MATCHES "^(MT|MTd)$")
     message(FATAL_ERROR "LLVM_INTEGRATED_CRT_ALLOC only works with /MT or /MTd. Use LLVM_USE_CRT_${uppercase_CMAKE_BUILD_TYPE} to set the appropriate option.")
   endif()
 
   string(REGEX REPLACE "(/|\\\\)$" "" LLVM_INTEGRATED_CRT_ALLOC "${LLVM_INTEGRATED_CRT_ALLOC}")
 
   if(NOT EXISTS "${LLVM_INTEGRATED_CRT_ALLOC}")

llvm/utils/benchmark/test/CMakeLists.txt

 # Enable the tests
 
 find_package(Threads REQUIRED)
 include(CheckCXXCompilerFlag)
 
 # NOTE: Some tests use `<cassert>` to perform the test. Therefore we must
 # strip -DNDEBUG from the default CMake flags in DEBUG mode.
-string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
-if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
+if( NOT CMAKE_BUILD_TYPE STREQUAL "Debug" )
   add_definitions( -UNDEBUG )
   add_definitions(-DTEST_BENCHMARK_LIBRARY_HAS_NO_ASSERTIONS)
   # Also remove /D NDEBUG to avoid MSVC warnings about conflicting defines.
   foreach (flags_var_to_scrub
       CMAKE_CXX_FLAGS_RELEASE
       CMAKE_CXX_FLAGS_RELWITHDEBINFO
       CMAKE_CXX_FLAGS_MINSIZEREL
       CMAKE_C_FLAGS_RELEASE