ack/util/mcgg/ir.dat

# Flags:
#   S: has size (use in CONST1, CONST2, CONST4, CONST8 forms)
#   V: has no size (use in JUMP, CJUMP, RET forms)

# Simple terminals
S CONST # must be followed by float form
S CONSTF
V REG
V NOP
S LABEL
S BLOCK
V PAIR
S ANY
S LOCAL
V PHI

# Magic stack operations
S PUSH
S POP # must be followed by float form
S POPF

#... Memory operations
S LOAD # must be followed by float form
S LOADF
S STORE

# Arithemetic operations
S ADD
S SUB
S MUL
S DIV
S MOD
S NEG

S ADDF
S SUBF
S MULF
S DIVF
S NEGF

S AND
S OR
S EOR
S NOT

# Conversions
S CII1
S CII2
S CII4
S CII8

S CIU1
S CIU2
S CIU4
S CIU8

# Tristate comparisons
S COMPARES
S COMPAREU

# Boolean comparisons
S IFEQ
S IFLT
S IFLE

# Procedures
V CALL

# Flow control --- these never return
V JUMP
V CJUMPEQ
V CJUMPLT
V CJUMPLE
V RET
 
# Special
S STACKADJUST
S GETRET
S SETRET
IR codes are now owned by mcgg; ir terminals are inserted into the table during compilation (so you can refer to them). 2016-09-24 16:31:35 +00:00			`# Flags:`
			`# S: has size (use in CONST1, CONST2, CONST4, CONST8 forms)`
			`# V: has no size (use in JUMP, CJUMP, RET forms)`

			`# Simple terminals`
We're going to need some type inference after all, I think. Let's do a little for now and see how it goes. 2016-10-01 17:10:22 +00:00			`S CONST # must be followed by float form`
			`S CONSTF`
Instruction selection now happens on a shadow tree, rather than on the IR tree itself. Currently it's semantically the same but the implementation is cleaner. 2016-10-03 18:52:36 +00:00			`V REG`
			`V NOP`
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`S LABEL`
			`S BLOCK`
			`V PAIR`
			`S ANY`
			`S LOCAL`
Instruction selection now happens on a shadow tree, rather than on the IR tree itself. Currently it's semantically the same but the implementation is cleaner. 2016-10-03 18:52:36 +00:00			`V PHI`
IR codes are now owned by mcgg; ir terminals are inserted into the table during compilation (so you can refer to them). 2016-09-24 16:31:35 +00:00
			`# Magic stack operations`
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`S PUSH`
We're going to need some type inference after all, I think. Let's do a little for now and see how it goes. 2016-10-01 17:10:22 +00:00			`S POP # must be followed by float form`
			`S POPF`
Keep more data around about ir instructions. Implement a half-baked type inference routine to propagate information about floats up the tree, so we know whether to put floats into special registers as early as possible. 2016-09-26 20:12:46 +00:00
			`#... Memory operations`
We're going to need some type inference after all, I think. Let's do a little for now and see how it goes. 2016-10-01 17:10:22 +00:00			`S LOAD # must be followed by float form`
			`S LOADF`
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`S STORE`
IR codes are now owned by mcgg; ir terminals are inserted into the table during compilation (so you can refer to them). 2016-09-24 16:31:35 +00:00
			`# Arithemetic operations`
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`S ADD`
			`S SUB`
			`S MUL`
			`S DIV`
			`S MOD`
			`S NEG`
Keep more data around about ir instructions. Implement a half-baked type inference routine to propagate information about floats up the tree, so we know whether to put floats into special registers as early as possible. 2016-09-26 20:12:46 +00:00
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`S ADDF`
			`S SUBF`
			`S MULF`
			`S DIVF`
			`S NEGF`
Keep more data around about ir instructions. Implement a half-baked type inference routine to propagate information about floats up the tree, so we know whether to put floats into special registers as early as possible. 2016-09-26 20:12:46 +00:00
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`S AND`
			`S OR`
			`S EOR`
			`S NOT`
Keep more data around about ir instructions. Implement a half-baked type inference routine to propagate information about floats up the tree, so we know whether to put floats into special registers as early as possible. 2016-09-26 20:12:46 +00:00
IR codes are now owned by mcgg; ir terminals are inserted into the table during compilation (so you can refer to them). 2016-09-24 16:31:35 +00:00			`# Conversions`
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`S CII1`
			`S CII2`
			`S CII4`
			`S CII8`
Keep more data around about ir instructions. Implement a half-baked type inference routine to propagate information about floats up the tree, so we know whether to put floats into special registers as early as possible. 2016-09-26 20:12:46 +00:00
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`S CIU1`
			`S CIU2`
			`S CIU4`
			`S CIU8`
Keep more data around about ir instructions. Implement a half-baked type inference routine to propagate information about floats up the tree, so we know whether to put floats into special registers as early as possible. 2016-09-26 20:12:46 +00:00
IR codes are now owned by mcgg; ir terminals are inserted into the table during compilation (so you can refer to them). 2016-09-24 16:31:35 +00:00			`# Tristate comparisons`
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`S COMPARES`
			`S COMPAREU`
Keep more data around about ir instructions. Implement a half-baked type inference routine to propagate information about floats up the tree, so we know whether to put floats into special registers as early as possible. 2016-09-26 20:12:46 +00:00
IR codes are now owned by mcgg; ir terminals are inserted into the table during compilation (so you can refer to them). 2016-09-24 16:31:35 +00:00			`# Boolean comparisons`
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`S IFEQ`
			`S IFLT`
			`S IFLE`
Keep more data around about ir instructions. Implement a half-baked type inference routine to propagate information about floats up the tree, so we know whether to put floats into special registers as early as possible. 2016-09-26 20:12:46 +00:00
IR codes are now owned by mcgg; ir terminals are inserted into the table during compilation (so you can refer to them). 2016-09-24 16:31:35 +00:00			`# Procedures`
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`V CALL`
Keep more data around about ir instructions. Implement a half-baked type inference routine to propagate information about floats up the tree, so we know whether to put floats into special registers as early as possible. 2016-09-26 20:12:46 +00:00
IR codes are now owned by mcgg; ir terminals are inserted into the table during compilation (so you can refer to them). 2016-09-24 16:31:35 +00:00			`# Flow control --- these never return`
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`V JUMP`
			`V CJUMPEQ`
			`V CJUMPLT`
			`V CJUMPLE`
			`V RET`
IR codes are now owned by mcgg; ir terminals are inserted into the table during compilation (so you can refer to them). 2016-09-24 16:31:35 +00:00
			`# Special`
You know what, the type inference stuff is a complete red herring. What this actually needs is a more intelligent register allocator. So, remove the type inference. 2016-09-29 17:58:02 +00:00			`S STACKADJUST`
			`S GETRET`
			`S SETRET`
IR codes are now owned by mcgg; ir terminals are inserted into the table during compilation (so you can refer to them). 2016-09-24 16:31:35 +00:00