Compiler - Target Platform and Language Classification

Compiler Classification Compilers are often classified in two important ways: by the target platform (where the output code runs) and by the target language (what form the output code takes). Understanding these classifications helps clarify when and why different compiler types are used in software development. Classification by Target Platform Native and Hosted Compilers A native compiler (also called a hosted compiler) is the most straightforward type: it generates executable code that runs on the same computer architecture and operating system where the compiler itself is running. For example, if you compile a C program on your Windows laptop using a compiler installed on that same Windows laptop, the resulting executable runs on Windows—this is a native compiler. The term "hosted" emphasizes that the compiler runs "hosted" on the target system. Native compilers are the most common type you'll encounter because they allow you to develop and test software directly on the machine where it will run. Cross Compilers A cross compiler produces executable code designed to run on a different platform than the one where the compiler executes. Cross compilers are essential for embedded systems development. Embedded systems (like microcontrollers in appliances, automotive systems, or IoT devices) often lack the computing power or resources to run a full development environment. Instead, developers use a powerful desktop computer running a cross compiler to generate machine code for the embedded device. For example, you might run a cross compiler on your Linux desktop computer to generate executable code for an ARM-based microcontroller. The compiler runs on the Linux desktop (the "host" platform) but produces code for the ARM device (the "target" platform). Virtual-Machine Target Compilers Some compilers generate code that runs on a virtual machine (a software-based emulation of a computer) rather than directly on physical hardware. These compilers occupy a special category because the distinction between native and cross doesn't apply cleanly to them. When code is compiled to run on a virtual machine, it may execute on the same platform where the compiler runs, or it may execute on a completely different platform—what matters is that the virtual machine acts as an intermediary. Since the execution environment is virtualized rather than physical, these compilers are typically not classified as either native or cross compilers. A common example is Java, where compilers generate bytecode that runs on the Java Virtual Machine (JVM). The bytecode can run on any computer with a JVM installed, regardless of the platform where the Java compiler was running. Classification by Target Language High-Level Target Languages Not all compilers produce machine code or bytecode. Some compilers are source-to-source compilers (also called transpilers)—they translate source code from one high-level programming language into another high-level programming language, rather than directly into machine code. The C programming language is particularly important in this context. Because C is widely supported across different platforms and can be optimized effectively by standard C compilers, many compiler designers use C as a portable assembly language—a convenient intermediate target that can then be compiled to machine code for any platform with a C compiler available. This creates a flexible compilation pipeline: source code in language A → C code → machine code for platform X. This approach provides both portability and the ability to leverage existing C compiler optimizations. Characteristics of Generated C Code When compilers generate C code as an intermediate form, that generated code is not intended for human readability. The compiler optimizes for correctness and efficiency, not for human understanding. As a result, generated C code typically lacks proper formatting, indentation, and meaningful variable names. This is fundamentally different from hand-written code, where programmers follow style guidelines for readability. Generated code might have all statements on a single line, use cryptic variable names, or have unusual structure—all of which is perfectly fine since the generated code will be processed by another compiler, not read by humans. <extrainfo> The image shown illustrates how multiple source languages can feed into a unified compiler architecture. Notice how Language 1 and Language 2 each have their own front-end (lexical analyzer, parser, and intermediate-code generator), but then both produce the same intermediate code format. This intermediate code flows into a shared optimizer, which then feeds into multiple target-specific code generators. This architecture demonstrates the practical benefit of using intermediate representations: the expensive optimization phase doesn't need to be duplicated for each source language or target platform. Instead, it operates on a language-independent and platform-independent intermediate form. </extrainfo>