View rustc.rs
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>
View future.rs
// 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;
View Avery RPC.md

Remote procedure calls in Avery

Introduction

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.

View Caps.md

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.

Messages

enum Message {
View Control flow integrity and dynamic linking plot
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.
View patchpoint.ll
; 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() {
View nicer.ll
; 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
View gist:44f0e0d3519fcfbcd35d
  • Start Date: 2014-07-22
  • RFC PR #: (leave this empty)
  • Rust Issue #: (leave this empty)

Summary

This adds the ability to have macros in type signatures.

Motivation

View gist:2a69723a14704db3d50f
  • Start Date: 2014-07-21
  • RFC PR #: (leave this empty)
  • Rust Issue #: (leave this empty)

Summary

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>.

View gist:2b50c3897e9cb1883d07
  • Start Date: 2014-07-20
  • RFC PR #: (leave this empty)
  • Rust Issue #: (leave this empty)

Summary

Values should be able to be passed as type parameters. The [T, ..n] fixed length array should be changed to use a value as a type parameter.

Motivation