\subsection{Limitations}

Emscripten's compilation approach, as has been described in this Section so far,

is to generate `natural' JavaScript, as close as possible to normal JavaScript

on the web, so that modern JavaScript engines perform well on it. In particular,

we try to generate `normal' JavaScript operations, like regular addition and

multiplication and so forth. This is a very

different approach than, say, emulating a CPU on a low level, or for the case

of LLVM, writing an LLVM bitcode interpreter in JavaScript. The latter approach

has the benefit of being able to run virtually any compiled code, at the cost

of speed, whereas Emscripten makes a tradeoff in the other direction. We will

now give a summary of some of the limitations of Emscripten's approach.

\begin{itemize}

\item \textbf{64-bit Integers}: JavaScript numbers are all 64-bit doubles, with engines

typically implementing them as 32-bit integers where possible for speed.

A consequence of this is that it is impossible to directly implement

64-bit integers in JavaScript, as integer values larger than 32 bits will become doubles,

with only 53 bits for the significand. Thus, when Emscripten uses normal

JavaScript addition and so forth for 64-bit integers, it runs the risk of

rounding effects. This could be solved by emulating 64-bit integers,

but it would be much slower than native code.

\item \textbf{Multithreading}: JavaScript has Web Workers, which are additional

threads (or processes) that communicate via message passing. There is no

shared state in this model, which means that it is not directly possible

to compile multithreaded code in C++ into JavaScript. A partial solution

could be to emulate threads, without Workers, by manually controlling

which blocks of code run (a variation on the switch in a loop construction

mentioned earlier) and manually switching between threads every so often.

However, in that case there would not be any utilization

of additional CPU cores, and furthermore performance would be slow due to not

using normal JavaScript loops.

\end{itemize}

Perhaps the largest future goal of Emscripten is to improve the performance of