1 * MCS: The Ximian C# compiler
3 The Mono C# compiler is considered feature complete at this
4 point and relatively mature. MCS is able to compile itself
5 and many more C# programs (there is a test suite included that
6 you can use). It is routinely used to compile Mono, roughly
7 half a million lines of C# code.
11 There are a few known bugs in the Mono C# compiler, but
12 they are very very few at this point,
13 you can also browse the MCS <a href="http://bugzilla.ximian.com/buglist.cgi?product=Mono%2FMCS&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&email1=&emailtype1=substring&emailassigned_to1=1&email2=&emailtype2=substring&emailreporter2=1&changedin=&chfieldfrom=&chfieldto=Now&chfieldvalue=&short_desc=&short_desc_type=substring&long_desc=&long_desc_type=substring&bug_file_loc=&bug_file_loc_type=substring&keywords=&keywords_type=anywords&op_sys_details=&op_sys_details_type=substring&version_details=&version_details_type=substring&cmdtype=doit&newqueryname=&order=Reuse+same+sort+as+last+time&form_name=query">bugs</a> from Bugzilla.
15 A test suite is maintained to track the progress of
16 the compiler and various programs are routinely compiled and
21 Slides for the Mono C# Compiler presentation at .NET ONE are
23 href="http://primates.ximian.com/~miguel/slides-europe-nov-2002/Mono_C_Sharp_Overview_1007.sxi">here</a>
28 The Mono C# compiler is part of the `mcs' module in the Mono CVS
29 you can get it from our <a href="anoncvs.html">Anonymous CVS</a> server,
30 or you can get nightly <a href="download.html">download page</a>.
34 MCS is written in C# and uses heavily the .NET APIs. MCS runs
35 on Linux with the Mono runtime and on Windows with both the
36 .NET runtime and the Mono runtime.
38 ** Reporting Bugs in MCS
40 When you report a bug, try to provide a small test case that would
41 show the error so we can include this as part of the Mono C# regression
44 If the bug is an error or a warning that we do not flag, write
45 a sample program called `csXXXX.cs' where XXXX is the code number
46 that is used by the Microsoft C# compiler that illustrates the
47 problem. That way we can also do regression tests on the invalid
50 ** Phases of the compiler
52 The compiler has a number of phases:
55 * Lexical analyzer: hand-coded lexical analyzer that
56 provides tokens to the parser.
58 * The Parser: the parser is implemented using Jay (A
59 Berkeley Yacc port to Java, that I ported to C#).
60 The parser does minimal work and syntax checking,
61 and only constructs a parsed tree.
63 Each language element gets its own class. The code
64 convention is to use an uppercase name for the
65 language element. So a C# class and its associated
66 information is kept in a "Class" class, a "struct"
67 in a "Struct" class and so on. Statements derive
68 from the "Statement" class, and Expressions from the
71 * Parent class resolution: before the actual code
72 generation, we need to resolve the parents and
73 interfaces for interface, classe and struct
76 * Semantic analysis: since C# can not resolve in a
77 top-down pass what identifiers actually mean, we
78 have to postpone this decision until the above steps
81 * Code generation: The code generation is done through
82 the System.Reflection.Emit API.
87 The compiler performs a number of simple optimizations on its input:
88 constant folding (this is required by the C# language spec) and
89 can perform dead code elimination.
91 Other more interesting optimizations like hoisting are not possible
92 at this point since the compiler output at this point does not
93 generate an intermediate representation that is suitable to
94 perform basic block computation.
96 Adding an intermediate layer to enable the basic block
97 computation to the compiler should be a simple task, but we
98 are considering having a generic CIL optimizer. Since all the
99 information that is required to perform basic block-based
100 optimizations is available at the CIL level, we might just skip
101 this step altogether and have just a generic IL optimizer that
102 would perform hoisting on arbitrary CIL programs, not only
103 those produced by MCS.
105 If this tool is further expanded to perform constant folding
106 (not needed for our C# compiler, as it is already in there)
107 and dead code elimination, other compiler authors might be
108 able to use this generic CIL optimizer in their projects
109 reducing their time to develop a production compiler.
113 MCS was able to parse itself on April 2001, MCS compiled itself
114 for the first time on December 28 2001. MCS became self hosting
115 on January 3rd, 2002.
117 The Mono Runtime and the Mono execution engine were able to make
118 our compiler self hosting on March 12, 2002.
120 ** Questions and Answers
122 Q: Why not write a C# front-end for GCC?
124 A: I wanted to learn about C#, and this was an exercise in this
125 task. The resulting compiler is highly object-oriented, which has
126 lead to a very nice, easy to follow and simple implementation of
129 I found that the design of this compiler is very similar to
130 Guavac's implementation.
132 Targeting the CIL/MSIL byte codes would require to re-architecting
133 GCC, as GCC is mostly designed to be used for register machines.
135 The GCC Java engine that generates Java byte codes cheats: it does
136 not use the GCC backend; it has a special backend just for Java, so
137 you can not really generate Java bytecodes from the other languages
140 Q: If your C# compiler is written in C#, how do you plan on getting
141 this working on a non-Microsoft environment.
143 We will do this through an implementation of the CLI Virtual
144 Execution System for Unix (our JIT engine).
146 Our JIT engine is working for the purposes of using the compiler.
147 The supporting class libraries are being worked on to fully support
152 A: No, currently I am using Jay which is a port of Berkeley Yacc to
153 Java that I later ported to C#. This means that error recovery is
154 not as nice as I would like to, and for some reason error
155 productions are not being caught.
157 In the future I want to port one of the Bison/Java ports to C# for
160 Q: Should someone work on a GCC front-end to C#?
162 A: I would love if someone does, and we would love to help anyone that
163 takes on that task, but we do not have the time or expertise to
164 build a C# compiler with the GCC engine. I find it a lot more fun
165 personally to work on C# on a C# compiler, which has an intrinsic
168 We can provide help and assistance to anyone who would like to work
171 Q: Should someone make a GCC backend that will generate CIL images?
173 A: I would love to see a backend to GCC that generates CIL images. It
174 would provide a ton of free compilers that would generate CIL
175 code. This is something that people would want to look into
176 anyways for Windows interoperation in the future.
178 Again, we would love to provide help and assistance to anyone
179 interested in working in such a project.
181 Q: What about making a front-end to GCC that takes CIL images and
182 generates native code?
184 A: I would love to see this, specially since GCC supports this same
185 feature for Java Byte Codes. You could use the metadata library
186 from Mono to read the byte codes (ie, this would be your
187 "front-end") and generate the trees that get passed to the
190 Ideally our implementation of the CLI will be available as a shared
191 library that could be linked with your application as its runtime
194 Again, we would love to provide help and assistance to anyone
195 interested in working in such a project.
197 Q: But would this work around the GPL in the GCC compiler and allow
198 people to work on non-free front-ends?
200 A: People can already do this by targeting the JVM byte codes (there
201 are about 130 compilers for various languages that target the JVM).
203 Q: Why are you writing a JIT engine instead of a front-end to GCC?
205 A: The JIT engine and runtime engine will be able to execute CIL
206 executables generated on Windows.
208 You might also want to look at the <a href="faq.html#gcc">GCC</a>
209 section on the main FAQ