This is the eighth post in our Compiler series. Other posts:

• LLVM Everywhere
• Compilers 101 – Overview and Lexer
• Compilers 102 – Parser
• Compilers 103 – Semantic Analyzer
• Compilers 104 – IR Generation
• Compilers 105 – Back End Overview
• Compilers 106 – Optimizer
• Compilers 107 – Optimizer Loop Unrolling

This is the simple code we started with in the Compilers 101 blog post:

sum = 3.14 + 2 * 4 // calculation

It results in a constant value of 11. After the IR is generated and optimized, it can boil down to just a single line of machine code, which will vary by processor and architecture. Machine code is just binary and not readable, so below is what the Assembly code might look like.

This is the Assembly code for 32-bit ARM:

movs r0, #11

This is the Assembly code for ARM64:

movz w0, #11

x86 and x86-64 use this Assembly code:

movl $11, %eax

Obviously this is the tricky part of making a multi-platform compiler since Assembly code is different between processors and architectures.

Once you have machine code that the computer can run, the last step is to link all the pieces together so that you have an app that the OS can run. This is done by the Linker.

As you may know, Xojo’s compiler takes the code you write and translates it into a sort of meta-assembly language. Think of it as assembly code that is not specific to any particular processor. This part of the compiler is called the Front End. The Back End of the compiler takes that meta-assembly code and translates it into actual machine code for a particular processor such as x86 or ARM. We have been moving Xojo from our own compiler Back End to using an open source one known as LLVM which is used by Apple and others as well. It’s how we are building for 64-bit and it optimizes your code for speed, something our old compiler Back End did not do.

We depend on LLVM to provide us with the data we need to make debugging work. LLVM version 3.7 had the necessary support for macOS and Linux. LLVM version 4 has added this for Windows but it was released only a few weeks ago, not enough time for us to get it working for today’s release of Xojo 2017 Release 1. Although you don’t directly see LLVM when you use Xojo, it’s doing significant and important work. Switching from one major release of LLVM to another affects far more than just debugging so it must be done very early in our development of a release of Xojo. It’s likely that 64-bit debugging support for Windows will be available in Xojo 2017 Release 2.

64-bit support in Xojo may seem like a minor feature. After all, for most of you, switching from 32 to 64-bit is a single-click operation. However, for it to be that simple has required a huge amount of effort on our part. While you can still get by with 32-bit apps in most cases today, that won’t be true in the not-too-distant future. That’s why it’s critical we make it easy for you to switch. The importance of Xojo supporting 64-bit really can’t be overstated.

Remember that many features in Xojo take multiple release cycles to complete. That means that when the feature list is short, there’s working going on for future releases. When it’s long, much of that work may have been done during previous release cycles. It’s a curious fact of software development that sometimes features that seem simple on the outside are actually large and complex on the inside.

There’s a lot more coming for Xojo in 2017 so stay tuned.