[llvm-dev] Upgrading LLVM's minimum required CMake version (original) (raw)

Louis Dionne via llvm-dev llvm-dev at lists.llvm.org
Tue Jun 30 08:04:14 PDT 2020

On Apr 8, 2020, at 13:06, Louis Dionne <ldionne at apple.com> wrote:

On Apr 2, 2020, at 10:19, Louis Dionne via llvm-dev <llvm-dev at lists.llvm.org <mailto:llvm-dev at lists.llvm.org>> wrote: Okay, so we've had some discussion on this thread, and although some people (including me) would like a more aggressive policy, I believe the following will not get any objection (based on the thread). On April 23rd 2020, Ubuntu 20.04 LTS will ship with CMake 3.16.x. This will make the lower bound for LTS distributions be 3.13.4, and so I suggest we upgrade to that. Here's a proposed process: 1. Immediately add a CMake warning in /llvm/CMakeLists.txt saying that CMake 3.13.4 will be the new minimum version starting with LLVM 12.0.0, and mentioning the versions used in various LTSes. 2. Immediately send a courtesy heads-up email to all build-bot owners telling them about the upcoming change. 3. Right after we branch off the release branch for LLVM 11.0.0 (the next one), make the minimum CMake version required be 3.13.4. 4. Iterate on (3) until all bots are migrated. 5. Send a message to the list saying the bump is complete. At that time, projects are free to start using features from 3.13.4. Unless someone else absolutely wants to bite the bullet, I volunteer to do the above steps. Ok, so the thread has kept going, but AFAICT all the discussion is about a policy for "automatic" upgrades. So I've went ahead and did the first two steps of the above algorithm: (1) Review at https://reviews.llvm.org/D77740 <https://reviews.llvm.org/D77740> (2) Email sent to the owners of all build slaves listed on http://lab.llvm.org:8011/buildslaves <http://lab.llvm.org:8011/buildslaves> Just to reiterate, this means that as soon as we branch LLVM 11.0.0 (the NEXT release), CMake 3.13.4 will be the minimum required version.

Hi,

Just a heads up that about two weeks from now, we should be branching for the LLVM 11.0.0 release. Right after we branch, I will implement steps (3) and (4) of the algorithm described above, which is to make the minimum CMake version required be 3.13.4. I will do this by checking-in this patch: https://reviews.llvm.org/D78646 <https://reviews.llvm.org/D78646>.

That patch will cause errors whenever the CMake version is less than 3.13.4 -- I will then revert and re-apply this patch until all build bots have upgraded to a sufficient CMake. The patch was crafted to be minimal and revert-friendly. Note that build bot owners have already been contacted in March and pinged several times again for those who had not yet upgraded. At this time, I think only 1-2 bots have not upgraded.

Once everyone has upgraded, I will then apply this patch: https://reviews.llvm.org/D78648 <https://reviews.llvm.org/D78648>. That patch marks the minimum CMake version required as being 3.13.4 throughout the monorepo in a slightly more invasive but definitive way. Once that's all done, I'll report to the list that the version bump is complete and we can all start using modern CMake features.

Cheers, Louis

Cheers, Louis

On Mar 26, 2020, at 16:07, Shoaib Meenai <smeenai at fb.com <mailto:smeenai at fb.com>> wrote:

We had this discussion a few months ago and it petered out, and it’s recently been revived in the context of upgrading the CMake version specifically for libc++ (at which point people suggested upgrading the CMake version used by all of LLVM), so let’s try to move this forward. Our current required minimum version is CMake 3.4.3, which was released on January 25th 2016. It’s interesting to note that LLVM started requiring 3.4.3 on May 31st 2016, which was just 4 months after its release. Let’s look at the CMake versions available on various distros and operating systems. I’m unfamiliar with many of these, so I apologize if I get something wrong. (I’m using pkgs.org <http://pkgs.org/> for most of this information.) * RHEL 6 (released Nov 10th 2010) : 3.6.1 (via EPEL) * RHEL 7 (released June 10th 2014): 3.14.7 (via EPEL) * RHEL 8 (released May 7th 2019): 3.11.4 (maybe pkgs.org <http://pkgs.org/> is screwy on this one, because it doesn’t make sense that RHEL 7 should have a newer available version than RHEL 8) * Debian 9 (released June 17th 2017): 3.7.2 * Debian 10 (released July 6th 2019): 3.13.4 * Ubuntu 16.04 LTS (released April 21st 2016): 3.5.1 * Ubuntu 18.04 LTS (released April 26th 2018): 3.10.2 * FreeBSD 11 (released October 10th 2016): 3.15.5 (presumably upgraded in a point release) * FreeBSD 12 (released December 11th 2018): 3.15.5 (presumably upgraded in a point release) * NetBSD 8.1 (released May 31st 2019): 3.16.1 * NetBSD 9.0 (released February 14th 2020): 3.16.1 * OpenBSD: couldn’t find the version * macOS: latest version is readily available through Homebrew * Windows: You can install it yourself or use the one bundled with Visual Studio. I don't know what versions are bundled with Visual Studio; some searching suggests Visual Studio 2017 has CMake 3.12 and Visual Studio 2019 has 3.15, though I have no confirmation of that. Note that CMake provides prebuilt binaries for Linux, macOS, and Windows, and it’s also straightforward to build from source (it has very conservative compiler requirements). One suggestion that was brought up in the past was for LLVM’s build system to just download a newer version of CMake if you attempted to build it using one that was too old, but there was opposition [1]. There was also a suggestion to have a script in LLVM to download and build CMake for you, but there were mixed opinions on this too [2], particularly since many developers might prefer downloading a binary release to building from source themselves (though of course the script could also download binary releases if applicable). I personally think downloading or building CMake yourself isn’t a high barrier for anyone wanting to build LLVM (and in particular it’s much more straightforward than building LLVM itself), but I can understand why people would prefer to stick to versions available in distros. Another suggestion that came up last time was to set a policy for upgrading CMake versions on some regular basis. The opposition to this was that we should upgrade CMake versions only when a newer version has a compelling enough feature to justify upgrading, rather than always upgrading. I can see arguments for both approaches, but we should definitely at least think about the benefits we can get from upgrading versions. I've gone through the CMake release notes and highlighted features which seemed potentially valuable for LLVM. Note that I'm only highlighting features for which our minimum CMake version would have to be bumped up in order for our build system to take advantage of. There are other useful features in newer CMake versions, but you can take advantage of them just by using a newer CMake yourself. For example, 3.9 loosens the dependencies of object compilation, which should result in faster Ninja builds. CMake 3.5 (released March 8th 2016): * install(DIRECTORY) supports generator expressions CMake 3.6 (released July 7th 2016): * install() supports EXCLUDEFROMALL * list() supports FILTER to filter by regular expression * Subninja support, which could theoretically be used for much faster runtimes builds, although in practice we probably want to make ExternalProject support this directly instead of trying to layer our own meta-build system on top * CMAKETRYCOMPILETARGETTYPE to tell trycompile to build a static library instead of an executable, which will greatly simplify the compiler-rt build CMake 3.7 (released November 11th 2016): * New if() comparison operators LESSEQUAL, GREATEREQUAL, STRLESSEQUAL, STRGREATEREQUAL, VERSIONLESSEQUAL, and VERSIONGREATEREQUAL CMake 3.8 (released April 10th 2017): * Compile features for C++17, which is required to build libc++ correctly * Support for compile features for specific C++ features instead of only being able to specify standard versions * rpath support via BUILDRPATH target property and CMAKEBUILDRPATH variable * Apple framework support for static libraries * New swigaddlibrary command in the UseSWIG module * New generator expression $IF:cond,true-value,false-value CMake 3.9 (released July 18th 2017): * install(TARGETS) and install(EXPORTS) support for object libraries, which will simplify the compiler-rt build * TARGETOBJECTS generator expression support in addcustomcommand and file(GENERATE) * <TARGETBUNDLEDIR:tgt>and<TARGETBUNDLEDIR:tgt> and <TARGETBUNDLEDIR:tgt>andTARGETBUNDLECONTENTDIR:tgt generator expressions for Apple bundles CMake 3.10 (released November 20th 2017): * includeguard() command for proper guarding against double includes of CMake scripts * An interesting aside is that this is the first verion of CMake to require C++11 to build, which should give a good sense of how conservative they are about compiler requirements CMake 3.11 (released March 28th 2018): * addlibrary() and addexecutable() can be called without sources as long as targetsources() is used later * targetcompile{definitions,features,options}, targetincludedirectories(), targetsources(), and targetlinklibraries() can set the corresponding INTERFACE* properties on imported targets * COMPILEDEFINITIONS supports generator expressions * COMPILEOPTIONS source file property added * INCLUDEDIRECTORIES source file property added * Interface libraries support custom properites CMake 3.12 (released July 17th 2018): * addcompiledefinitions() added to add compile definitions for targets (to avoid the global pollution caused by adddefinitions()) * cmakeminimumrequired() supports a version range to indicate tested CMake versions and set policies accordingly * file(TOUCH) and file(TOUCHNOCREATE) added * list(JOIN), list(SUBLIST) and list(TRANSFORM) added * string(JOIN) added * SHELL: prefix support in targetcompileoptions to avoid errant deduplication * targetlinklibraries() supports object libraries and propagates usage requirements * EXPORTPROPERTIES target property to control the target properties exported by export() and install(EXPORT) * FindLibXml2 provides imported targets * New FindPython, FindPython2, and FindPython3 modules to ease location Python and selecting a specific version * Modernization of UseSWIG module * New generator expressions <GENEXEVAL:...>,<GENEXEVAL:...>, <GENEXEVAL:...>,TARGETGENEXEVAL:target,..., <INLIST:...>,<INLIST:...>, <INLIST:...>,TARGETEXISTS:... and $TARGETNAMEIFEXISTS:... * Compile features support for C++20 CMake 3.13 (released November 20th 2018): * cmake -E createsymlink supported on Windows * targetlinkdirectories() and targetlinkoptions() commands to set link options instead of awkwardly having to use targetlinklibraries() for this purpose * UseSWIG can manage INCLUDEDIRECTORIES for SWIG compilation CMake 3.14 (released March 14th 2019): * file(CREATELINK) to create hard or symbolic links * if(DEFINED CACHE{VAR}) for checking if a cache variable is defined * $INLIST:... generator expression correctly handles empty argument * Fixes for object library linking propagation * Link options to manage position independent executables added automatically CMake 3.15 (released July 17th 2019): * list(PREPEND), list(POPFRONT) and list(POPBACK) added * New message() types NOTICE, VERBOSE, DEBUG and TRACE * string(REPEAT) added * MSVCRUNTIMELIBRARY target property and CMAKEMSVCRUNTIMELIBRARY variable to select the runtime library type for MSVC * <CCOMPILERID:...>,<CCOMPILERID:...>, <CCOMPILERID:...>,CXXCOMPILERID:..., <COMPILELANGUAGE:...>,and<COMPILELANGUAGE:...>, and <COMPILELANGUAGE:...>,andPLATFORMID:... generator expressions support matching one value from a list * $COMPILELANGANDID:... generator expression added * $FILTER:list,INCLUDE|EXCLUDE,regex generator expression added * $REMOVEDUPLICATES:list generator expression added * New <TARGETFILE∗>generatorexpressionsadded:<TARGETFILE*> generator expressions added: <TARGETFILE∗>generatorexpressionsadded:TARGETFILEPREFIX:..., <TARGETFILEBASENAME:...>,<TARGETFILEBASENAME:...>, <TARGETFILEBASENAME:...>,TARGETFILESUFFIX:..., <TARGETLINKERFILEPREFIX:...>,<TARGETLINKERFILEPREFIX:...>, <TARGETLINKERFILEPREFIX:...>,TARGETLINKERFILEBASENAME:..., <TARGETLINKERFILESUFFIX:...>,<TARGETLINKERFILESUFFIX:...>, <TARGETLINKERFILESUFFIX:...>,TARGETPDBFILEBASENAME:... * $TARGETOBJECTS:... generator expression supports executables and static, shared, and module libraries CMake 3.16 (released November 26th 2019): * Support for generator expressions in BUILDRPATH and INSTALLRPATH CMake 3.17 (released March 20th 2020): * Ninja Multi-Config generator, which among other things would greatly simplify LLVMOPTIMIZEDTABLEGEN * foreach(ZIPLISTS) added to iterate multiple lists simultaneously * New message() keywords CHECKSTART, CHECKPASS, and CHECKFAIL * INSTALLNAMEDIR supports generator expressions Our build system is incredibly complex, and many of these features can be used to clean it up and make it much more maintainable. I would personally like us to at least bump up to CMake 3.12. I also do think it's worth establishing a policy and process around upgrading CMake versions, since newer versions keep on adding useful features (particularly better generator expression support), and we want to be able to keep taking advantage of them. [1] http://lists.llvm.org/pipermail/llvm-dev/2019-November/136485.html <http://lists.llvm.org/pipermail/llvm-dev/2019-November/136485.html> [2] http://lists.llvm.org/pipermail/llvm-dev/2019-November/136488.html <http://lists.llvm.org/pipermail/llvm-dev/2019-November/136488.html>

LLVM Developers mailing list llvm-dev at lists.llvm.org <mailto:llvm-dev at lists.llvm.org> https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev

-------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20200630/0ff8f748/attachment.html>

More information about the llvm-dev mailing list