about summary refs log tree commit diff stats
path: root/mu_instructions
Commit message (Collapse)AuthorAgeFilesLines
* support checking overflow flag everywhereKartik K. Agaram2021-05-081-0/+25
|
* always check for null in 'index' instructionsKartik K. Agaram2021-05-071-3/+9
|
* always check for null in 'get' instructionsKartik K. Agaram2021-05-071-1/+5
|
* 7478Kartik Agaram2021-01-031-1/+1
|
* 7296 - rough support for printing floatsKartik Agaram2020-11-291-0/+1
| | | | No rounding yet, and we have a blunt way to decide when to start truncating.
* 7286 - mu.subx: isolate bytes from previous valuesKartik Agaram2020-11-271-0/+2
|
* 7266Kartik Agaram2020-11-171-6/+6
|
* 7261 - mu.subx: array bounds-checking doneKartik Agaram2020-11-171-8/+12
|
* 7248 - mu.subx: new primitive 'clear-object'Kartik Agaram2020-11-151-0/+3
|
* 7247Kartik Agaram2020-11-151-2/+4
|
* 7152 - 'return' instructionKartik Agaram2020-11-011-0/+11
| | | | | | https://github.com/akkartik/mu/issues/45#issuecomment-719990879, task 1. We don't have checking for it yet. Soon.
* 7150Kartik Agaram2020-10-311-0/+16
|
* 7147Kartik Agaram2020-10-311-4/+7
|
* 7146Kartik Agaram2020-10-311-86/+86
|
* 6957Kartik Agaram2020-10-051-0/+9
| | | | | | | | The final fix to the raytracing program involves rounding modes. It turns out x86 processors round floats by default, unlike C which has trained me to expect truncation. Rather than mess with the MXCSR register, I added another instruction for truncation. Now milestone 3 emits perfectly correct results.
* 6954Kartik Agaram2020-10-051-13/+13
|
* 6944Kartik Agaram2020-10-041-0/+4
|
* 6920Kartik Agaram2020-10-011-1/+1
|
* 6915 - a new family of Mu branch instructionsKartik Agaram2020-09-301-0/+6
| | | | | | The realization of commit 6916 means that we should be using jump-if-addr* after comparing floats. Which is super ugly. Let's create aliases to them called jump-if-float*.
* 6908 - compiling all floating-point operationsKartik Agaram2020-09-301-2/+2
| | | | | We don't yet support emulating these instructions in `bootstrap`. But generated binaries containing them run natively just fine.
* 6896Kartik Agaram2020-09-281-0/+77
| | | | Readme-driven development for Mu's floating-point operations.
* 6894Kartik Agaram2020-09-281-0/+9
|
* 6893Kartik Agaram2020-09-281-6/+6
|
* 6698Kartik Agaram2020-08-011-1/+1
|
* 6697Kartik Agaram2020-08-011-13/+9
|
* 6657Kartik Agaram2020-07-161-16/+0
|
* 6648 - bit-shift instructions in MuKartik Agaram2020-07-141-0/+7
| | | | I'm not happy with the names.
* 6645 - heap allocations in MuKartik Agaram2020-07-131-0/+8
| | | | | | | | - allocate var - populate var, n Both rely on the type of `var` to compute the size of the allocation. No need to repeat the name of the type like in C, C++ or Java.
* 6516 - operations on bytesKartik Agaram2020-06-131-0/+4
| | | | | | Byte-oriented addressing is only supported in a couple of instructions in SubX. As a result, variables of type 'byte' can't live on the stack, or in registers 'esi' and 'edi'.
* 6468Kartik Agaram2020-06-051-2/+2
|
* 6465Kartik Agaram2020-06-041-0/+1
|
* 6408Kartik Agaram2020-05-271-1/+2
|
* 6405Kartik Agaram2020-05-251-1/+1
|
* 6392 - 'length' instruction done in all complexityKartik Agaram2020-05-241-1/+1
|
* 6390 - return `length` in elementsKartik Agaram2020-05-241-1/+25
|
* 6389Kartik Agaram2020-05-241-9/+14
|
* 6173Kartik Agaram2020-03-271-5/+12
|
* 6170Kartik Agaram2020-03-251-3/+3
|
* 6169Kartik Agaram2020-03-251-1/+1
|
* 6164Kartik Agaram2020-03-241-2/+2
|
* 6160 - plan for safe heap accessKartik Agaram2020-03-211-2/+31
| | | | | | | | | Based on apps/handle.subx (commit 4894), but we're able to simplify it further now that we know more about the situation we find ourselves in. 6 instructions, zero pushes or pops. Before I can start building this, I need to reorganize my use of handles. They're going to be fat pointers so we can't store them in registers anymore.
* 6159Kartik Agaram2020-03-211-218/+165
|
* 6158 - standardize opcode namesKartik Agaram2020-03-211-29/+29
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | At the lowest level, SubX without syntax sugar uses names without prepositions. For example, 01 and 03 are both called 'add', irrespective of source and destination operand. Horizontal space is at a premium, and we rely on the comments at the end of each line to fully describe what is happening. Above that, however, we standardize on a slightly different naming convention across: a) SubX with syntax sugar, b) Mu, and c) the SubX code that the Mu compiler emits. Conventions, in brief: - by default, the source is on the left and destination on the right. e.g. add %eax, 1/r32/ecx ("add eax to ecx") - prepositions reverse the direction. e.g. add-to %eax, 1/r32/ecx ("add ecx to eax") subtract-from %eax, 1/r32/ecx ("subtract ecx from eax") - by default, comparisons are left to right while 'compare<-' reverses. Before, I was sometimes swapping args to make the operation more obvious, but that would complicate the code-generation of the Mu compiler, and it's nice to be able to read the output of the compiler just like hand-written code. One place where SubX differs from Mu: copy opcodes are called '<-' and '->'. Hopefully that fits with the spirit of Mu rather than the letter of the 'copy' and 'copy-to' instructions.
* 6145 - 'address' operatorKartik Agaram2020-03-141-0/+5
| | | | | This could be a can of worms, but I think I have a set of checks that will keep use of addresses type-safe.
* 6131 - operating on arrays on the stackKartik Agaram2020-03-121-1/+5
|
* 6129Kartik Agaram2020-03-111-1/+3
|
* 6097Kartik Agaram2020-03-071-2/+0
| | | | | | I thought I needed to support compute-offset with literal index, but in that case might as well just use an index literal directly. The 'index' instruction with literals already supports non-power-of-2 sizes.
* 6094 - new 'compute-offset' instructionKartik Agaram2020-03-071-3/+11
| | | | | | | | | | | | | | | | | | | | | | | If indexing into a type with power-of-2-sized elements we can access them in one instruction: x/reg1: (addr int) <- index A/reg2: (addr array int), idx/reg3: int This translates to a single instruction because x86 instructions support an addressing mode with left-shifts. For non-powers-of-2, however, we need a multiply. To keep things type-safe, it is performed like this: x/reg1: (offset T) <- compute-offset A: (addr array T), idx: int y/reg2: (addr T) <- index A, x An offset is just an int that is guaranteed to be a multiple of size-of(T). Offsets can only be used in index instructions, and the types will eventually be required to line up. In the process, I have to expand Input-size because mu.subx is growing big.
* 6060Kartik Agaram2020-02-271-11/+11
|
* 6059Kartik Agaram2020-02-271-0/+8
|
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-04 20:02:37 +0000