My talk from RustFest (Kyiv, 2017)

1. Rust JavaScript
Ingvar Stepanyan
@RReverser

2. Wait but why

3. JavaScript:
true cross-platform target

4. JavaScript:
true cross-platform target

5. JavaScript:
true cross-platform target

6. JavaScript:
true cross-platform target

7. JavaScript:
true cross-platform target

8. JavaScript:
true cross-platform target

9. JavaScript:
true cross-platform target

10. JavaScript:
true cross-platform target

11. JavaScript:
true cross-platform target

12. Wait but how

14. C/C++ CFG/SSA
LLVM
bitcode
Native
objects
Native
executable
Clang (LLVM)

15. C/C++ CFG/SSA
LLVM
bitcode
JavaScript /
WASM
Emscripten (LLVM)

16. Rust CFG/SSA
LLVM
bitcode
Native
objects
Native
executable
Rust (LLVM)

17. Emscripten + Rust
Rust CFG/SSA
LLVM
bitcode
Native
objects
Native
executable
C/C++ CFG/SSA
LLVM
bitcode
JavaScript /
WASM

18. Emscripten + Rust
Rust CFG/SSA
LLVM
bitcode
Native
objects
Native
executable
C/C++ CFG/SSA
LLVM
bitcode
JavaScript /
WASM

19. Emscripten + Rust
Rust CFG/SSA
LLVM
bitcode
C/C++ CFG/SSA
LLVM
bitcode
JavaScript /
WASM

20. Hell o'world

22. // hello.rs
fn main() {
println!("Hello, world");
}

23. $ rustc --target=asmjs-unknown-emscripten hello.rs
$ node hello.js
Hello, world

24. Exporting functions
#[no_mangle]
pub extern fn add_integers(x: i32, y: i32) -> i32 {
return x + y;
}

25. Exporting functions
#[no_mangle]
pub extern fn add_integers(x: i32, y: i32) -> i32 {
return x + y;
}
fn main() {}

26. $ rustc --target=asmjs-unknown-emscripten hello.rs
$ node
> require('./hello')
$

27. Exporting functions
#![feature(link_args)]
#[no_mangle]
pub extern fn add_integers(x: i32, y: i32) -> i32 {
return x + y;
}
#[link_args = "-s NO_EXIT_RUNTIME=1"]
extern {}
fn main() {}

28. Exporting functions
#[no_mangle]
pub extern fn add_integers(x: i32, y: i32) -> i32 {
return x + y;
}
extern {
fn emscripten_exit_with_live_runtime();
}
fn main() {
unsafe {
emscripten_exit_with_live_runtime();
}
}

29. $ rustc --target=asmjs-unknown-emscripten hello.rs
$ node
> require('./hello')
exit(0) implicitly called by end of main(), but
noExitRuntime, so not exiting the runtime (you can
use emscripten_force_exit, if you want to force a
true shutdown)
[Emscripten Module object]
> require('./hello')._add_integers(10, 20)
30

30. Exporting functions
$ emcc ... "hello.0.o" "-o" "hello.js" "-s"
"EXPORTED_FUNCTIONS=["_add_integers","_main",
"_rust_eh_personality"]" ...

31. Exporting functions
var real__add_integers = asm["_add_integers"];
asm["_add_integers"] = function() {
assert(runtimeInitialized, 'you need to wait for the runtime
to be ready (e.g. wait for main() to be called)');
assert(!runtimeExited, 'the runtime was exited (use
NO_EXIT_RUNTIME to keep it alive after main() exits)');
return real__add_integers.apply(null, arguments);
};

32. Generated code (asm.js)
function _add_integers($0,$1) {
$0 = $0|0;
$1 = $1|0;
var $$arith = 0, $$ispos = 0, $$negcheck = 0, $$negtemp = 0, $$poscheck = 0, $
$postemp = 0, $$select = 0, $2 = 0, label = 0, sp = 0;
sp = STACKTOP;
$$arith = (($0) + ($1))|0;
$$postemp = (($0) + -2147483648)|0;
$$negtemp = (($0) + 2147483647)|0;
$$poscheck = ($$arith|0)<($$postemp|0);
$$negcheck = ($$arith|0)>($$negtemp|0);
$$ispos = ($0|0)>=(0);
$$select = $$ispos ? $$poscheck : $$negcheck;
$2 = $$select;
if ($2) {
__ZN4core9panicking5panic17h0c8c35aaab94c092E(2160);
// unreachable;
} else {
return ($$arith|0);
}
return (0)|0;
}

33. Optimized code (asm.js)
function _add_integers($0, $1) {
$0 = $0 | 0;
$1 = $1 | 0;
return $1 + $0 | 0; //@line 47
}

34. Optimized code (WASM)
(func $_add_integers (param $0 i32) (param $1 i32)
(result i32)
(i32.add
(get_local $1)
(get_local $0)
)
)

35. asm.js <-> wasm
x+y|0
(i32.add (get_local $x)
(get_local $y))
+(x+y)
(i32.add (get_local $x)
(get_local $y))
f()|0 (call $f)
HEAP32[ptr>>2]|0
(i32.load (get_local
$ptr))

36. Memory model
var HEAP8 = new global.Int8Array(buffer);
var HEAP16 = new global.Int16Array(buffer);
var HEAP32 = new global.Int32Array(buffer);
var HEAPU8 = new global.Uint8Array(buffer);
var HEAPU16 = new global.Uint16Array(buffer);
var HEAPU32 = new global.Uint32Array(buffer);
var HEAPF32 = new global.Float32Array(buffer);
var HEAPF64 = new global.Float64Array(buffer);

37. Memory model

38. Calling JavaScript
#include <emscripten.h>
int main() {
EM_ASM(
alert("who doesn't like popups?");
);
return 0;
}

39. Calling JavaScript
// system/include/emscripten/em_asm.h
#define EM_ASM(...) emscripten_asm_const(#__VA_ARGS__)
#define EM_ASM_(code, ...)
emscripten_asm_const_int(#code, __VA_ARGS__)
...

40. Calling JavaScript
emscripten_asm_const: true,
emscripten_asm_const_int: true,
emscripten_asm_const_double: true,

43. Calling JavaScript
function _main() {
var label = 0, sp = 0;
sp = STACKTOP;
_emscripten_asm_const_v(0);
return 0;
}

44. Calling JavaScript
var ASM_CONSTS = [function() {
alert("who doesn't like popups?");
}];
function _emscripten_asm_const_v(code) {
return ASM_CONSTS[code]();
}

45. Calling JavaScript
extern {
fn emscripten_asm_const(code: &str, ...);
}

46. Calling JavaScript
extern {
fn emscripten_asm_const(code: *const u8, ...);
}

47. Calling JavaScript
unsafe {
emscripten_asm_const_int(b"alert("who doesn't like
popups?");");
}

48. Calling JavaScript
unsafe {
emscripten_asm_const_int(b"alert("who doesn't like
popups?");".as_ptr());
}

49. Calling JavaScript
unsafe {
emscripten_asm_const_int(b"alert("who doesn't like
popups?");" as *const u8);
}

50. Calling JavaScript
unsafe {
emscripten_asm_const_int(b"alert("who doesn't like
popups?");0" as *const u8);
}

51. Calling JavaScript
macro_rules! js {
($expr:expr $(,$arg:expr)*) => (unsafe {
emscripten_asm_const(
concat!(stringify!($expr), "0")
as *const str
as *const u8
)
})
}

52. Calling JavaScript
js! {
alert("who doesn't like popups?");
}

53. Calling JavaScript

54. But what about fancy types

55. Embind
C++ magic

56. #include <emscripten/bind.h>
using namespace emscripten;
class MyClass {
public:
MyClass(int x) : x(x) {}
int getX() const { return x; }
void setX(int x_) { x = x_; }
private:
int x;
};

57. // Binding code
EMSCRIPTEN_BINDINGS(my_class_example) {
class_<MyClass>("MyClass")
.constructor<int>()
.property("x", &MyClass::getX, &MyClass::setX)
;
}

58. $ emcc --bind hello.cpp -o hello.js

59. > module = require('./hello')
[Emscripten Module object]
> myObj = new module.MyClass(10)
MyClass {}
> myObj.x
10

60. > myObj.$$.ptr
5247384
> module.HEAP32[myObj.$$.ptr >> 2]
10

61. Embind
C++ magic

62. EMSCRIPTEN_ALWAYS_INLINE explicit class_(const char* name) {
using namespace internal;
BaseSpecifier::template verify<ClassType>();
auto _getActualType = &getActualType<ClassType>;
auto upcast = BaseSpecifier::template getUpcaster<ClassType>();
auto downcast = BaseSpecifier::template getDowncaster<ClassType>();
auto destructor = &raw_destructor<ClassType>;
_embind_register_class(
TypeID<ClassType>::get(),
TypeID<AllowedRawPointer<ClassType>>::get(),
TypeID<AllowedRawPointer<const ClassType>>::get(),
BaseSpecifier::get(),
getSignature(_getActualType),
reinterpret_cast<GenericFunction>(_getActualType),
getSignature(upcast),
reinterpret_cast<GenericFunction>(upcast),
getSignature(downcast),
reinterpret_cast<GenericFunction>(downcast),
name,
getSignature(destructor),
reinterpret_cast<GenericFunction>(destructor));
}

63. EMSCRIPTEN_ALWAYS_INLINE explicit class_(const char* name) {
using namespace internal;
BaseSpecifier::template verify<ClassType>();
auto _getActualType = &getActualType<ClassType>;
auto upcast = BaseSpecifier::template getUpcaster<ClassType>();
auto downcast = BaseSpecifier::template getDowncaster<ClassType>();
auto destructor = &raw_destructor<ClassType>;
_embind_register_class(
TypeID<ClassType>::get(),
TypeID<AllowedRawPointer<ClassType>>::get(),
TypeID<AllowedRawPointer<const ClassType>>::get(),
BaseSpecifier::get(),
getSignature(_getActualType),
reinterpret_cast<GenericFunction>(_getActualType),
getSignature(upcast),
reinterpret_cast<GenericFunction>(upcast),
getSignature(downcast),
reinterpret_cast<GenericFunction>(downcast),
name,
getSignature(destructor),
reinterpret_cast<GenericFunction>(destructor));
}

64. Reverse-engineering
FTW

65. // Implemented in JavaScript. Don't call these directly.
extern "C" {
...
void _embind_register_class(
...
);
...
}

66. // Implemented in JavaScript. Don't call these directly.
extern "C" {
...
void _embind_register_class(
TYPEID classType,
TYPEID pointerType,
TYPEID constPointerType,
TYPEID baseClassType,
const char* getActualTypeSignature,
GenericFunction getActualType,
const char* upcastSignature,
GenericFunction upcast,
const char* downcastSignature,
GenericFunction downcast,
const char* className,
const char* destructorSignature,
GenericFunction destructor);
...
}

67. #![feature(core_intrinsics)]
::std::intrinsics::type_id::<T>()

68. #![feature(core_intrinsics)]
::std::intrinsics::type_id::<T>() as u32

69. // Implemented in JavaScript. Don't call these directly.
extern "C" {
...
void _embind_register_class(
TYPEID classType,
TYPEID pointerType,
TYPEID constPointerType,
TYPEID baseClassType,
const char* getActualTypeSignature,
GenericFunction getActualType,
const char* upcastSignature,
GenericFunction upcast,
const char* downcastSignature,
GenericFunction downcast,
const char* className,
const char* destructorSignature,
GenericFunction destructor);
...
}

70. extern fn get_actual_type<T: 'static>(arg: *const void) -> u32 {
unsafe {
type_id::<T>()
}
}

71. // Implemented in JavaScript. Don't call these directly.
extern "C" {
...
void _embind_register_class(
TYPEID classType,
TYPEID pointerType,
TYPEID constPointerType,
TYPEID baseClassType,
const char* getActualTypeSignature,
GenericFunction getActualType,
const char* upcastSignature,
GenericFunction upcast,
const char* downcastSignature,
GenericFunction downcast,
const char* className,
const char* destructorSignature,
GenericFunction destructor);
...
}

72. void smth(int x, float y, const char *z);

73. void smth(int x, float y, const char *z);
"vifi"

74. // Implemented in JavaScript. Don't call these directly.
extern "C" {
...
void _embind_register_class(
TYPEID classType,
TYPEID pointerType,
TYPEID constPointerType,
TYPEID baseClassType,
const char* getActualTypeSignature,
GenericFunction getActualType,
const char* upcastSignature,
GenericFunction upcast,
const char* downcastSignature,
GenericFunction downcast,
const char* className,
const char* destructorSignature,
GenericFunction destructor);
...
}

75. // Implemented in JavaScript. Don't call these directly.
extern "C" {
...
void _embind_register_class(
TYPEID classType,
TYPEID pointerType,
TYPEID constPointerType,
TYPEID baseClassType,
const char* getActualTypeSignature,
GenericFunction getActualType,
const char* upcastSignature,
GenericFunction upcast,
const char* downcastSignature,
GenericFunction downcast,
const char* className,
const char* destructorSignature,
GenericFunction destructor);
...
}

76. ::std::intrinsics::type_name::<T>()

77. CString::new(::std::intrinsics::type_name::<T>())
.unwrap()
.as_ptr(),

78. // Implemented in JavaScript. Don't call these directly.
extern "C" {
...
void _embind_register_class(
TYPEID classType,
TYPEID pointerType,
TYPEID constPointerType,
TYPEID baseClassType,
const char* getActualTypeSignature,
GenericFunction getActualType,
const char* upcastSignature,
GenericFunction upcast,
const char* downcastSignature,
GenericFunction downcast,
const char* className,
const char* destructorSignature,
GenericFunction destructor);
...
}

79. extern fn destructure<T: 'static>(arg: *mut void) {
unsafe {
Box::from_raw(arg as *mut T);
}
}

80. // Implemented in JavaScript. Don't call these directly.
extern "C" {
...
void _embind_register_class(
TYPEID classType,
TYPEID pointerType,
TYPEID constPointerType,
TYPEID baseClassType,
const char* getActualTypeSignature,
GenericFunction getActualType,
const char* upcastSignature,
GenericFunction upcast,
const char* downcastSignature,
GenericFunction downcast,
const char* className,
const char* destructorSignature,
GenericFunction destructor);
...
}

81. unsafe {
_embind_register_class(
type_id::<T>(),
type_id::<*mut T>(),
type_id::<*const T>(),
null(),
b"ii0".as_ptr(),
get_actual_type::<T>,
b"v0".as_ptr(),
noop,
b"v0".as_ptr(),
noop,
CString::new(type_name::<T>()).unwrap().as_ptr(),
b"vi0".as_ptr(),
destructure::<T>
)
}

82. unsafe {
_embind_register_class(
type_id::<T>(),
type_id::<*mut T>(),
type_id::<*const T>(),
null(),
cstr!("ii"),
get_actual_type::<T>,
cstr!("v"),
noop,
cstr!("v"),
noop,
CString::new(type_name::<T>()).unwrap().as_ptr(),
cstr!("vi"),
destructure::<T>
)
}

83. void _embind_register_class_constructor(
TYPEID classType,
unsigned argCount,
const TYPEID argTypes[],
const char* invokerSignature,
GenericFunction invoker,
GenericFunction constructor);

84. extern {
fn _embind_register_class_constructor(
cls_type: TypeId,
arg_count: usize,
arg_types: *const TypeId,
invoker_signature: CStr,
invoker: extern fn (
fn () -> Box<void>
) -> *mut void,
ctor: fn () -> Box<void>
);
}

85. #[allow(improper_ctypes)]
extern {
fn _embind_register_class_constructor(
cls_type: TypeId,
arg_count: usize,
arg_types: *const TypeId,
invoker_signature: CStr,
invoker: extern fn (
fn () -> Box<void>
) -> *mut void,
ctor: fn () -> Box<void>
);
}

86. extern fn invoker(f: fn () -> Box<void>) -> *mut void {
Box::into_raw(f())
}

87. unsafe {
let arg_types = [type_id::<*mut T>()];
_embind_register_class_constructor(
type_id::<T>(),
arg_types.len(),
arg_types.as_ptr(),
cstr!("ii"),
invoker,
::std::mem::transmute(
Box::<T>::default as fn () -> Box<_>
)
)
}

88. register_class::<MyStruct>();
register_class_default_ctor::<MyStruct>();

89. _embind_register_*
• void
• bool
• integer
• float
• std_string
• std_wstring
• memory_view
• function
• class
• enum
• smart_ptr
• ...

90. JavaScript static libraries

91. mergeInto(LibraryManager.library, {
my_js: function() {
alert('hi');
},
});

92. #[link_args = "--js-library rustlib.js"]
extern {
fn my_js();
}

93. mergeInto(LibraryManager.library, {
_embind_register_rust_string__deps: ['$registerType'],
_embind_register_rust_string: function(rawType) {
registerType(rawType, {
name: "&str",
'argPackAdvance': 8,
'readValueFromPointer': function (pointer) {
pointer >>= 2;
var length = HEAPU32[pointer + 1];
pointer = HEAPU32[pointer];
return Pointer_stringify(pointer, length);
}
});
},
})

94. #[link_args = "--js-library rustlib.js"]
extern {
fn _embind_register_rust_string(type_id: u32);
}
...
_embind_register_rust_string(type_id::<&str>());

95. Garbage collection

96. Garbage collection
window [1]
5

97. Garbage collection
window [2]
5
_emval_incref (aka Clone)

98. Garbage collection
window [2] "document"
5 6
_emval_take_value(...)
aka
Val::from("document").handle

99. Garbage collection
window [2] "document" document
5 6 7
_emval_get_property(...)
aka
global.get("document").handle

100. Garbage collection
window [1] document
5 7
_emval_decref(...)
aka
Drop for "document"
and
Drop for window

101. Serde + Emscripten

102. #[derive(Serialize)]
struct S {
x: &'static str,
y: u64,
z: [f64; 2]
}

103. let s = S {
x: "hello, world",
y: 42,
z: [123.456, 789.]
};
let val = s.serialize(Serializer).unwrap();

104. {
x: "hello, world",
y: 42,
z: [123.456, 789]
}

105. Speed (2.8M JSON)
native JSON.parse
serde-json
0ms 25ms 50ms 75ms 100ms

106. Speed (2.8M JSON)
via JSON
embind
0ms 27.5ms 55ms 82.5ms 110ms

107. Useful links
• https://github.com/RReverser/asmjs-experiments - safe
bindings for Embind
• https://kripken.github.io/emscripten-site/docs/
api_reference/emscripten.h.html - Emscripten APIs
• https://github.com/rust-lang/rust/pull/41409 - allow
linking JS libraries as normal libs
• https://github.com/rust-lang/cargo/pull/3954 - let Cargo
run binaries, tests, benchmarks on Emscripten target
via Node.js

108. unsafe {
get_questions()
}
Ingvar Stepanyan
@RReverser