
RISC-V 64-bit Linux in JavaScript - mbroncano
http://bellard.org/riscvemu/js/
======
alpb
This was discussed last month.
[https://news.ycombinator.com/item?id=13210711](https://news.ycombinator.com/item?id=13210711)

~~~
bobajeff
Except this is the JavaScript version.

~~~
Narishma
Which was already available at that time, as you can see some commenters
discussing it in that story.

------
bobajeff
Wow, I'm running Linux on top of RISC-V in an emulator in my browser on my
phone!

~~~
agumonkey
Babel tower reemerges from the memories of Boole

~~~
Senji
Our hubris will be our undoing.

------
chris_wot
Silly question, but is there an x86 instruction set emulator written in
JavaScript? Not even Linux, just something that takes x86 instructions into a
"virtual CPU" and lets you run the assembly statements?

~~~
kbeckmann
Not a silly question at all. I would also like to know this. Would be a fun
way to play around with assembly without the need of a tool chain etc. Maybe
even on your phone while on the train. If this doesn't exist already, I'd be
happy to start working on something like this.

~~~
pmjordan
You could probably start from here: x86 Linux running in a web browser, also
by Fabrice Bellard. [http://bellard.org/jslinux/](http://bellard.org/jslinux/)

------
netheril96
So, how do you do 64-bit arithmetic in JavaScript? Emulate with two 32-bit
number? Won't that be a huge performance bottleneck, one that cannot be
optimized by JIT?

~~~
sjrd
Yes, you emulate them with 32-bit numbers. It is a huge performance bottleneck
if you do it naively, which most compile-to-JS languages that support 64-bit
integers do. Emscripten even has a flag to let you choose between correct-but-
slow 64-bit integers and fast-but-incorrect (drops to 53 bits).

It is possible to get fast longs in JS, though, if you push your optimizer far
enough. This is what we have done in Scala.js. I wrote a paper about this, but
it is still under submission so I cannot disclose it just yet. However, I can
point to the implementation:

* The user-land implementation of `Long`s in Scala.js: [https://github.com/scala-js/scala-js/blob/master/library/src...](https://github.com/scala-js/scala-js/blob/master/library/src/main/scala/scala/scalajs/runtime/RuntimeLong.scala)

* The PR that made the performance breakthrough in the optimizer, by stack-allocating all instances of `RuntimeLong`: [https://github.com/scala-js/scala-js/pull/2488](https://github.com/scala-js/scala-js/pull/2488)

~~~
bogomipz
I just had to look this up, the limitation is that JS has a max int of 2^53?

Do you know what the reasons were for JS not implementing full 2^64?

Also I noticed theres a JS C-types that has 64 bit ints, would that not help
here?

~~~
anewhnaccount
All numbers in Javascript are IEEE 754 64-bit double precision floating point
numbers. The significand precision is 53 bits (see here
[https://en.wikipedia.org/wiki/Double-precision_floating-
poin...](https://en.wikipedia.org/wiki/Double-precision_floating-
point_format)).

~~~
bogomipz
Thanks for the clarifications.

------
ramblenode

      ~# date
    
      Thu Jan 1 00:03:09 UTC 1970

------
bogomipz
Tangentially related this is a great talk about RISC-V architecture:

[https://www.youtube.com/watch?v=vB0FC1DZqUM&feature=youtu.be](https://www.youtube.com/watch?v=vB0FC1DZqUM&feature=youtu.be)

------
Yan_Coutinho
Architeture doesn't have kernel memory protection? Seems risky...

~~~
orbifold
There is a specification of privileged extensions, I think it was stabilised
fairly recently:

[https://people.eecs.berkeley.edu/~krste/papers/riscv-priv-
sp...](https://people.eecs.berkeley.edu/~krste/papers/riscv-priv-spec-1.7.pdf)

The rocket chip generator [https://github.com/ucb-bar/rocket-
chip](https://github.com/ucb-bar/rocket-chip) and boom both have support for
it, as far as I know.

