Lines Matching full:that

13 There is a central processing unit (CPU) that reads commands (or _instructions_) from
17 operands are _stack operands_ that reside in a special data structure called _stack_. The program
23 that the number and purpose of registers differs, too. Some nuances of working with stack may also
79 more _dispatch overhead_. Which means that the stack-based bytecode is slower by nature.
86 interpreter is very important, that's why
117 * Sometimes you might want to write directly into virtual register. e.g. for register moves (that
133 Let's take a closer look at `adda arg1, arg2`. Assume that arguments map to virtual registers on
148 It easy to see that to address virtual registers 4 and 5 we need just 3 bits which allows to encode
157 to the stack-based approach. Of course, if virtual registers have large numbers that do no fit
165 How to make sure that we benefit from the shorter encoding most of the time? An observation shows
166 that most of operations inside a function happen on local and/or temporary variables, while
167 function arguments participate as operands in a fewer number of cases. With that in mind, let's map
171 Please note also that we don't need "full-range" versions for all instructions. In case some
172 instruction lacks a wide-range form, we can prepare operands for it with moves that have all
187 One option is to make the operation _statically typed_, i.e. specify explicitly that it works only
191 Another option is to make the operation _dynamically typed_, i.e. specify that `adda ...` handles
199 It may seem that the dynamically typed approach is better for dynamically typed languages, but it
203 a number without an explicit type cast. This means that if we would like to run these two languages
217 I.e. does it mean that if `adda reg1, reg2` operates only on 64-bit integers, registers `reg1`
221 that once a value of a certain type is store into a virtual register, all operations on that value