Skip to content

Instantly share code, notes, and snippets.

Zoxc / test.ll
Created February 6, 2020 03:54
LLVM infinite loop
; ModuleID = '../../../../output-func.ll'
source_filename = "rustc_mir.anxkd8ga-cgu.7"
target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc"
; Function Attrs: nounwind uwtable
define hidden fastcc void @_ZN5alloc5slice5merge17hae3c4424e1deafb6E([0 x i32]* nonnull align 4 %0, i64 %1, i64 %2, i32* %3) {
%5 = shl i64 %2, 2
%6 = bitcast i32* %3 to i8*
%7 = bitcast i32* undef to i8*
Zoxc /
Last active September 23, 2017 08:31
rustc TyCtxt model
use std::cell::RefCell;
use std::collections::HashSet;
// This is the mapping of types in this model to types in rustc:
// model => rustc
// TyS<'a> => TyS<'tcx>
// Ty<'a> => Ty<'tcx>
// Arena => DroplessArena
// Interner<'cx> => CtxtInterner<'tcx>
// Ctxt<'a, 'gcx, 'lcx> => TyCtxt<'a, 'gcx, 'tcx>
Zoxc /
Last active January 8, 2017 01:29
// A function pointer and some data to pass to the callback
pub struct Callback<R> {
pointer: fn (R, *const ()),
data: *const (),
// This is the trait implemented for generators
pub trait Future {
type Return;

Remote procedure calls in Avery


Avery's RPCs are based on capabilities. A capability is a reference to an object which the process has previously received. If you do not have a capability to an object, you cannot communicate with it.

You can do asynchronous calls to objects. These in calls, arguments and return values can contain both bytes and capabilities. If you send a capability to another process it gains access to it.

Objects belong to an event loop (a kernel object) and all messages sent to it is queued there.

Zoxc /
Last active July 23, 2016 07:47

Capability system

This is a sketch of a capability system which utilised data and operations in kernel mode.

There are 2 kernel objects used to support the capability system, Vat and Call. Cap is a global identifier of a capability consisting of a Vat reference and a vat defined number.


enum Message {
All code is shared between processes. Processes can not read or write to the code segment.
The global code segment is 2 TB. It is split into 1MB blocks, giving 2M blocks in total.
A module is a executable or shared library.
Each process has an bitmap where each bit represents a block of code of the code segment.
With 1 bit per block means the size of the array is 256KB.
If a bit is 0, the process does not have access to the block in the code segment.
; ModuleID = 'bugpoint-reduced-simplified.bc'
target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: noreturn
declare void @fail()
declare void @llvm.experimental.patchpoint.void(i64, i32, i8*, i32, ...)
define void @test() {
Zoxc / nicer.ll
Created July 27, 2015 19:32
LLVM codegen
; ModuleID = 'nicer.ll'
target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
define i8 @test({ i8*, i64 } %arg, i64 %arg1) unnamed_addr {
"the block":
%tmp = extractvalue { i8*, i64 } %arg, 1
%tmp2 = icmp ugt i64 %tmp, %arg1
br i1 %tmp2, label %exit, label %cond.i
Zoxc / gist:44f0e0d3519fcfbcd35d
Last active August 29, 2015 14:04
Type macros
  • Start Date: 2014-07-22
  • RFC PR #: (leave this empty)
  • Rust Issue #: (leave this empty)


This adds the ability to have macros in type signatures.


Zoxc / gist:2a69723a14704db3d50f
Last active August 29, 2015 14:04
Field offsets RFC
  • Start Date: 2014-07-21
  • RFC PR #: (leave this empty)
  • Rust Issue #: (leave this empty)


This adds the ability to refer to fields of types and use them later on with objects of that type. The FieldOffset<Obj, Field> type is added which refers to fields of type Field in the object Obj. The offsetof Type.field syntax is defined to construct instances of FieldOffset<Type, the type of field>.