I've just got a MacOS 2 days ago with Mojave 10.14.5 and I was trying to install the latest Clang 12.0.0 but to no avail. I can't upgrade the OS to Catalina, so when I tried the XCode route I could only get the 13.1 version, with LLVM 10.0.1 and Clang-1001.0.46.4.
Then I followed this guide :
https://embeddedartistry.com/blog/2017/02/24/installing-llvm-clang-on-osx/
which was supposed to help me upgrade the llvm and clang through brew, and I successfully did it.
I got it up to LLVM 11.0.0 (I checked it out through "brew info llvm"), nonetheless when I use the command "clang --version", it still gives me:
Apple LLVM version 10.0.1 (clang-
1001.0.46.4)
Target: x86_64-apple-darwin18.6.0
Thread model: posix
InstalledDir:/Library/Developer/CommandLineTools/u
sr/bin
So I have 2 questions:
Did I miss something in the brew installation?
Is there another way to update to clang without the OS upgrade?
P.s
In the guide I couldn't do from the "Where to find llvm/clang" and downwards, since many of those commands weren't recognized by the terminal
Repost?
homebrew installs binaries into /usr/local/bin, so you normally need to put that at the start of your PATH:
export PATH=/usr/local/bin:$PATH
You can check which clang will be run when you type clang in your Terminal by running:
type clang
If that tells you clang is /usr/bin/clang or /Applications/anything or /Library/anything, that means it is supplied by Apple.
If it contains /usr/local/anything or /opt/anything, it is probably supplied by homebrew.
For hombrew problems, try asking the good doctor:
brew doctor
Related
Mac 10.13.6 High Sierra here. New to C development and I'm trying to get myself setup with the latest stable/recommended GCC version, which I believe (keep me honest here) is 10.2.
When I go to the terminal to see what I have installed:
$ gcc --version
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
Apple LLVM version 9.1.0 (clang-902.0.39.1)
Target: x86_64-apple-darwin17.7.0
Thread model: posix
InstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin
$ gcc -dumpversion
4.2.1
OK...surprised to see LLVM/clang-related stuff in the output. So I try this:
$ clang --version
Apple LLVM version 9.1.0 (clang-902.0.39.1)
Target: x86_64-apple-darwin17.7.0
Thread model: posix
InstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin
So its almost as if... I have both clang and gcc installed, but my clang installation has assimilated my GCC installation?! Why else would the gcc --version output reference clang?
Is this typical for Mac setups?
What do I need to do to get GCC 10.2 properly installed on my machine?
Here are some simple truths, statements and observations to try and explain what's going on:
Apple ships the clang/LLVM compiler with macOS. Clang is a "front-end" that can parse C, C++ and Objective-C down to something that LLVM (referred to as a "back-end") can compile
Clang/LLVM is located in /Applications/Xcode.app/somewhere
Apple also ships a /usr/bin/gcc which just runs clang. I have no idea why they do that - it doesn't seem very helpful to me - but they don't answer my questions
Apple puts its binaries (programs) in /usr/bin. That is an integral part of macOS and you should never touch or change anything in there - you are asking for problems if you do. This warning applies to Python too.
If you want the real, lovely GNU Compiler Collection (GCC) which includes the gcc, g++ and gfortran compilers, your best bet, IMHO, is to get them from homebrew. I will not put the installation instructions here because they could become outdated, so you should use the ones on the homebrew site.
Once you have homebrew installed, you can install the GNU Compiler Collection (GCC) with:
brew install gcc
After that, you will have all the lovely GNU Compiler Collection (GCC) of tools in /usr/local/bin, so you should put that in your PATH, near the beginning, and in any case before /usr/bin, using:
export PATH=/usr/local/bin:$PATH
In general, you should also add a similar line into your login profile, or into the system login profile, so it is set up every time you or any other user logs in.
Let's take a look:
ls /usr/local/bin/gcc* /usr/local/bin/g++*
/usr/local/bin/gcc-10
/usr/local/bin/g++-10
Depending on the versions and updates, you will then have these programs available:
gcc-10 # the real GNU C compiler
g++-10 # the real GNU C++compiler
gfortran # GNU fortran compiler
And you can check their versions with:
gcc-10 -v
g++-10 -v
gfortran -v
Now you know about homebrew, here are some more simple truths and observations:
folks (who are not the supplier of the operating system) who supply binaries (programs) for you should put their stuff in /usr/local to show that it is just a locally installed program rather than a part of the core macOS operating system
homebrew is well-behaved and installs its binaries (programs) in /usr/local/Cellar and then usually makes symbolic links from /usr/local/bin/PROGRAM to the Cellar. None of this interferes with Apple-supplied stuff.
if you want to run the homebrew version of a command, you should have /usr/local/bin first on your PATH
Let's have a look at those symbolic links:
ls -l /usr/local/bin/g*10
lrwxr-xr-x 1 mark admin 31 21 Aug 16:41 /usr/local/bin/g++-10 -> ../Cellar/gcc/10.2.0/bin/g++-10
lrwxr-xr-x 1 mark admin 31 21 Aug 16:41 /usr/local/bin/gcc-10 -> ../Cellar/gcc/10.2.0/bin/gcc-10
If you want to know what you are actually running when you enter a command, use the type command like this.
type gcc
gcc is hashed (/usr/bin/gcc)
That tells you that if you run gcc you will actually be running /usr/bin/gcc which we know is from Apple - because it is in /usr/bin
Now try this:
type gcc-10
gcc-10 is hashed (/usr/local/bin/gcc-10)
That tells you that if you run gcc-10 you will actually be running /usr/local/bin/gcc-10 which we know is from homebrew - because it is in /usr/local/bin
Note: None of the answers provided at Get Apple clang version and corresponding upstream LLVM version seems to work anymore.
The download page at http://releases.llvm.org/download.html and the Wikipedia article at https://en.wikipedia.org/wiki/Clang seems to indicate that the most recent Clang version is 6.0.0.
But on my macOS High Sierra version 10.13.3, I see this output:
$ clang --version
Apple LLVM version 9.1.0 (clang-902.0.39.1)
Target: x86_64-apple-darwin17.4.0
Thread model: posix
InstalledDir: /Library/Developer/CommandLineTools/usr/bin
$ which clang
/usr/bin/clang
This does not seem right. Why is the Apple's version of Clang greater than the current version of Clang?
How do I find out which version of Clang hosted on http://releases.llvm.org/download.html does my Mac's version of Clang correspond to?
I ask this because I see http://releases.llvm.org/6.0.0/tools/clang/docs/UsersManual.html documenting a -pedantic option for the clang command line, but it is not documented in the man page of clang on my system.
$ man clang | grep pedantic
$ clang --help | grep pedantic
$
launch terminal and enter:
clang --version
Apple clang version 11.0.0 (clang-1100.0.33.16)
This wikipedia table maps Xcode and Apple clang versions to LLVM versions.
Your clang-902.0.39.1 appears to be based on LLVM 5.0.2.
You could try using
echo | clang -dM -E - | grep __clang
and maybe that will give you more reliable numbers. Although I'm speculating since I'm not on a Mac.
Also, clang has had the -pedantic option for a long long time - many versions before 6.0. -pedantic is a GCC option and clang takes after GCC in its options.
The original question asked specifically about determining the corresponding "llvm.org" Clang version for a give Apple Clang compiler, which doesn't seem to be well-addressed by the other answers. In early versions of Apple Clang, the actual base LLVM version was included in the output of the clang --version command. That hasn't been the case for years now, and many sites that list the LLVM versions don't include info past the point where Apple stopped providing it.
Apple maintains a public fork of the "llvm-project" source code on GitHub. As far as I know, this is the only reliable way to determine the base LLVM version for a given version of Xcode/Clang/Swift. Apple overrides the LLVM and Clang version numbers as part of the build process, but the original LLVM version is defined in the CMakeLists.txt file for the llvm subproject. You can use the following steps to find the version for your current Xcode:
Run swift -frontend -version to get the Swift version for the installed Xcode. This seems counter-intuitive if you are trying to find the version for Clang, but Apple tags their open-source repo based on the Swift version.
Open https://github.com/apple/llvm-project/blob/next/llvm/CMakeLists.txt in your web browser. This is the file that contains the LLVM version numbers, but you will first land on the current development version and not the actual version that you want.
In the top left corner next to the filename, look for the drop-down button with the word "next". If you are familiar with GitHub, you know that this is the branch/tag selector.
Click on the drop-down, switch to the "Tags" view, then search for swift-<version>-RELEASE, where <version> is the Swift version number from step 1. For example, Xcode 13.4 uses Swift 5.6.1 so you would search for swift-5.6.1-RELEASE. Click on the tag name to select that revision.
In the CMakeLists.txt file, look for the line that sets the LLVM_VERSION_MAJOR variable. The MAJOR, MINOR and PATCH versions will give you the exact version of LLVM on which the Apple build is based. For Xcode 13.4, where Apple Clang reports a version of 13.1.6, you will see that it is based on LLVM 13.0.0.
The major version for Apple Clang is always the same as the major version of the corresponding Xcode. The fact that the major version of Apple Clang and the base LLVM happen to match in the Xcode 13.4 example is purely coincidental. Clang 13.1.6, which was first released with Xcode 13.3, is the first release in years where this has been the case, although the minor and patch versions are obviously still different.
Also be aware that Apple Clang is only based on the corresponding "llvm.org" source code. It is built from a fork that may include some Apple-specific differences, and there are also additional code changes in the proprietary Xcode release of Apple Clang that may not appear in the Apple open-source fork on GitHub.
Finally, many default values can be specified at build time and may be different between the Apple and "llvm.org" Clang compilers. For example, Apple Clang sometimes uses different default C and C++ standards when a specific standard version is not specified on the command-line. Apple Clang 13.1.6 and "llvm.org" both default to C17 for the C standard, but Apple still defaults to the original C++98 standard for C++ while "llvm.org" Clang 13 defaults to C++14.
I am an expert on this.
If you use "clang --version" to checkout the version of the clang compiler on your mac, then as you got that:
Apple LLVM version 9.1.0 (clang-902.0.39.1)
Target: x86_64-apple-darwin17.4.0
Thread model: posix
InstalledDir: /Library/Developer/CommandLineTools/usr/bin
What you want to know that which the actual Clang version on Mac?
In other words, you want to ask, which the actual Clang version for your Xcode is been used on Mac?
As your Mac terminal output,(The output tells you things about your Xcode on your mac)
the first line "Apple LLVM version 9.1.0 (clang-902.0.39.1)" means:
your installed Xcode version was 9.3 or 9.3.1, including the default installed Clang version 9.1.0(This Clang version Identifier wasclang-902.0.39.1).
the second and third line do no matter with your Clang Version.
the fourth line "InstalledDir: /Library/Developer/CommandLineTools/usr/bin"means:
Where is your now using Clang locations. Or, if you want to know which clang version are your Xcode(mac) using? you need to go that directory /Library/Developer/CommandLineTools/usr/bin. Just use this command to checkout which clang version your Mac(==Xcode) are using now:
cd /Library/Developer/CommandLineTools/usr/lib/clang/ && ls
That may show like this: 9.0.0 or 9.1.0 or 10.0.0.
As this may show, The Clang version of your Xcode Now may use 9.0.0, or 9.0.1 or 10.0.0.
But why your now using Clang version is different from the default installed Clang version of Xcode including?
Or, why there is another Clang version out of the default including Clang version of Xcode?
Or, Xcode comes with Clang, why there is another version Clang?
As I know, the newable version of Xcodes are including the Command Line Tools. Or, the new version of Xcode comes with Command Line Tools; or, If you use Xcode, the Command Line Tools are also embedded within the Xcode IDE. And the Command Line Tool are including many useful tools, such as
the Apple LLVM compiler(LLVM-Clang), linker, and Make.
Also, Why you have a Command Line Tools of Xcode and another separated Command-Line Tools. Maybe you install a separated Command Line Tools after installing Xcode! And, you may select the separated Command-Line Tools via using "xcode-select --switch <path>" to replace the default Command Line Tools of Xcode
according to the old blog's guidance.
Just like this image(from Chinese Website juejing)
As I see, The Xcode.app was stored in /Applications/Xcode.app/Contents/Developer. The separated Command Line Tools was stored in /Library/Developer/CommandLineTools.
Just like this image(from Chinese Blog Website juejin):
So, when you use "clang --version" to check out the clang version of your Mac you are using, that shows:
Apple LLVM version 9.1.0 (clang-902.0.39.1)
Target: x86_64-apple-darwin17.4.0
Thread model: posix
InstalledDir: /Library/Developer/CommandLineTools/usr/bin
So, if you are using the default Xcode of command-line Tools, what would that "clang --version" output? Here comes the using default Xcode of command-line Tools:
Apple LLVM version 9.1.0 (clang-902.0.39.1)
Target: x86_64-apple-darwin17.4.0
Thread model: posix
InstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin
All in all, if you have more than one xcode installed on mac or more than one separated command-line tools, you will have more than one command-line tools; Just like the image(from Chinese Website Blog juejin) shows:
Others, the connection of Xcode and command-line tools just like this image(from Chinese Website juejin)
Also, you will have more than one clang to choose from using.
Last, what i want to say is, which clang version are your mac using, that depends the directory of command-line tools's chosed InstalledDir.
If your mac use the default embeded Xcode command-line tools,
then, that "Apple LLVM version 9.1.0 (clang-902.0.39.1)" shows your using Clang 9.1.0 with it's Identifier clang-902.0.39.1, your using Clang installed dirctory was in
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin
If your mac use separated command-line tools, then, that "Apple LLVM version 9.1.0 (clang-902.0.39.1)" ONLY express your installed Xcode 9.3/9.3.1 with embedded command-line tools(Clang 9.1.0) , Your mac Now used command-line tools was from Xcode. And, that "InstalledDir: /Library/Developer/CommandLineTools/usr/bin" shows
where Now your Mac using command-line tools(Clang compiler) was in
or where Now your Mac using Clang compiler was in.
Last Last Last,
Your macOS High Sierra version 10.13.3 could install Xcode version up to Xcode 10.1, and Clang version up to Clang 10.0.0. As your "clang --version" shows, you are not using the embedded Xcode command-line tools(Clang). Now You are using the separated (command-line tools)/Clang, enter Your InstalledDir show directory "/Library/Developer/CommandLineTools/usr/bin" to checkout Now Your Mac using version. Just using this command to checkout what the version of Clang you are using:
cd /Library/Developer/CommandLineTools/usr/lib/clang/ && ls
（Infer from the command-line tools downloadable on your computer's current system 10.13.3）
Take my macOS 10.12 for example, my Xcode could up to Xcode9.2, and Clang could up to Clang9.0.0, Because I have installed separated command-line tools with Clang 9.0.0, My VSCode C/C++ compiler just use Clang9.0.0 via the separated command-line tools,
My Xcode C/C++ compiler just uses Clang8.1.0 via the embedded Xcode command-line tools.
I am trying to figure what the differences between "--version" output are when I check the versions of gcc/g++ and clang/clang++, which I understand should just be links to each other. Furthermore, it is unclear to me whether there is some way to update what I have given that I am locked on Mac OSX 10.9 right now. There is a bit too much to fit into the question, but in short, I am trying to prepare for playing with SDL. It's best that I post the console output and comment as I go along. I think that I have a few misunderstandings to sort; I did look at similar pages on stack overflow, but none of the discussions quite answer my questions
$ gcc --version
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
Apple LLVM version 6.0 (clang-600.0.57) (based on LLVM 3.5svn)
okay, so this is a rather old version,
is there a safe way to update everything, or am I system locked?
I remember installing command line tools and the latest version of Xcode, 6.2, available on my system
Target: x86_64-apple-darwin13.4.0
Thread model: posix
$ g++ --version
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
4.2.1? I have Xcode 6.2 installed. Am I meant to rebuild something?
Apple LLVM version 6.0 (clang-600.0.57) (based on LLVM 3.5svn)
Target: x86_64-apple-darwin13.4.0
Thread model: posix
$ clang --version
Apple LLVM version 6.0 (clang-600.0.57) (based on LLVM 3.5svn)
Target: x86_64-apple-darwin13.4.0
Thread model: posix
$ clang++ --version
Apple LLVM version 6.0 (clang-600.0.57) (based on LLVM 3.5svn)
Target: x86_64-apple-darwin13.4.0
Thread model: posix
The clang printouts tell me nothing about the Xcode version, so I am not sure whether there is a difference here.
In short, am I meant to update or install something so I have a more recent set of compilers, or am I set? What is the real difference between the gcc/g++ and clang/clang++ information above? Lastly, can I update at all, and if so, in what way, and can I do so without any negative consequences?
Apologies in advance if the question is a bit too general/cloudy. I simply wish to make sure that I have a proper understanding of these messages and know how to proceed.
Thank you.
On a modern Mac system, gcc is an alias for clang, and g++ is an alias for clang++.
They're also components of Xcode (or the Xcode command-line tools, if you installed those). The installed version of clang is dependent on (but not the same as) the version of Xcode you have installed.
The "4.2.1" you're looking at is the version of the C++ headers. It will only confuse you. Ignore it.
If you want a newer version of the compiler, you will need to install a newer version of Xcode, and to do that, you will need to install a newer version of macOS.
I installed gcc version 4.9 with homebrew in my mac. But when I check the gcc version in terminal it is showing still the old one.
Aarons-MacBook-Air:bin Aaron$ gcc -v
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
Apple LLVM version 6.0 (clang-600.0.56) (based on LLVM 3.5svn)
Target: x86_64-apple-darwin14.1.0
Thread model: posix
Please help
homebrew installs gcc with version specific suffixes, so when you install gcc49, it gets called gcc-4.9 on the command line. This is intended to prevent interference with the gcc stub (which is actually clang) which is provided by the OSX command line development toolchain, as well as to allow you to install gcc-4.8, gcc-4.7, etc. alongside each other.
Generally defining the environment variables CC=gcc-4.9 and CXX=g++-4.9 should allow you to compile autoconf based packages, as well as standard makefile based projects using the gcc-4.9 compiler, rather than using the default cc/gcc.
I'm trying to build a project which is originally written for archlinux. The building process works fine on that archlinux but has a huge amount of errors when I tried to build it on my mac. The project is basically written in C++11 so it's very unstable. I think there has something to do with the compiler because the clang version in mac is 4.2(It actually shows 'Apple LLVM version 4.2 (clang-425.0.28) (based on LLVM 3.2svn)' when I type clang --version) and 3.3 for linux. So I want a different version of clang, perhaps 3.3. How Can I specify the version of my compiler when trying to build the project?
Some might argue this belongs on apple.stackexchange.com, but I'm not sure C++11 tags grab a lot of attention there:)
Xcode 5.0 is now available from the App Store. Install it, go to Preferences -> Downloads, and install the Command Line Tools. However...
First, you will need to go to Preferences -> Accounts and add your Apple ID. For some reason, the Command Line Tools download requires an account login. I don't know what the rationale for this is.
> clang -v
Apple LLVM version 5.0 (clang-500.2.75) (based on LLVM 3.3svn)
If you are willing to build from the command line, using make for example (which sounds likely given the project is from Linux), then install Macports and install whatever version of clang you would like:
$sudo port install clang-3.1
$sudo clang_select
Note that this version of clang shouldn't interfere with the Xcode Command Line package if you are will to invoke the Xcode version using xcrun clang instead of plain old clang.