Optimizing simple calls in a dynamically typed language?

I am playing around with some ideas for a compiled dynamically typed
language i.e. no VM.


What bugs me is that in a dynamically typed language without
primitives, code that looks like this in C:


int j;


... <code setting the value of j>


int i = j * 5 + 3;


Would usually compile to something like 2 dynamic calls, first on j
and then on the result of j * 5.


While one can discuss the extra overhead of dynamic dispatch, in this
example the C code doesn't even turn up a single function call, and
because of the dynamic dispatch there is no hope to inline the calls.


The only idea that struck me as remotely feasible would be to inline
these types manually.


So my code


i = j * 5 + 3;


would compile to something like (ignoring conversions due to int
overflow):


Id temp = IS_INT(j) ? j * 5 : call(j, "mult", 5);
Id i = IS_INT(temp) ? temp + 3 : call(temp, "add", 3);


Where IS_INT is some macro that would do some bit-check to verify that
the object can be interpreted as an int.


Aside from being hideously ugly, I am not really sure that it is a
workable solution.


This obviously touches on the whole "how do you get a dynamic language
to run as fast as C" discussion. So, does anyone have any ideas or
pointers?

Return to the comp.compilers page.
Search the comp.compilers archives again.