about summary refs log tree commit diff stats
path: root/apps
Commit message (Collapse)AuthorAgeFilesLines
* 6083Kartik Agaram2020-03-0616-20/+20
|
* 6082 - bugfix in spilling register varsKartik Agaram2020-03-062-3/+263
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | In the process I'm starting to realize that my approach to avoiding spills isn't ideal. It works for local variables but not to avoid spilling outputs. To correctly decide whether to spill to an output register or not, we really need to analyze when a variable is live. If we don't do that, we'll end up in one of two bad situations: a) Don't spill the outermost use of an output register (or just the outermost scope in a function). This is weird because it's hard to explain to the programmer why they can overwrite a local with an output above a '{' but not below. b) Disallow overwriting entirely. This is easier to communicate but quite inconvenient. It's nice to be able to use eax for some temporary purpose before overwriting it with the final result of a function. If we instead track liveness, things are convenient and also easier to explain. If a temporary is used after the output has been written that's an obvious problem: "you clobbered the output". (It seems more reasonable to disallow multiple live ranges for the output. Once an output is written it can only be shadowed in a nested block.) That's the bad news. Now for some good news: One lovely property Mu the language has at the moment is that live ranges are guaranteed to be linear segments of code. We don't need to analyze loop-carried dependences. This means that we can decide whether a variable is live purely by scanning later statements for its use. (Defining 'register use' is slightly non-trivial; primitives must somehow specify when they read their output register.) So we don't actually need to worry about a loop reading a register with one type and writing to another type at the end of an iteration. The only way that can happen is if the write at the end was to a local variable, and we're guaranteeing that local variables will be reclaimed at the end of the iteration. So, the sequence of tasks: a) compute register liveness b1) verify that all register variables used at any point in a program are always the topmost use of that register. b2) decide whether to spill/shadow, clobber or flag an error. There's still the open question of where to attach liveness state. It can't be on a var, because liveness varies by use of the var. It can't be on a statement because we may want to know the liveness of variables not referenced in a given statement. Conceptually we want a matrix of locals x stmts (flattened). But I think it's simpler than that. We just want to know liveness at the time of variable declarations. A new register variable can be in one of three states w.r.t. its previous definition: either it's shadowing it, or it can clobber it, or there's a conflict and we need to raise an error. I think we can compute this information for each variable definition by an analysis similar to existing ones, maintaining a stack of variable definitions. The major difference is that we don't pop variables when a block ends. Details to be worked out. But when we do I hope to get these pending tests passing.
* 6079 - optimize register spillsKartik Agaram2020-03-052-23/+211
| | | | | The second var to the same register in a block doesn't need to spill. We're never going to restore the var it's shadowing.
* 6076Kartik Agaram2020-03-021-20/+21
|
* 6074Kartik Agaram2020-02-292-21/+25
|
* 6073Kartik Agaram2020-02-292-11/+28
|
* 6071 - array indexing for non-int power-of-2 typesKartik Agaram2020-02-292-11/+163
|
* 6070Kartik Agaram2020-02-2915-1/+1
|
* 6069Kartik Agaram2020-02-292-24/+24
|
* 6064Kartik Agaram2020-02-2715-2/+2
| | | | Fix CI.
* 6062Kartik Agaram2020-02-272-10/+92
|
* 6061Kartik Agaram2020-02-272-22/+22
|
* 6055 - record types and the 'get' instructionKartik Agaram2020-02-272-6/+487
| | | | | | | | | | | This is a lot of code for a single test, and it took a long time to get my data model just right. But the test coverage seems ok because it feels mostly like straight-line code. We'll see. I've also had to add a lot of prints. We really need app-level trace generation pretty urgently. That requires deciding how to turn it on/off from the commandline. And I've been reluctant to start relying on the hairy interface that is POSIX open().
* 6054Kartik Agaram2020-02-242-3/+21
|
* 6053Kartik Agaram2020-02-233-3/+3
|
* 6052Kartik Agaram2020-02-231-10/+21
|
* 6051Kartik Agaram2020-02-232-13/+25
|
* 6050Kartik Agaram2020-02-232-26/+34
|
* 6049Kartik Agaram2020-02-231-11/+11
|
* 6048Kartik Agaram2020-02-212-28/+9
|
* 6047Kartik Agaram2020-02-212-2/+2
|
* 6046Kartik Agaram2020-02-212-45/+42
| | | | One more error condition when desugaring function calls in SubX.
* 6045Kartik Agaram2020-02-211-16/+16
|
* 6044Kartik Agaram2020-02-212-68/+68
|
* 6043Kartik Agaram2020-02-212-0/+52
| | | | Test for 'index'.
* 6041 - array indexing starting to workKartik Agaram2020-02-213-10/+108
| | | | | | | | | | | | | And we're using it now in factorial.mu! In the process I had to fix a couple of bugs in pointer dereferencing. There are still some limitations: a) Indexing by a literal doesn't work yet. b) Only arrays of ints supported so far. Looking ahead, I'm not sure how I can support indexing arrays by non-literals (variables in registers) unless the element size is a power of 2.
* 6037 - first passing test for pointer lookupKartik Agaram2020-02-202-67/+192
|
* 6036Kartik Agaram2020-02-202-5/+6
|
* 6035Kartik Agaram2020-02-202-18/+18
|
* 6034Kartik Agaram2020-02-202-20/+20
|
* 6033 - save pointer lookup state while parsingKartik Agaram2020-02-202-30/+37
|
* 6032 - make room for '*' pointer lookups in stmtsKartik Agaram2020-02-202-31/+89
|
* 6031 - bugfix in selecting codegen patternKartik Agaram2020-02-202-6/+23
|
* 6030Kartik Agaram2020-02-202-11/+9
|
* 6029Kartik Agaram2020-02-202-4/+4
|
* 6028Kartik Agaram2020-02-201-4/+4
|
* 6026Kartik Agaram2020-02-181-7/+7
|
* 6024 - finally, commandline parsing in MuKartik Agaram2020-02-181-4/+22
|
* 6023 - bug: vars with both stack-offset and regKartik Agaram2020-02-182-10/+20
| | | | | This was initially disquieting; was I writing enough tests? Then I noticed I had TODOs for some missing checks.
* 6022 - initial sketch of array lengthKartik Agaram2020-02-182-0/+75
| | | | | This is a particularly large abstraction leak: SubX arrays track their lengths in bytes, and therefore Mu as well.
* 6022Kartik Agaram2020-02-182-1/+4
| | | | Forgot to actually use the new type-dispatch in commit 6017.
* 6021Kartik Agaram2020-02-182-0/+22
|
* 6020Kartik Agaram2020-02-182-55/+47
| | | | Some deduplication, though this may be a premature abstraction.
* 6019 - finish supporting all branch primitivesKartik Agaram2020-02-182-6/+233
| | | | | | | | I'd been thinking I didn't need unconditional `break` instructions, but I just realized that non-local unconditional breaks have a use. Stop over-thinking this, just support everything. The code is quite duplicated.
* 6017 - simplify type-dispatch for primitivesKartik Agaram2020-02-172-26/+66
| | | | | | | | | | | | We'll be doing type-checking in a separate phase in future. For now we need only to distinguish between literals and non-literals for x86 primitive instructions. I was tempted to support x86 set__ instructions for this change: https://c9x.me/x86/html/file_module_x86_id_288.html That will happen at some point. And I'll simplify a bunch of branches for results of predicate functions when it happens.
* 6016Kartik Agaram2020-02-171-5/+5
|
* 6014Kartik Agaram2020-02-178-70/+70
|
* 6011Kartik Agaram2020-02-162-5/+3
|
* 6010 - starting to flesh out run-testsKartik Agaram2020-02-161-1/+1
|
* 6009 - significantly cleaner lexingKartik Agaram2020-02-163-135/+34
| | | | | | | | | This cleans up a bunch of little warts that had historically accumulated because of my bull-headedness in not designing a grammar up front. Let's see if the lack of a grammar comes up again. We now require that there be no space in variable declarations between the name and the colon separating it from its type.