Microprocessors and Programming Languages: How the Translation Process Works

Understanding how a microprocessor translates different programming languages like COBOL, Fortran, BASIC or C into machine language is crucial for effective software development. This article explains the complex process of converting high-level languages into a binary format that the hardware can understand.

Introduction: A Game of Telephone

When you write code in a high-level language like COBOL, Fortran, BASIC or C, you are essentially speaking a language that is not directly understandable by the hardware. Instead, these languages are compiled or interpreted into machine language, which the microprocessor can directly execute. This process is akin to a game of telephone, where each step transforms the original message into a form that the next party can understand.

From Source Code to Machine Instructions

A program called a compiler plays a central role in this process. It takes your high-level code and converts it into a series of machine instructions. For example, the code in C:

C A * B

might be translated into assembly language as:

load R0, A
mul R0, B
store R0, C

and in binary machine code, it would look like:

8b 15 20 2f 00 00 40 40 2c A
8b 05 1e 2f 00 00 40 40 30 B
01 d0
89 05 1a 2f 00 00 40 40 34 C

Similarly, for an Arduino, the same operation might require more instructions:

20 91 60 00 lds r18, 60
30 91 61 00 lds r19, 61
80 91 62 00 lds r24, 62
80 91 63 00 lds r25, 63
82 0f add r24, r18
93 1f adc r25, r19
90 93 65 00 sts r25, 65
90 93 64 00 sts r24, 64

Interpreters and Byte Code

Not all programming languages use compilers in the same way. Some, like BASIC or Python, are run directly by the microprocessor. In these cases, the microprocessor has a program stored within itself that interprets the source code line by line. This program converts the source code into a form called byte code, which is a low-level representation that can be understood by the microprocessor.

For example, the line `C A * B` might be interpreted as:

push A
pop B
mul
store C

This byte code is then executed by another program, which converts it into a series of machine instructions. This process can be seen as a higher-level interpreter that manages the byte code.

Custom Compilers

For educational or toy purposes, it's possible to create a custom compiler that translates a simplified language into machine instructions. Here's an example:

int values[256]
int stack[100]
int sp  -1

void pushint(int value)
 {
   sp  sp   1;
   if (sp  sizeof(stack)/sizeof(stack[0]))
   {
      throw new StackOverflowException;
   }
   stack[sp]  value;
 }

int pop()
 {
   if (sp  0)
   {
      throw new StackUnderflowException;
   }
   return stack[sp--];
 }

void utechar(char s)
 {
   bool running  true;
   while (running)
   {
       uint8_t op  (uint8_t)s;
       switch (op)
       {
           case '.':
               pushint(pop());
               break;
           case ',':
               pushint(pop() - int(pop()));
               break;
           case '':
               {
                   int val  pop();
                   int pop();
                   val;
               }
               break;
           case '|':
               running  false;
               break;
           default:
               if (!isalpha(op))
               {
                   // report syntax error
               }
               pushint(values[op]);
               break;
       }
   }

}

This code, while highly simplified, illustrates the process of converting high-level language instructions into machine instructions. It uses a stack-based approach to manage variables and perform operations.

Conclusion: Understanding the Low-Level World

Understanding the translation process between high-level languages and machine language is essential for developers. By grasping how compilers and interpreters work, you can better optimize your code and appreciate the complex behind-the-scenes processes that make modern computing possible.