23 ms·

Compiler Explorer

541 points by disadvantage 4y ago

mik09 4y ago
wow i first saw this on a small alternative reddit site. great to see it here and being this popular!
caramelcream 4y ago
Compiler Explorer is such a wonderful tool. It made examining and comparing compiler outputs so much easier and now pretty much everyone interested in optimizations is using it.
choeger 4y ago
When I was still programming in C++ that tool was the method to discuss compiler internals and language semantics with colleagues. Just setup a minimal example and share it with your colleagues. Impressive and sad at the same time. Impressive for obvious reasons. Sad, because the language is so confabulated that there is no easy concise way to talk about its semantics.
- curiousgal 4y ago
  Do you all not need to understand assembly to advance the discussion?
  - dtgriscom 4y ago
    ... having trouble parsing this...
  - School-Cotton 4y ago
    Assembly is not that hard to learn to read.
  - einpoklum 4y ago
    No, because: 1. You can figure out things about the assembly even without understanding assembly (e.g. lines of source translating into 0 lines of output vs many lines of output). 2. You have labels. 3. You can figure out some of the assembly on your own. Say: `mov %r1 %r2` - it probably moves what's in entity %r1 into a similar entity %r2, or vice-versa. etc. 4. You can see what the executable outputs 5. and most importantly: You can read compiler warnings and errors...
    - whateveracct 4y ago
      You can also RTFM and simply .. learn assembly.
  - jfoutz 4y ago
    yes but there's real value in exploration. I haven't touched c or assembly for a long time. here's a cold read. push rbp this is going to take the contents of rbp and push it onto the top of the stack - this will probably also change the stack pointer mov rbp, rsp move goes left <-, like a = 5, not 5 = a. so, copy the updated stack pointer into rbp mov DWORD PTR [rbp-4], edi now, I'm not 100% sure, but I believe this guy puts edi just under the value we pushed to the top of the stack mov eax, DWORD PTR [rbp-4] Take that value, and put it into eax, I'm not 100% sure why it's not just mov eax edi. imul eax, eax integer multiply, this is the part that does the double. pop rbp restore rbp (which we messed with) ret and we're done. there are at least three holes in my understanding - but those three are not _that_ hard to track down. 1, does the stack pointer actually auto increment? (I think it does) 2, imul overflow and setting sign flags and such. - that shouldn't be hard to run down. 3, what is the c calling convention? it looks like the argument is top of stack, but also in edi - is that shuffling really needed? I think there's a bucket of implicit behavior there that's kinda scary. I would _hope_ unless linking to a library, whatever called this, just did the imul eax eax. My understanding may be deeply flawed, but explaining my assumptions and my understanding does two things. 1, it helps me learn. 2, it helps others re-evaluate their assumptions and possibly see from a different viewpoint. I'm not saying spam compiler lists. But a clear and well thought out question can certainly advance discussion. It forces people to formalize their assumptions.
    - School-Cotton 4y ago
      The default godbolt page runs the compiler with no flags, which means without any optimizations. This explains why the code unnecessarily shuffles stuff to the stack and back. Unoptimized clang/llvm output spills everything to the stack, and register allocation is an optimization. With -O3, the code is: imul edi, edi mov eax, edi ret Yep, the calling convention for x86-64 on Linux and macOS passes the first six integer arguments in rdi, rsi, rdx, rcx, r8, and r9, and then spills to stack.
      - Sharlin 4y ago
        And Win64 in rcx, rdx, r8, and r9. Having originally learned the basics of assembly on the chronically register-deprived x86, it took me a while to get used to the fact that standard CCs now pass things in registers (and rsi and rdi in particular, retaining their ancient names while being completely general-purpose these days).
- throwawy6969 4y ago
  I think it has a few other languages supported now too. And/or there's equivalents for other languages. I think most of the confabulation of C++ is necessary to get the semantics needed for it to work right. Especially with all of the optimizations that compilers are expected to make. I found the reasoning behind switching from just rvalues/lvalues to the 5+ types they have now to be fascinating, for example.
- jeffbee 4y ago
  I also use it for this purpose, however I have come to hate the way other people use it for this. I have a colleague who has really no idea what he's talking about with respect to machine performance, and who did not have the requisite knowledge of how to peep at the assembly code of a given function with the standard tools like objdump, who now loves to send everyone godbolt links in slack, along with his suppositions about which function will be faster, based entirely on vibes (mostly, instruction count). This drives me up the wall. I wish there was some minimum height needed to ride godbolt.
  - mwcampbell 4y ago
    It's hard to measure performance in realistic situations; it's easy to measure code size. I recently found myself wasting time doing micro-optimizations, encouraged by the feedback loop of measuring and reducing code size (in my case, not with Compiler Explorer, but with "cargo bloat", since I was working on a Rust project.)
    - sitkack 4y ago
      I know you know this but instructions are basically free in the face of memory access and random memory access is the worst. Linear scans over contiguous memory (per thread) generally optimizes performance. Instruction counts are only useful if everything is guaranteed to be in registers.
      - slavik81 4y ago
        It can be tough even without the impact of the memory hierarchy. I've seen code where adding an extra instruction to the calculation made it faster. The extra instruction implicitly eliminated denormals, thus resulting in faster execution with some workloads on systems where operations on denormal values were slower than operations on other values. It was a completely unnecessary instruction from a correctness perspective, because it had no effect on the answer. However, it was important for performance; removing the instruction made the calculation slower.
- nice_byte 4y ago
  I cannot imagine writing performance-critical software in _any_ language without a tool like this.
  - pjmlp 4y ago
    Most compiled languages have offered switches to generate Assembly. Even on JVM and .NET there are ways to dump it, while on the various JVM implementations it requires a plugin if not using a debug build, on the .NET side, you can use show Assembly on Visual Studio, or make use of WinDBG with SOS plugin.
5e92cb50239222b 4y ago
A decent interview with the creator in podcast form. https://cppcast.com/matt-godbolt-compiler-explorer/ https://cppcast.com/matt-godbolt-compiler-explorer/
- c-cube 4y ago
  There's also 2's complement, a podcast by the author and a friend of his. It's pretty nice. https://www.twoscomplement.org/ https://www.twoscomplement.org/
dorongrinstein 4y ago
Thank you Matt Godbolt for creating such a wonderful tool. You're as cool as they get!
- skybrian 4y ago
  I didn’t realize until today that Godbolt was someone’s name. I had thought it was a whimsically named compiler tool. :)
  - ainar-g 4y ago
    I've only found out recently, thanks to the C++ Iceberg. https://fouronnes.github.io/cppiceberg/ https://fouronnes.github.io/cppiceberg/ (Entries are clickable.)
  - therein 4y ago
    I hadn't realized it until I started working with him back in the day and saw his name on Slack. Wrote him a message and told him how much we appreciated his work at my previous workplace and how we used it all the time to settle debates about C++ code. Wonderful guy, back then he was very pleasantly surprised that people actually used his website.
  - mattgodbolt 4y ago
    It still surprises me too! I need to change my name to Matt Compiler-Explorer :D
    - sam_bristow 4y ago
      It's the old Frankenstein's Monster problem. Much like you could argue that Dr Frankenstein was the real monster in that story, I'd say Matt Goldbot was the real Compiler Explorer all along.
  - a_e_k 4y ago
    If you want whimsical names though, someone set up a Decompiler Explorer at dogbolt.org. Discussed 3mo ago on HN: https://news.ycombinator.com/item?id=32079227 https://news.ycombinator.com/item?id=32079227
ChrisMarshallNY 4y ago
I've used Godbolt for years. The story that I heard, was that he was arguing with someone about some compiler optimization, and created the site to prove a point.
- tialaramex 4y ago
  There's a CPPCon talk - which I'm sure somebody else can remember and link - where Matt explains how this started. IIRC He was initially wondering whether C++ iterators are actually the same price as the C-style for loops you'd once have used instead with an index counting up or a pointer increasing. If it was slower then in Matt's industry that's useless, but if it's the same speed then the improved clarity of what you mean is valuable. Obviously the results will be identical but because the iterators look fancy (and are easier to think about) maybe there's some object getting constructed, it might be a lot heavier - right? Nope, same machine code. Matt initially did this much more manually, the Godbolt web site is just that same idea getting further enriched over time. This is even more striking for something like Rust's iterators that don't look at all like it's just the C-style for loop, there's a call to make the iterator IntoIterator::into_iter() and then repeated calls to its next() method, sounds expensive - but nope, once again the optimiser can see what's going on here and emit the same machine code. Having a tool like Godbolt to confirm (or sometimes refute) the belief that these things are actually the same is really useful, as even after confirming that optimisation is needed if the proposed "optimisation" doesn't change the machine code it wasn't an optimisation, just making the program needlessly harder to understand.
  - Simran-B 4y ago
    It's the CppCon 2017 talk with the title "What has my compiler done for me lately? Unbolting the compiler's lid". The Compiler Explorer backstory starts here: https://youtu.be/bSkpMdDe4g4?t=4m57s https://youtu.be/bSkpMdDe4g4?t=4m57s
  - JadeNB 4y ago
    > This is even more striking for something like Rust's iterators that don't look at all like it's just the C-style for loop, there's a call to make the iterator IntoIterator::into_iter() and then repeated calls to its next() method, sounds expensive - but nope, once again the optimiser can see what's going on here and emit the same machine code. > Having a tool like Godbolt to confirm (or sometimes refute) the belief that these things are actually the same is really useful, as even after confirming that optimisation is needed if the proposed "optimisation" doesn't change the machine code it wasn't an optimisation, just making the program needlessly harder to understand. I'm not sure I understand this. Wouldn't you expect higher-order code to be easier to optimise, since it comes closer to telling the compiler what you want to do, so that the compiler can figure it out, rather than forcing the compiler to divine the big-picture intention of a bunch of low-level instructions? And, if high-level code generates exactly the same machine code as low-level code, isn't that an argument in favour of high-level code—it lets you code declaratively, saying what you mean—rather than against high-level code? An optimisation might be optimising for intelligibility, not just run-time … and, while an experienced low-level C programmer might find the low-level code more readable, surely the non-expert maintenance programmer who comes afterwards will be grateful not to have to recognise the low-level patterns but rather have them spelled out in high-level code?
b3morales 4y ago
A small tip when visiting godbolt: you can use the name of the language you're interested in as a subdomain, to get a page immediately set up for that language, rather than starting with the default C++. For example https://erlang.godbolt.org https://erlang.godbolt.org or https://rust.godbolt.org https://rust.godbolt.org
- charcircuit 4y ago
  https://clang.godbolt.org https://clang.godbolt.org resolves but doesn't seem to do anything.
  - kupopuffs 4y ago
    Now, is clang a language? Hmm
    - saagarjha 4y ago
      It has “lang” in its name!
    - deleted 4y ago
      [deleted]
    - account42 4y ago
      Considering it (like all C/C++ Compilers) provides extensions to the languages it implements, yes?
  - mattgodbolt 4y ago
    It only works for languages, not compilers. _almost_ everything *.godbolt.org resolves to Compiler Explorer (I have some other projects at this domain), but *.compiler-explorer.com and *.godbo.lt always point at CE.
    - mattgodbolt 4y ago
      That said; it should resolve and still point at Compiler Explorer. If you're not getting that, ping me on email/twitter/discord and we can debug!
xfgusta 4y ago
I'd like to share a command-line tool to interact with Compiler Explorer that I made: https://github.com/xfgusta/cexpl https://github.com/xfgusta/cexpl. It's written in Python and it's available on PyPI.
dang 4y ago
Related: Compiler Explorer - https://news.ycombinator.com/item?id=24066570 https://news.ycombinator.com/item?id=24066570 - Aug 2020 (48 comments) Compiler Explorer - https://news.ycombinator.com/item?id=18671993 https://news.ycombinator.com/item?id=18671993 - Dec 2018 (44 comments) RMSbolt – An implementation of the Godbolt compiler-explorer for Emacs - https://news.ycombinator.com/item?id=18104167 https://news.ycombinator.com/item?id=18104167 - Sept 2018 (9 comments) Compiler bug in MSVC? - https://news.ycombinator.com/item?id=16142512 https://news.ycombinator.com/item?id=16142512 - Jan 2018 (2 comments) C compiler undefined behavior: calls never-called function - https://news.ycombinator.com/item?id=15147335 https://news.ycombinator.com/item?id=15147335 - Sept 2017 (83 comments) GodBolt: Enter C, get Assembly - https://news.ycombinator.com/item?id=13182726 https://news.ycombinator.com/item?id=13182726 - Dec 2016 (151 comments) Compiler Explorer – now with side-by-side compiler comparison - https://news.ycombinator.com/item?id=12627295 https://news.ycombinator.com/item?id=12627295 - Oct 2016 (6 comments) Compiler Explorer - https://news.ycombinator.com/item?id=11671730 https://news.ycombinator.com/item?id=11671730 - May 2016 (38 comments) Interactive C++ Assembly Explorer - https://news.ycombinator.com/item?id=9861294 https://news.ycombinator.com/item?id=9861294 - July 2015 (8 comments) See What Your C Function Compiles To - https://news.ycombinator.com/item?id=9808870 https://news.ycombinator.com/item?id=9808870 - June 2015 (2 comments) C/C++ Fiddle - https://news.ycombinator.com/item?id=7593109 https://news.ycombinator.com/item?id=7593109 - April 2014 (40 comments) Interactively watch how your C++ gets compiled. - https://news.ycombinator.com/item?id=4020814 https://news.ycombinator.com/item?id=4020814 - May 2012 (1 comment)
- mattgodbolt 4y ago
  Right...we turn up here every few months. Always grateful for the PR, of course :)
  - kolbe 4y ago
    Do you earn anything from this site? Even if you do, I can't imagine it's much relative to an Optiver salary. Why do you do it?
    - 4y ago
justshowpost 4y ago
Its better than the others but also very unprofessional as the other web stuff. It DOES link but its absolutely impossible to view generated map. People are just hyping about codegen related microoptimizations but don't care about layout at all. Very typical for today's world where javascript coder counts as software engineer.
- timmy777 4y ago
  After the rant, the very least you could do is to educate us about the tool that allows us view codegen and "layout". >>> Very typical for today's world where javascript coder counts as software engineer. Oh, hello software engineer from yesterday's world.
  - justshowpost 4y ago
    Well polite people at least say "please". Otherwise you just go buy more SDRAM and ALU chips and be computer scientist. Curious thing is, you yourself dropped into gcc studying tool discussion clearly having no idea what I was criticizing in it.
TobyTheDog123 4y ago
First ran across this when looking into Carbon - it's a very cool tool!
prasadi 4y ago
slavik81 4y ago
I've used Compiler Explorer for many years as a C++ developer. When I started working in HIP, I really missed having Compiler Explorer in my toolbox. I've been on leave for the past couple months and I took the opportunity to make some contributions outside my normal work. Consequentially, full support for compiling HIP to AMDGPU assembly was merged last week. Here's an example: https://godbolt.org/z/qjsErWzcs https://godbolt.org/z/qjsErWzcs
- mattgodbolt 4y ago
  For which we thank you very much for your help!!
mattgodbolt 4y ago
Wow - we're on Hacker News again! Hello all, and thanks for the link and discussion! While we're here, we recently made some stats public: https://stats.compiler-explorer.com/ https://stats.compiler-explorer.com/ (spot the Hacker News spike!) General stuff: we're always looking for help; everything's open source on GH: https://github.com/compiler-explorer/ https://github.com/compiler-explorer/ (the base project, our cloud setup, all our build scripts, etc). The most valuable way to help us is with issues and PRs, or hang out on our Discord (https://discord.gg/zNNgyRKh https://discord.gg/zNNgyRKh). Then spread the word, and last we welcome sponsors on GH (https://github.com/sponsors/mattgodbolt https://github.com/sponsors/mattgodbolt) or Patreon (https://www.patreon.com/mattgodbolt https://www.patreon.com/mattgodbolt).
- chrisaycock 4y ago
  And for those who haven't read it yet, here's Matt's own article in ACM Queue: https://queue.acm.org/detail.cfm?id=3372264 https://queue.acm.org/detail.cfm?id=3372264
  - tomcam 4y ago
    Surprisingly accessible description of common optimizations; a useful survey for beginning compiler writers.
  - pencilguin 4y ago
    He has a Patreon acct. For a few bucks, he will send you authentic Godbolt stickers for your laptop lids, for the ultimate in geek cred.
- the_only_law 4y ago
  Thank you for making one of the coolest tools I found in the web in years.
  - mattgodbolt 4y ago
    Thank you for the kind words :)
sylware 4y ago
WOW! There is a noscript/ basic (x)html version AND it does handle the _canonical_ gcc aka the last C compilable gcc (4.7.4). Many of the optimization tricks hidden deep into those massive and complex software will be yours now.
shortlived 4y ago
I just discovered goldbolt aka compiler explorer via this excellent podcast episode: https://corecursive.com/to-the-assembly/ https://corecursive.com/to-the-assembly/
usefulcat 4y ago
Awesome tool. I do mostly c++ all day and I use this almost daily, and certainly weekly. I think it’s really improved my feel for what the compiler will do with different constructs.
photochemsyn 4y ago
It's great that you can now get RISC-V output. IMO RISC-V is the most pleasant way to learn assembly-level programming. For anyone interested here's a nice resource: https://riscv-programming.org/book.html https://riscv-programming.org/book.html
- nevi-me 4y ago
  A bit unrelated, I've been learning ARM64 assembly out of the convenience of having an ARM machine. It's also been pleasant, I've been planning on learning RISC-V next. The only device I have access to though is the ESP32C3, so I don't know how far I'll go with it. Outside of decompiling some code on Godbolt, peeking into the assembly on VS Code, I've also been practising with Rust's inline assembly, quite pleasant.
  - jshier 4y ago
    Do you have a good tutorial or intro for ARM64 or Apple Silicon assembly? I'd like to learn but the books I have are all for MIPS, and the online resources are hit or miss.
    - pjmlp 4y ago
      There is this book for ARM 64, which is quite alright, https://link.springer.com/book/10.1007/978-1-4842-5881-1 https://link.springer.com/book/10.1007/978-1-4842-5881-1
RobotToaster 4y ago
It's interesting to see what the different levels of compiler optimisation produce.
elromulous 4y ago
Seriously asking, how is it even possible to submit this to hn at this point? When one submits a previously submitted link, doesn't it just alias to the previous submission?
- josephcsible 4y ago
  That only happens if the previous submission was recent enough.
motgilk 4y ago
It's an excellent tool. Would be nice if it showed you the full linker output too, of the final binary.
- mattgodbolt 4y ago
  If you click "show binary" that's pretty much what we do. Here's a link doing so, and also running `elfdump -a` on the linked output: https://godbolt.org/z/9EcxhedK4 https://godbolt.org/z/9EcxhedK4
seabass 4y ago
Is there a trick to make the typescript compiler run? All the other examples seem fine out of the box. No matter what I write, the ts compilation fails.
- mattgodbolt 4y ago
  Sounds like an issue - I've filed something to take a look: https://github.com/compiler-explorer/compiler-explorer/issues/4164 https://github.com/compiler-explorer/compiler-explorer/issue...
  - mattgodbolt 4y ago
    So! The typescript compiler doesn't leave us (currently) with any asm. We can only execute what it produces: https://godbolt.org/z/YvKe8ojvT https://godbolt.org/z/YvKe8ojvT for example. You can also use an "execute only" view instead of the default "show me the assembly": https://godbolt.org/z/cfvEvnK56 https://godbolt.org/z/cfvEvnK56 Hope that helps!
bombobombone1 4y ago
londont 4y ago
This is VERY cool. Congrats!
at_compile_time 4y ago
I was using CE earlier today to verify that rustc was optimizing the way I thought it would. It's a great service!
jawadch93 4y ago
[dead]
bori 4y ago
I'm looking at the C maxArray example and see that the for loop: for (i = 0; i < 65536; i++) gets compiled as .L2: add rax, 8 cmp rax, 524288 jne .L4 Is there any fundamental reason why the loop increments with 8 instead of 1? Or is this completely arbitrary? Thanks.
- kazinator 4y ago
  Because it's working with arrays of double which is 8 bytes wide, and the optimized loop doesn't use any scaled indexing; basically the loop index is pre-scaled to the element size. Perhaps those MMX instructions don't support addressing modes with index scaling (wild guess). The unoptimized code increments by 1 to 65535, but the memory accesses use scaling. Well, not exactly. We see this: lea rdx, [0+rax*8] mov rax, QWORD PTR [rsp-120] add rax, rdx movsd xmm0, QWORD PTR [rax] This LEA here, though it means "load effective address" is not actually an effective address calculation. The base address is zero, and so this is just LEA being exploited to multiply RAX by 8, and get that into RDX. RAX is then clobbered with the base address of an array, to which the scaled displacement is added and then finally used to make an access.
ufo 4y ago
I recently learned that it's not too difficult to run Compiler Explorer locally on your machine. Clone it from github and run the appropriate makefile and npm commands. Recently I've been using it Compiler Explorer a lot like this. It's easier to use your own header files and it's nice to not have the extra latency of compiling remotely or worry that you're using so many of their CPU cycles. The main downside is that if you run locally you can only test on the version of gcc and clang that you have installed, while on the website you can test other versions and also other CPU architectures.
whatsakandr 4y ago
The addition of cppfront during Herb's the talk was legendary.

541 points by disadvantage 4y ago

wow i first saw this on a small alternative reddit site. great to see it here and being this popular!

Compiler Explorer is such a wonderful tool. It made examining and comparing compiler outputs so much easier and now pretty much everyone interested in optimizations is using it.

choeger 4y ago

When I was still programming in C++ that tool was the method to discuss compiler internals and language semantics with colleagues. Just setup a minimal example and share it with your colleagues. Impressive and sad at the same time. Impressive for obvious reasons. Sad, because the language is so confabulated that there is no easy concise way to talk about its semantics.

curiousgal 4y ago
Do you all not need to understand assembly to advance the discussion?
- dtgriscom 4y ago
  ... having trouble parsing this...
- School-Cotton 4y ago
  Assembly is not that hard to learn to read.
- einpoklum 4y ago
  No, because: 1. You can figure out things about the assembly even without understanding assembly (e.g. lines of source translating into 0 lines of output vs many lines of output). 2. You have labels. 3. You can figure out some of the assembly on your own. Say: `mov %r1 %r2` - it probably moves what's in entity %r1 into a similar entity %r2, or vice-versa. etc. 4. You can see what the executable outputs 5. and most importantly: You can read compiler warnings and errors...
  - whateveracct 4y ago
    You can also RTFM and simply .. learn assembly.
- jfoutz 4y ago
  yes but there's real value in exploration. I haven't touched c or assembly for a long time. here's a cold read. push rbp this is going to take the contents of rbp and push it onto the top of the stack - this will probably also change the stack pointer mov rbp, rsp move goes left <-, like a = 5, not 5 = a. so, copy the updated stack pointer into rbp mov DWORD PTR [rbp-4], edi now, I'm not 100% sure, but I believe this guy puts edi just under the value we pushed to the top of the stack mov eax, DWORD PTR [rbp-4] Take that value, and put it into eax, I'm not 100% sure why it's not just mov eax edi. imul eax, eax integer multiply, this is the part that does the double. pop rbp restore rbp (which we messed with) ret and we're done. there are at least three holes in my understanding - but those three are not _that_ hard to track down. 1, does the stack pointer actually auto increment? (I think it does) 2, imul overflow and setting sign flags and such. - that shouldn't be hard to run down. 3, what is the c calling convention? it looks like the argument is top of stack, but also in edi - is that shuffling really needed? I think there's a bucket of implicit behavior there that's kinda scary. I would _hope_ unless linking to a library, whatever called this, just did the imul eax eax. My understanding may be deeply flawed, but explaining my assumptions and my understanding does two things. 1, it helps me learn. 2, it helps others re-evaluate their assumptions and possibly see from a different viewpoint. I'm not saying spam compiler lists. But a clear and well thought out question can certainly advance discussion. It forces people to formalize their assumptions.
  - School-Cotton 4y ago
    The default godbolt page runs the compiler with no flags, which means without any optimizations. This explains why the code unnecessarily shuffles stuff to the stack and back. Unoptimized clang/llvm output spills everything to the stack, and register allocation is an optimization. With -O3, the code is: imul edi, edi mov eax, edi ret Yep, the calling convention for x86-64 on Linux and macOS passes the first six integer arguments in rdi, rsi, rdx, rcx, r8, and r9, and then spills to stack.
    - Sharlin 4y ago
      And Win64 in rcx, rdx, r8, and r9. Having originally learned the basics of assembly on the chronically register-deprived x86, it took me a while to get used to the fact that standard CCs now pass things in registers (and rsi and rdi in particular, retaining their ancient names while being completely general-purpose these days).
throwawy6969 4y ago
I think it has a few other languages supported now too. And/or there's equivalents for other languages. I think most of the confabulation of C++ is necessary to get the semantics needed for it to work right. Especially with all of the optimizations that compilers are expected to make. I found the reasoning behind switching from just rvalues/lvalues to the 5+ types they have now to be fascinating, for example.
jeffbee 4y ago
I also use it for this purpose, however I have come to hate the way other people use it for this. I have a colleague who has really no idea what he's talking about with respect to machine performance, and who did not have the requisite knowledge of how to peep at the assembly code of a given function with the standard tools like objdump, who now loves to send everyone godbolt links in slack, along with his suppositions about which function will be faster, based entirely on vibes (mostly, instruction count). This drives me up the wall. I wish there was some minimum height needed to ride godbolt.
- mwcampbell 4y ago
  It's hard to measure performance in realistic situations; it's easy to measure code size. I recently found myself wasting time doing micro-optimizations, encouraged by the feedback loop of measuring and reducing code size (in my case, not with Compiler Explorer, but with "cargo bloat", since I was working on a Rust project.)
  - sitkack 4y ago
    I know you know this but instructions are basically free in the face of memory access and random memory access is the worst. Linear scans over contiguous memory (per thread) generally optimizes performance. Instruction counts are only useful if everything is guaranteed to be in registers.
    - slavik81 4y ago
      It can be tough even without the impact of the memory hierarchy. I've seen code where adding an extra instruction to the calculation made it faster. The extra instruction implicitly eliminated denormals, thus resulting in faster execution with some workloads on systems where operations on denormal values were slower than operations on other values. It was a completely unnecessary instruction from a correctness perspective, because it had no effect on the answer. However, it was important for performance; removing the instruction made the calculation slower.
nice_byte 4y ago
I cannot imagine writing performance-critical software in _any_ language without a tool like this.
- pjmlp 4y ago
  Most compiled languages have offered switches to generate Assembly. Even on JVM and .NET there are ways to dump it, while on the various JVM implementations it requires a plugin if not using a debug build, on the .NET side, you can use show Assembly on Visual Studio, or make use of WinDBG with SOS plugin.

5e92cb50239222b 4y ago

A decent interview with the creator in podcast form. https://cppcast.com/matt-godbolt-compiler-explorer/ https://cppcast.com/matt-godbolt-compiler-explorer/

c-cube 4y ago
There's also 2's complement, a podcast by the author and a friend of his. It's pretty nice. https://www.twoscomplement.org/ https://www.twoscomplement.org/

dorongrinstein 4y ago

Thank you Matt Godbolt for creating such a wonderful tool. You're as cool as they get!

skybrian 4y ago
I didn’t realize until today that Godbolt was someone’s name. I had thought it was a whimsically named compiler tool. :)
- ainar-g 4y ago
  I've only found out recently, thanks to the C++ Iceberg. https://fouronnes.github.io/cppiceberg/ https://fouronnes.github.io/cppiceberg/ (Entries are clickable.)
- therein 4y ago
  I hadn't realized it until I started working with him back in the day and saw his name on Slack. Wrote him a message and told him how much we appreciated his work at my previous workplace and how we used it all the time to settle debates about C++ code. Wonderful guy, back then he was very pleasantly surprised that people actually used his website.
- mattgodbolt 4y ago
  It still surprises me too! I need to change my name to Matt Compiler-Explorer :D
  - sam_bristow 4y ago
    It's the old Frankenstein's Monster problem. Much like you could argue that Dr Frankenstein was the real monster in that story, I'd say Matt Goldbot was the real Compiler Explorer all along.
- a_e_k 4y ago
  If you want whimsical names though, someone set up a Decompiler Explorer at dogbolt.org. Discussed 3mo ago on HN: https://news.ycombinator.com/item?id=32079227 https://news.ycombinator.com/item?id=32079227

ChrisMarshallNY 4y ago

I've used Godbolt for years. The story that I heard, was that he was arguing with someone about some compiler optimization, and created the site to prove a point.

tialaramex 4y ago
There's a CPPCon talk - which I'm sure somebody else can remember and link - where Matt explains how this started. IIRC He was initially wondering whether C++ iterators are actually the same price as the C-style for loops you'd once have used instead with an index counting up or a pointer increasing. If it was slower then in Matt's industry that's useless, but if it's the same speed then the improved clarity of what you mean is valuable. Obviously the results will be identical but because the iterators look fancy (and are easier to think about) maybe there's some object getting constructed, it might be a lot heavier - right? Nope, same machine code. Matt initially did this much more manually, the Godbolt web site is just that same idea getting further enriched over time. This is even more striking for something like Rust's iterators that don't look at all like it's just the C-style for loop, there's a call to make the iterator IntoIterator::into_iter() and then repeated calls to its next() method, sounds expensive - but nope, once again the optimiser can see what's going on here and emit the same machine code. Having a tool like Godbolt to confirm (or sometimes refute) the belief that these things are actually the same is really useful, as even after confirming that optimisation is needed if the proposed "optimisation" doesn't change the machine code it wasn't an optimisation, just making the program needlessly harder to understand.
- Simran-B 4y ago
  It's the CppCon 2017 talk with the title "What has my compiler done for me lately? Unbolting the compiler's lid". The Compiler Explorer backstory starts here: https://youtu.be/bSkpMdDe4g4?t=4m57s https://youtu.be/bSkpMdDe4g4?t=4m57s
- JadeNB 4y ago
  > This is even more striking for something like Rust's iterators that don't look at all like it's just the C-style for loop, there's a call to make the iterator IntoIterator::into_iter() and then repeated calls to its next() method, sounds expensive - but nope, once again the optimiser can see what's going on here and emit the same machine code. > Having a tool like Godbolt to confirm (or sometimes refute) the belief that these things are actually the same is really useful, as even after confirming that optimisation is needed if the proposed "optimisation" doesn't change the machine code it wasn't an optimisation, just making the program needlessly harder to understand. I'm not sure I understand this. Wouldn't you expect higher-order code to be easier to optimise, since it comes closer to telling the compiler what you want to do, so that the compiler can figure it out, rather than forcing the compiler to divine the big-picture intention of a bunch of low-level instructions? And, if high-level code generates exactly the same machine code as low-level code, isn't that an argument in favour of high-level code—it lets you code declaratively, saying what you mean—rather than against high-level code? An optimisation might be optimising for intelligibility, not just run-time … and, while an experienced low-level C programmer might find the low-level code more readable, surely the non-expert maintenance programmer who comes afterwards will be grateful not to have to recognise the low-level patterns but rather have them spelled out in high-level code?

b3morales 4y ago

A small tip when visiting godbolt: you can use the name of the language you're interested in as a subdomain, to get a page immediately set up for that language, rather than starting with the default C++. For example https://erlang.godbolt.org https://erlang.godbolt.org or https://rust.godbolt.org https://rust.godbolt.org

charcircuit 4y ago
https://clang.godbolt.org https://clang.godbolt.org resolves but doesn't seem to do anything.
- kupopuffs 4y ago
  Now, is clang a language? Hmm
  - saagarjha 4y ago
    It has “lang” in its name!
  - deleted 4y ago
    [deleted]
  - account42 4y ago
    Considering it (like all C/C++ Compilers) provides extensions to the languages it implements, yes?
- mattgodbolt 4y ago
  It only works for languages, not compilers. _almost_ everything *.godbolt.org resolves to Compiler Explorer (I have some other projects at this domain), but *.compiler-explorer.com and *.godbo.lt always point at CE.
  - mattgodbolt 4y ago
    That said; it should resolve and still point at Compiler Explorer. If you're not getting that, ping me on email/twitter/discord and we can debug!

xfgusta 4y ago

I'd like to share a command-line tool to interact with Compiler Explorer that I made: https://github.com/xfgusta/cexpl https://github.com/xfgusta/cexpl. It's written in Python and it's available on PyPI.

dang 4y ago

Related: Compiler Explorer - https://news.ycombinator.com/item?id=24066570 https://news.ycombinator.com/item?id=24066570 - Aug 2020 (48 comments) Compiler Explorer - https://news.ycombinator.com/item?id=18671993 https://news.ycombinator.com/item?id=18671993 - Dec 2018 (44 comments) RMSbolt – An implementation of the Godbolt compiler-explorer for Emacs - https://news.ycombinator.com/item?id=18104167 https://news.ycombinator.com/item?id=18104167 - Sept 2018 (9 comments) Compiler bug in MSVC? - https://news.ycombinator.com/item?id=16142512 https://news.ycombinator.com/item?id=16142512 - Jan 2018 (2 comments) C compiler undefined behavior: calls never-called function - https://news.ycombinator.com/item?id=15147335 https://news.ycombinator.com/item?id=15147335 - Sept 2017 (83 comments) GodBolt: Enter C, get Assembly - https://news.ycombinator.com/item?id=13182726 https://news.ycombinator.com/item?id=13182726 - Dec 2016 (151 comments) Compiler Explorer – now with side-by-side compiler comparison - https://news.ycombinator.com/item?id=12627295 https://news.ycombinator.com/item?id=12627295 - Oct 2016 (6 comments) Compiler Explorer - https://news.ycombinator.com/item?id=11671730 https://news.ycombinator.com/item?id=11671730 - May 2016 (38 comments) Interactive C++ Assembly Explorer - https://news.ycombinator.com/item?id=9861294 https://news.ycombinator.com/item?id=9861294 - July 2015 (8 comments) See What Your C Function Compiles To - https://news.ycombinator.com/item?id=9808870 https://news.ycombinator.com/item?id=9808870 - June 2015 (2 comments) C/C++ Fiddle - https://news.ycombinator.com/item?id=7593109 https://news.ycombinator.com/item?id=7593109 - April 2014 (40 comments) Interactively watch how your C++ gets compiled. - https://news.ycombinator.com/item?id=4020814 https://news.ycombinator.com/item?id=4020814 - May 2012 (1 comment)

mattgodbolt 4y ago
Right...we turn up here every few months. Always grateful for the PR, of course :)
- kolbe 4y ago
  Do you earn anything from this site? Even if you do, I can't imagine it's much relative to an Optiver salary. Why do you do it?
  - 4y ago

justshowpost 4y ago

Its better than the others but also very unprofessional as the other web stuff. It DOES link but its absolutely impossible to view generated map. People are just hyping about codegen related microoptimizations but don't care about layout at all. Very typical for today's world where javascript coder counts as software engineer.

timmy777 4y ago
After the rant, the very least you could do is to educate us about the tool that allows us view codegen and "layout". >>> Very typical for today's world where javascript coder counts as software engineer. Oh, hello software engineer from yesterday's world.
- justshowpost 4y ago
  Well polite people at least say "please". Otherwise you just go buy more SDRAM and ALU chips and be computer scientist. Curious thing is, you yourself dropped into gcc studying tool discussion clearly having no idea what I was criticizing in it.

TobyTheDog123 4y ago

First ran across this when looking into Carbon - it's a very cool tool!

prasadi 4y ago

slavik81 4y ago

I've used Compiler Explorer for many years as a C++ developer. When I started working in HIP, I really missed having Compiler Explorer in my toolbox. I've been on leave for the past couple months and I took the opportunity to make some contributions outside my normal work. Consequentially, full support for compiling HIP to AMDGPU assembly was merged last week. Here's an example: https://godbolt.org/z/qjsErWzcs https://godbolt.org/z/qjsErWzcs

mattgodbolt 4y ago
For which we thank you very much for your help!!

mattgodbolt 4y ago

Wow - we're on Hacker News again! Hello all, and thanks for the link and discussion! While we're here, we recently made some stats public: https://stats.compiler-explorer.com/ https://stats.compiler-explorer.com/ (spot the Hacker News spike!) General stuff: we're always looking for help; everything's open source on GH: https://github.com/compiler-explorer/ https://github.com/compiler-explorer/ (the base project, our cloud setup, all our build scripts, etc). The most valuable way to help us is with issues and PRs, or hang out on our Discord (https://discord.gg/zNNgyRKh https://discord.gg/zNNgyRKh). Then spread the word, and last we welcome sponsors on GH (https://github.com/sponsors/mattgodbolt https://github.com/sponsors/mattgodbolt) or Patreon (https://www.patreon.com/mattgodbolt https://www.patreon.com/mattgodbolt).

chrisaycock 4y ago
And for those who haven't read it yet, here's Matt's own article in ACM Queue: https://queue.acm.org/detail.cfm?id=3372264 https://queue.acm.org/detail.cfm?id=3372264
- tomcam 4y ago
  Surprisingly accessible description of common optimizations; a useful survey for beginning compiler writers.
- pencilguin 4y ago
  He has a Patreon acct. For a few bucks, he will send you authentic Godbolt stickers for your laptop lids, for the ultimate in geek cred.
the_only_law 4y ago
Thank you for making one of the coolest tools I found in the web in years.
- mattgodbolt 4y ago
  Thank you for the kind words :)

sylware 4y ago

WOW! There is a noscript/ basic (x)html version AND it does handle the _canonical_ gcc aka the last C compilable gcc (4.7.4). Many of the optimization tricks hidden deep into those massive and complex software will be yours now.

shortlived 4y ago

I just discovered goldbolt aka compiler explorer via this excellent podcast episode: https://corecursive.com/to-the-assembly/ https://corecursive.com/to-the-assembly/

usefulcat 4y ago

Awesome tool. I do mostly c++ all day and I use this almost daily, and certainly weekly. I think it’s really improved my feel for what the compiler will do with different constructs.

photochemsyn 4y ago

It's great that you can now get RISC-V output. IMO RISC-V is the most pleasant way to learn assembly-level programming. For anyone interested here's a nice resource: https://riscv-programming.org/book.html https://riscv-programming.org/book.html

nevi-me 4y ago
A bit unrelated, I've been learning ARM64 assembly out of the convenience of having an ARM machine. It's also been pleasant, I've been planning on learning RISC-V next. The only device I have access to though is the ESP32C3, so I don't know how far I'll go with it. Outside of decompiling some code on Godbolt, peeking into the assembly on VS Code, I've also been practising with Rust's inline assembly, quite pleasant.
- jshier 4y ago
  Do you have a good tutorial or intro for ARM64 or Apple Silicon assembly? I'd like to learn but the books I have are all for MIPS, and the online resources are hit or miss.
  - pjmlp 4y ago
    There is this book for ARM 64, which is quite alright, https://link.springer.com/book/10.1007/978-1-4842-5881-1 https://link.springer.com/book/10.1007/978-1-4842-5881-1

RobotToaster 4y ago

It's interesting to see what the different levels of compiler optimisation produce.

elromulous 4y ago

Seriously asking, how is it even possible to submit this to hn at this point? When one submits a previously submitted link, doesn't it just alias to the previous submission?

josephcsible 4y ago
That only happens if the previous submission was recent enough.

motgilk 4y ago

It's an excellent tool. Would be nice if it showed you the full linker output too, of the final binary.

mattgodbolt 4y ago
If you click "show binary" that's pretty much what we do. Here's a link doing so, and also running `elfdump -a` on the linked output: https://godbolt.org/z/9EcxhedK4 https://godbolt.org/z/9EcxhedK4

seabass 4y ago

Is there a trick to make the typescript compiler run? All the other examples seem fine out of the box. No matter what I write, the ts compilation fails.

mattgodbolt 4y ago
Sounds like an issue - I've filed something to take a look: https://github.com/compiler-explorer/compiler-explorer/issues/4164 https://github.com/compiler-explorer/compiler-explorer/issue...
- mattgodbolt 4y ago
  So! The typescript compiler doesn't leave us (currently) with any asm. We can only execute what it produces: https://godbolt.org/z/YvKe8ojvT https://godbolt.org/z/YvKe8ojvT for example. You can also use an "execute only" view instead of the default "show me the assembly": https://godbolt.org/z/cfvEvnK56 https://godbolt.org/z/cfvEvnK56 Hope that helps!

bombobombone1 4y ago

londont 4y ago

This is VERY cool. Congrats!

at_compile_time 4y ago

I was using CE earlier today to verify that rustc was optimizing the way I thought it would. It's a great service!

jawadch93 4y ago

[dead]

bori 4y ago

I'm looking at the C maxArray example and see that the for loop: for (i = 0; i < 65536; i++) gets compiled as .L2: add rax, 8 cmp rax, 524288 jne .L4 Is there any fundamental reason why the loop increments with 8 instead of 1? Or is this completely arbitrary? Thanks.

kazinator 4y ago
Because it's working with arrays of double which is 8 bytes wide, and the optimized loop doesn't use any scaled indexing; basically the loop index is pre-scaled to the element size. Perhaps those MMX instructions don't support addressing modes with index scaling (wild guess). The unoptimized code increments by 1 to 65535, but the memory accesses use scaling. Well, not exactly. We see this: lea rdx, [0+rax*8] mov rax, QWORD PTR [rsp-120] add rax, rdx movsd xmm0, QWORD PTR [rax] This LEA here, though it means "load effective address" is not actually an effective address calculation. The base address is zero, and so this is just LEA being exploited to multiply RAX by 8, and get that into RDX. RAX is then clobbered with the base address of an array, to which the scaled displacement is added and then finally used to make an access.

ufo 4y ago

I recently learned that it's not too difficult to run Compiler Explorer locally on your machine. Clone it from github and run the appropriate makefile and npm commands. Recently I've been using it Compiler Explorer a lot like this. It's easier to use your own header files and it's nice to not have the extra latency of compiling remotely or worry that you're using so many of their CPU cycles. The main downside is that if you run locally you can only test on the version of gcc and clang that you have installed, while on the website you can test other versions and also other CPU architectures.

whatsakandr 4y ago

The addition of cppfront during Herb's the talk was legendary.