d0p1/ack
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
ack/mach/proto/mcg/mcg.h

117 lines
2.8 KiB
C
Raw Normal View History

Abstract out the EM reader; skeleton of the tree builder.
2016-09-17 22:02:16 +00:00
#ifndef MCG_H
#define MCG_H
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
#include "em_arith.h"
#include "em_label.h"
#include "em.h"
#include "em_comp.h"
#include "em_pseu.h"
#include "em_mnem.h"
#include "em_flag.h"
#include "em_ptyp.h"
Archival checking of the half-written IR treebuilder.
2016-09-18 21:24:54 +00:00
#include "array.h"
Refactor mcg.h as it's getting a bit big; keep track of register variables.
2016-10-01 22:30:33 +00:00
#include "imap.h"
It doesn't really make a lot of sense to have BURG nonterminal names different to register classes, so combine them. Refactor the map code.
2016-10-01 10:17:14 +00:00
#include "pmap.h"
Move fatal(), warning() and aprintf() into the new data module (because they're really useful).
2016-09-30 17:10:30 +00:00
#include "diagnostics.h"
#include "astring.h"
Archival checking of the half-written IR treebuilder.
2016-09-18 21:24:54 +00:00
#include "ir.h"
Start factoring out the hardware op code.
2016-09-25 21:29:59 +00:00
#include "mcgg.h"
#include "hop.h"
Better management of register data. Add struct hreg.
2016-10-05 19:00:28 +00:00
#include "reg.h"
Perform SSA conversion of locals. Much, *much* better code now, at least inasmuch as it looks better before register allocation. Basic blocks now know their own successors and predecessors (after a certain point in the IR processing).
2016-10-02 15:50:34 +00:00
#include "basicblock.h"
Refactor mcg.h as it's getting a bit big; keep track of register variables.
2016-10-01 22:30:33 +00:00
#include "procedure.h"
No, dammit, for register allocation I need to walk the blocks in *dominance* order. Since the dominance tree has changed when I fiddled with the graph, I need to recompute it, so factor it out of the SSA pass. Code is uglier than I'd like but at least the RET statement goes last in the generated code now.
2016-10-05 21:52:54 +00:00
#include "dominance.h"
Abstract out the EM reader; skeleton of the tree builder.
2016-09-17 22:02:16 +00:00
extern char em_pseu[][4];
extern char em_mnem[][4];
extern char em_flag[];
Archival checking of the half-written IR treebuilder.
2016-09-18 21:24:54 +00:00
enum {
SECTION_UNKNOWN = 0,
SECTION_ROM,
SECTION_DATA,
SECTION_BSS,
SECTION_TEXT
};
Store the EM code up front and build the basic block graph *before* generating the IR code. Lots more IR code.
2016-09-19 21:06:59 +00:00
struct symbol
{
Archival checking of the half-written IR treebuilder.
2016-09-18 21:24:54 +00:00
const char* name;
int section;
Procedure compilation now happens after the entire EM file has been read in (so that we can look inside data blocks which might be defined in the future... sigh, csa and csb). csa and csb no longer generate invalid IR.
2016-09-23 23:04:00 +00:00
struct procedure* proc;
Archival checking of the half-written IR treebuilder.
2016-09-18 21:24:54 +00:00
bool is_defined : 1;
bool is_exported : 1;
bool is_proc : 1;
};
Store the EM code up front and build the basic block graph *before* generating the IR code. Lots more IR code.
2016-09-19 21:06:59 +00:00
enum
{
Archival checking of the half-written IR treebuilder.
2016-09-18 21:24:54 +00:00
PARAM_NONE,
Store the EM code up front and build the basic block graph *before* generating the IR code. Lots more IR code.
2016-09-19 21:06:59 +00:00
PARAM_IVALUE,
PARAM_LVALUE,
PARAM_BVALUE,
};
Rename struct insn to struct em (throughout).
2016-09-25 10:29:03 +00:00
struct em
Store the EM code up front and build the basic block graph *before* generating the IR code. Lots more IR code.
2016-09-19 21:06:59 +00:00
{
int opcode;
int paramtype;
union {
arith ivalue;
struct {
const char* label;
arith offset;
} lvalue;
struct {
struct basicblock* left;
struct basicblock* right;
} bvalue;
} u;
};
Archival checking of the half-written IR treebuilder.
2016-09-18 21:24:54 +00:00
extern const char* aprintf(const char* fmt, ...);
Tracing cleanup. Simplified the IR code. Some more opcodes.
2016-09-21 22:15:48 +00:00
extern void tracef(char k, const char* fmt, ...);
extern bool tracing(char k);
Abstract out the EM reader; skeleton of the tree builder.
2016-09-17 22:02:16 +00:00
extern void parse_em(void);
Archival checking of the half-written IR treebuilder.
2016-09-18 21:24:54 +00:00
extern void symbol_init(void);
extern bool symbol_exists(const char* name);
extern struct symbol* symbol_get(const char* name);
extern void symbol_declare(const char* name, bool is_exported, bool is_proc);
Procedure compilation now happens after the entire EM file has been read in (so that we can look inside data blocks which might be defined in the future... sigh, csa and csb). csa and csb no longer generate invalid IR.
2016-09-23 23:04:00 +00:00
typedef bool symbol_walker_t(struct symbol* symbol, void* user);
extern struct symbol* symbol_walk(symbol_walker_t* walker, void* user);
Archival checking of the half-written IR treebuilder.
2016-09-18 21:24:54 +00:00
extern void data_label(const char* name);
extern void data_int(arith data, size_t size, bool is_ro);
extern void data_block(const uint8_t* data, size_t size, bool is_ro);
extern void data_offset(const char* label, arith offset, bool is_ro);
extern void data_bss(arith size, int init);
Abstract out the EM reader; skeleton of the tree builder.
2016-09-17 22:02:16 +00:00
extern void tb_filestart(void);
extern void tb_fileend(void);
Store the EM code up front and build the basic block graph *before* generating the IR code. Lots more IR code.
2016-09-19 21:06:59 +00:00
extern void tb_procedure(struct procedure* proc);
Refactor mcg.h as it's getting a bit big; keep track of register variables.
2016-10-01 22:30:33 +00:00
extern void tb_regvar(struct procedure* proc, arith offset, int size, int type, int priority);
Abstract out the EM reader; skeleton of the tree builder.
2016-09-17 22:02:16 +00:00
Add a pass to do critical edge splitting.
2016-10-04 21:42:00 +00:00
extern void pass_convert_locals_to_ssa(struct procedure* proc);
Each pass now lives in its own source file; much cleaner.
2016-09-23 19:07:16 +00:00
extern void pass_convert_stack_ops(struct procedure* proc);
Replaced the block splicer with a trivial block eliminator (which rewrites jumps to blocks which contain only a jump). Don't bother storing the bb graph in the ir nodes; we can find it on demand by walking the tree instead --- slower, but much easier to understand and more robust. Added a terrible map library.
2016-09-23 21:59:15 +00:00
extern void pass_eliminate_trivial_blocks(struct procedure* proc);
Add a pass to do critical edge splitting.
2016-10-04 21:42:00 +00:00
extern void pass_group_irs(struct procedure* proc);
Some instruction selection is now happening.
2016-09-24 20:46:08 +00:00
extern void pass_instruction_selector(struct procedure* proc);
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
extern void pass_promote_float_ops(struct procedure* proc);
The register allocator is really a pass, so arrange the code like one.
2016-10-05 21:55:38 +00:00
extern void pass_register_allocator(struct procedure* proc);
Add a pass to do critical edge splitting.
2016-10-04 21:42:00 +00:00
extern void pass_remove_dead_blocks(struct procedure* proc);
extern void pass_split_critical_edges(struct procedure* proc);
Add a bodged in algorithm for converting basic block communication from stacked variables to SSA. Also add dead block removal and block splicing. IR code is much better now.
2016-09-22 21:19:29 +00:00
Abstract out the EM reader; skeleton of the tree builder.
2016-09-17 22:02:16 +00:00
#endif
/* vim: set sw=4 ts=4 expandtab : */
Reference in a new issue Copy permalink