intending to contribute on clang

Have subscribed to relevant mailing list and intends to contribute to clang/clang++.
But unfortunately, I am all dump in compiler engieering,
and yes clang is a great compiler which we have used in our open source project and aware of open source development

Would somebody throw some light on how to start on knowledge requirement part.

There are books and courses on compiler development, but honestly
I think the best approach is just to pick some (small!) existing feature
in clang that you're interested in and figure out how it works. Pay
attention to the ASTs that get built and watch how they get interpreted.


You can browse open issues and try to find something small to get you
started. You can also search for FIXME comments in the code and try to
improve the codebase. Improving diagnostics is another option. But
whatever you choose know that it won't be easy, you'll have to read
the standards and understand the languages very well (this is
something I've been trying to do without much success) and also
understand the design of llvm/clang.

There are lots of things that you can do to help which require practically
no knowledge of compiler engineering. I would recommend looking at your
skills and looking for places to apply them.

There are lots of things that would help us enormously that are only
tangentially related to compiler engineering. For example:

- Improving our website: Currently it seems like every separate llvm web
presence has a different look and feel[1]. It would be fantastic if someone
could develop an attractive stylesheet that all the different projects
could use. (I'm the person to contact for more information if you are
interested in working on this).

- Try building software with Clang and see where it fails. For example, a
thankless but enormously helpful job would be to look at <> and try to improve that number. Some failures are
clang's fault. For these, developing reduced test cases and filing bugs for
us would be *extremely* helpuful. Some other build failures are just
oversights of the developers due to GCC being lax. Submitting patches to
those projects to fix those oversights is a thankless but incredibly
valuable effort. General Unix/Linux knowledge and C/C++ coding is really
all that is needed for this; experience interacting with the debian folks
would also be helpful. You could also do something similar by just trying
to build a gentoo installation and fixing/reporting errors as you run into

- Similar to the above, but more extreme, is to trying to building software
on windows and seeing where it fails; reducing test cases where our
behavior is not correct would be a big help towards improving our MS
support. (this needs *a lot* of work, but you can make a dent). If you have
solid knowledge of Microsoft's C++ ABI, then you could really help our
Microsoft C++ ABI support for example.

The important thing is seeing what your specific strengths are and then
applying them. Almost nothing that you learn from a compiler textbook will
really be applicable to working on Clang. As John mentioned, the best way
to understand clang is to just pick a piece and figure out how it works and
gain familiarity with the codebase. Blogging about your findings is also
helpful, since then it helps out others who want to learn too; also,
explaining a feature in a way that another person could understand is a
good way to make sure that *you* actually understand.

[1] Compare:

-- Sean Silva