How do compilers assure stability? Suppose you need a c compiler. It would be preferable to write that compiler in a c-like language, given the complexity of a compiler of that degree. At best, the c compiler would be written in c, but that would require a c compiler to begin with. If a mistake is made in the making of one of the early iterations of compilers, it could propagate. How do compilers make sure that this doesn't happen? Obviously, no code is flawless, not even the processor is, but if you haven't somehow measured the stability, you don't even know if your compiler is stable. What assumptions are made and how is it justified? I would imagine it would be architecture-dependent too.
Edit: By stability, I mean that the code runs as intended.
It happens that compilers contain subtle errors. No blatant errors, because blatant errors would be detected and fixed.
A compiler that is itself compiled by a compiler with subtle errors will tend to have blatant errors. They will be easy to detect because they are so blatant. They will be hard to fix because these blatant errors will be produced by perfectly fine source code, so whoever wants to fix it will have a hard time finding the real problem.
The solution will be to make a compiler of sufficient quality that bugs are very rare, and extremely rare within the compiler. We also expect compiler bugs to affect very complicated code more, so the compiler writer should write code that is simple and follows common coding patterns.