8 ms·
SmallerC – Small, Simple, Self-Compiling, Single Pass C Compiler
- hbbio 9y agoFabrice Bellard (who also had some spare time to create ffmpeg, QEMU, and a few others like a software implementation of a 4G-LTE base station) wrote tcc, the tiny C compiler: https://bellard.org/tcc/ https://bellard.org/tcc/ Small, fast and of course self-compiling! The project is the better compiler out of a first project named OTCC which won the IOCCC (yes, the obfuscated C programming contest - less than 2k bytes). https://bellard.org/otcc/ https://bellard.org/otcc/
- pmoriarty 9y agoOne of the most amazing Javascript apps I've ever seen was also written by Bellard: jslinux https://bellard.org/jslinux/ https://bellard.org/jslinux/
- masklinn 9y agoAnd from it grew tccboot (https://bellard.org/tcc/tccboot.html https://bellard.org/tcc/tccboot.html), a boot loader which compiles the Linux kernel on the fly from source then runs it, the entire process taking only a few seconds ("15 seconds on a 2.4 GHz Pentium 4.")
- tbodt 9y agoAbout 3 seconds on my i5 from 2015.
- nabla9 9y agoHis newest is RV128IMAFDQC emulator https://bellard.org/riscvemu/ https://bellard.org/riscvemu/
- tombert 9y agoI had no idea that the dude who made QEMU also made ffmpeg. Those are two of my favorite apps...I should buy that guy a pizza.
- tbodt 9y agoyes he is an amazing guy, he should put a "buy me a pizza" link on his homepage
- emanreus 9y agoYeah, Fabrice is a monster.
- throwaway2016a 9y agoNice. This is a really ambitious project for just 4 contributors (and one that looks like they did most of the work). I'm curious why ASM and not LLVM? Edit (comment above unaltered): I got down voted by someone which tells me I missed an obvious answer to my question. Did I miss something? I've noticed a lot of compiler projects lately tend to default to LLVM, I'm curious of the strengths and weaknesses of LLVM vs ASM since the author here chose to compile to ASM.
- bitwalker 9y agoMy impression (as someone working on a compiler of my own, using LLVM), is that while you get a lot out of building on LLVM (portability across platforms, a collection of "free" optimizations, and a well defined low-level IR), it comes at the cost of a huge toolchain (takes about 5-10 minutes to compile from scratch on my laptop), and it is not stable across releases (the extent to which you are affected depends on the features your compiler depends on though). I think for toy projects it is probably more interesting to write the code gen yourself; and for projects focused on a specific platform, it is perhaps desirable to handle it yourself. Some people probably just don't want the dependency. My perspective is that I don't want to reinvent the work on cross platform support, or the optimization passes, and would rather take advantage of those efforts by depending on LLVM. I don't know that this makes sense for this project though.
- blt 9y agoLLVM is big, heavy, complicated, powerful. Kind of against the spirit of writing a lightweight C compiler. On the other hand, an x86 assembler can be easily implemented by one person and requires minimal cpu and memory resources.
- alexfru 9y agoYeah, a fifth name appears in the macos branch. :) Not sure if github will show the name when macos is merged into master. I wanted something small and easily self-hosting. A compiler on a floppy (as in old times). I hope you guys know what floppies are. :) smlrc.c runs in 96KB on a PIC32 MIPS microcontroller. LLVM is big and if I don't implement enough of the language (and I hear LLVM is s written in C++, not C), I can't recompile LLVM. I can write an assembler. Or I can use FASM, which is self-hosting, if I can't compile NASM or YASM.
- feelin_googley 9y agoThis was posted before, right? I like that they allow FASM. And that there is no "standard library".
- megous 9y agoThere is standard library.
- feelin_googley 9y agoYes, my mistake. I think this has been posted to HN before. I seem to remember trying it out.
- tomcam 9y agoFrom the Github page: > The standard C library is work-in-progress and it's close to completion.
- linopolus 9y ago> Currently it generates 16-bit and 32-bit 80386+ assembly code for NASM that can then be assembled and linked into DOS, Windows and Linux programs. I wonder why not 64Bit? Hardly anyone uses 32bit processors anymore, and even in the Windows world 64Bit systems are slowly taking over, so it would seem more logical to me to compile for modern processors, instead of 16bit architecture.
- colejohnson66 9y agoThe x86_64 instruction set is a lot more complicated than the x86 one.
- mikebenfield 9y agoWhat do you have in mind here? What x86 code generated by a C compiler is not readily translatable to x86-64 code?
- kevin_thibedeau 9y agoThe additional registers would be useful. Even if sticking to the x32 ABI.
- CalChris 9y agoThat is so but the subset of x86_64 that you'd use for code generation is pretty much the same as the subset of x86 that you'd use for code generation.
- yjftsjthsd-h 9y ago> Hardly anyone uses 32bit processors anymore, On the contrary, nearly everyone has a processor that can run 32 bit programs now.
- alexfru 9y agoGoing 64-bit is quite a bit of work: - additional 64-bit types will need additional code for type checks and conversions, switch, etc - new or improved code generator is needed (ideally, 64-bit non-pointer types should also be supported in 32-bit programs, possibly as register pairs) - new object and executable formats to handle - possibly new ABIs to support (pushing arguments onto the stack and never bothering to align the stack pointer onto a multiple of 8 or 16 boundary is kinda easy, it's pretty much free) And the above work hasn't been done.
- bootcat 9y agoGuys, i just started reading through source code of 8cc and now this new project :). https://github.com/rui314/8cc https://github.com/rui314/8cc
- cpeterso 9y agoWhat are some current best practices for writing (C) compilers that were not common when, say, gcc 1.0 was written? Would someone writing a basic C compiler today approach it differently than Stallman did with gcc 1.0?
- petercooper 9y agoDepends if you mean a hobby/small C compiler or if you were trying to write something of similar scope to gcc or Watcom, say. If the latter, there have been big developments in the optimization stages (not least due to CPU and architecture changes over the years) and the approach to targeting runtimes would be quite different (far less likely to target x86 directly nowadays when there are things like LLVM or even the CLR/JVM/similar). At the risk of sparking controversy, I think Go is a great example of "how would they do it now?" which goes further than compiler techniques and back to rethinking what the runtime should even be.
- amelius 9y ago> I think Go is a great example of "how would they do it now?" which goes further than compiler techniques and back to rethinking what the runtime should even be. Agreed, but I wish they released the runtime as a separate component, in the same spirit as LLVM.
- chubot 9y agoIMO one big advance would be writing the compiler in something other than C. C is a bad language for writing compilers in (including C compilers)! Even (cough) C++ is better than C for this use case, e.g. comparing LLVM vs. GCC. But C++ has problems too though -- the TableGen language in LLVM is an interesting example of why a big C++ project like LLVM/Clang doesn't want all its logic/specification in C++. They really use C++ to the hilt and they still want/need a DSL. Other interesting options would be Swift, Rust, OCaml, or Go. Swift, Rust, and OCaml all have algebraic data types. I guess choosing something other than C or C++ is a little unusual because there is the tendency to self-host. The Rust, OCaml, and Go compilers are written in Rust, OCaml, and Go, respectively. I'm pretty sure Swift is a lot of C++, but that will probably change as times goes on.
- ryanpcmcquen 9y agoHow does it compare to pcc and tcc?
- dane-pgp 9y agoFrom a bootstrapping or Diverse Double-Compiling point of view, the real question is "Can compiler Y compile compiler X?" As of a few months ago, it is possible to compile (an old, non-C++ version of) gcc with tcc, which is a good position to be in: https://lists.gnu.org/archive/html/tinycc-devel/2017-05/msg00103.html https://lists.gnu.org/archive/html/tinycc-devel/2017-05/msg0...
- earenndil 9y agoCan you then compile a new version of gcc with that old gcc? Or are there more steps in between?
- dane-pgp 9y agoAccording to: http://gcc.gnu.org/install/prerequisites.html http://gcc.gnu.org/install/prerequisites.html "versions of GCC prior to 4.8 also allow bootstrapping with a ISO C89 compiler and versions of GCC prior to 3.4 also allow bootstrapping with a traditional (K&R) C compiler." So you might need to build tcc -> gcc 3.3 -> gcc 4.7 -> gcc 7.2
- alexfru 9y agoIt's less complete in terms of the language and needs less memory. smlrc.c runs in 96KB of RAM on a PIC32 MIPS microcontroller.
- derblitzmann 9y agoHold on... I thought due to the C preprocessor, you couldn't have just a single pass. Unless they aren't counting it as a pass?
- boardwaalk 9y agoI don't see any reason the preprocessor couldn't be integrated with the main parsing pass. It's all top-down (things defined before they're used) just like C.
- jokoon 9y agoIt seems there are C interpreters, I wonder how convenient it would be to use a C interpreter versus using LUA for example. Although I've never tried using an interpreter in a program, bridging calls from a script inside your compiled program seems difficult.