Hi, I get the feeling this question is going to be shot down in flames but anyway... from what I can see, the utils tool scripts in swift do some fairly obvious things and are there to make your life easier, but of course slightly hide what's happening "really".
Caveat: my source is still a bit old, swift 5.3.x
As I understand it, build-script is a python wrapper for build-script-impl, which is itself a shell script, that in turn basically copies some files around to set up an out of source build area then runs CMake, which does the main body of the work to make a buildable project. For example if you do utils/build-script -x it will invoke cmake -G Xcode.
I want to see if I can bypass the middleman and do these steps myself, rather than relying on scripts.
My reasons?
familiarity, I've always used CMake with llvm and I know where I am
reliability, these scripts make "normal" builds of swift, especially for newer developers, much more of a point-and-click affair... but for me, I find they're easier to break if I don't do the standard builds, if python2 has disappeared from my mac (for example) and so on... generally I don't like this feeling and I think it's a bit of a "black box".
flexibility, in my use case today I wanted to set up a CI server to build my forks of swift/llvm but just parts of them (like the llvm libraries but not compiler-rt and the swift compiler but not the standard library and not run unit tests) and I'm left scratching my head what is being done by the 4000 lines of scripting and what is being done by standard tools like cmake and ninja.
I would suggest taking a look at swift/build-windows-toolchain.bat at main · apple/swift (github.com) as that is a trace of all the cmake invocations needed to build a complete toolchain for Windows. There are a couple of cmake caches for other platforms as well if you are building for a different platform.
This looks like it tries to create the out of tree build directory for the "toolchain" in (forgive me translating to unix so I can understand it)... ${BuildRoot}/1 and then runs cmake --build in that directory to actually build the product and finally cmake --build ... --target install to install the built product somewhere suitable.
It then builds the "standard library" in ${BuildRoot}/2 and goes on from there (libdispatch, spm, etc. etc.) ... the subdirectories in these builds just have numbers because there's no real need to give these intermediates meaningful paths, right? Or is this just me not able to read Windows batch files?
When it says build "toolchain" that looks to me like llvm/clang, right? And where the comment says it's building the standard library, that looks to me like it's building the swift compiler and then the standard library, is that correct? The comments maybe aren't 100% accurate there? Or am I missing something?
Yes, each set of products are configured, built, installed for the most part.
They are numbers to compress the path as the paths are incredibly long (260+ characters) which causes problems.
No, the toolchain is the full toolchain: all compilers, linkers, debuggers, resources, and binary utilities. The swift compiler is part of the toolchain. The runtime only builds the swift standard library.
