The bit twiddling office called. They want a function to compute a sequence of ARM64 instructions that fills a register with an arbitrary constant 64-bit number.

Zeros in positive number

All ARM64 instructions are 32 bits long, so one instruction can’t possibly handle all 64-bit patterns. One straightforward way to assemble the desired bit pattern is to use MOVK which sets any one of the four 16-bit chunks of the register without touching any other chunks. So, four MOVK instructions can assemble any 64-bit pattern.

Let’s say you want to associate a property with an object, but you don’t want to write to the object directly, maybe for design reasons or logistical reasons. (What if the object is frozen and immutable?) You can use WeakMap for this, and the garbage collector is free to collect keys of the map:

object = []
map = ObjectSpace::WeakMap.new
map[object] = [object]

p map.member?(object) # => true

There is an issue with this demo, however. Currently, Ruby’s WeakMap doesn’t keep the values of the map alive, so the map evicts the pair in the demo after a garbage collection run, even though the key survives:

Recently, I took a distribution version update for a Ubuntu system with a GTX 460 and I ended up spending a few hours to find out that the proprietary driver no longer works with the newest kernels. The open source nouveau driver didn’t handle the decade old card any better. I had to downgrade to an older LTS kernel and use Nvidia’s driver.

A different machine of mine running Raven Ridge integrated graphics recently also started to have issues. It freezes and dumps scary red text about amdgpu to the kernel ring buffer. This reminds me of when I first bought the machine in 2018, when Raven Ridge was new and the drivers for it nascent. It eventually stabilized, but now the crashes are back.

This is a post about the bits and pieces I learned while trying to fix a symbol leakage problem for YJIT-enabled Ruby. The symbols I’m talking about are the labels in object, executable, and shared library files that help linkers work.

Thinking back to my first few contacts with linkers, I found them somewhat mysterious. I think this is because I get errors from compilers more frequently than from linkers. Also, compared to compilers, linkers are generally in a worse vantage point for giving context-rich error messages that use familiar programming language level terms.

Recently I was asked how I review C99 code for problems that arise from failing to follow the so called “strict aliasing rules”. I struggled to answer, so I thought I would write a post to hopefully make my explanation more coherent.

The strict aliasing rules can be surprising because the way optimizers take advantage of them doesn’t mesh well with the popular belief that pointers are “just numbers”. Ultimately, I think there are practical benefits to understanding the rules even if you disagree with them. Popular compilers such as GCC and Clang take advantage of the rules so knowing them can help with debugging if for nothing else.

This guide intends to help Ruby native extension maintainers upgrade libraries to be compatible with GC.compact. Application developers can also use this guide to check applications for compaction compatibility. At the time of writing, the latest Ruby release is version 3.0.0.

Using automated tests to surface crashes

If your test suite runs under Ruby 2.7.0 or newer, it is possible to check for compaction crashes with a small addition to your test suite.

I have a K-Type, which is a programmable keyboard that lets me configure custom hotkeys. The configurations live with and on the keyboard, which is neat. Among other things, this lets my configuration work across different operating systems.

My current configuration has several navigation hotkeys that activate with the CAPSLOCK key. CAPSLOCK+{j,k,l,;} send arrow keys, in a way similar to Vim’s default normal mode bindings. CAPSLOCK+{i,n} gives page up and down, while CAPSLOCK+{h,quote} sends HOME and END. This hotkey cluster lets me scroll and move cursors without having to take my right hand away from the home row (index finger on j).

The first commit I made for my compiler was in 2016, it read “Here’s hoping I get this done in time”. I’m not sure if I met the deadline that message was referring to, but the compiler is certainly “done” now.

Of course, no one in the right mind would use the compiler for anything serious, but the compiler compiles code, and I’ve made a simple graphical app launcher using it.

I mostly want to talk about the human aspects of this project. I find a lot of technical stuff in the project interesting too, but as somebody who is very much a novice at building compilers, I don’t think I bring much to the table talking about compiler construction.