encounter/MWCC
1
0
Fork 0
mirror of https://git.wuffs.org/MWCC synced 2025-12-18 09:25:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

rename some stuff and use an enum for RegClass

Browse Source
This commit is contained in:
Ash Wolf
2022-12-14 01:00:56 +00:00
parent 25bab8b1fb
commit bc1321735c
28 changed files with 234 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
compiler_and_linker/unsorted/Registers.c
View File

@@ -5,12 +5,6 @@
#include "compiler/CompilerTools.h"
#include "compiler/objects.h"
// haven't checked this object file for .data stuff yet
// ONLY FOR TESTING
// this file gets kinda fucked up by the loop unroller
//#pragma opt_unroll_loops off
int used_virtual_registers[RegClassMax];
int used_nonvolatile_registers[RegClassMax];
int assignable_registers[RegClassMax];
@@ -26,6 +20,7 @@ char *register_class_name[RegClassMax];
char *register_class_format[RegClassMax];
int coloring;
int optimizing;
typedef struct ModifiedRegisters {
struct ModifiedRegisters *next;
Object *obj;
@@ -34,28 +29,27 @@ typedef struct ModifiedRegisters {
static ModifiedRegisters *mod_regs_table[128];
void init_registers(void) {
char rclass;
RegClass rclass;
int j;
for (rclass = 0; rclass < RegClassMax; rclass++) {
for (j = 0; j < RegisterMax; j++) {
reg_state[(char)rclass][j] = RegState0;
}
for (j = 0; j < RegisterMax; j++)
reg_state[rclass][j] = RegState0;
}
for (rclass = 0; rclass < RegClassMax; rclass++)
used_nonvolatile_registers[(char)rclass] = 0;
used_nonvolatile_registers[rclass] = 0;
optimizing = 1;
init_target_registers();
for (rclass = 0; rclass < RegClassMax; rclass++)
used_virtual_registers[(char)rclass] = n_real_registers[(char)rclass];
used_virtual_registers[rclass] = n_real_registers[rclass];
coloring = 1;
}
void assign_register_to_variable(Object *obj, char rclass) {
void assign_register_to_variable(Object *obj, RegClass rclass) {
VarInfo *vi;
short reg;
@@ -72,7 +66,7 @@ void assign_register_to_variable(Object *obj, char rclass) {
vi->reg = reg;
}
void retain_register_for_argument(Object *obj, char rclass, short reg) {
void retain_register_for_argument(Object *obj, RegClass rclass, short reg) {
VarInfo *vi = obj->u.var.info;
reg_state[rclass][reg] = RegState1;
vi->flags |= VarInfoFlag2;
@@ -80,7 +74,7 @@ void retain_register_for_argument(Object *obj, char rclass, short reg) {
vi->reg = reg;
}
int available_registers(char rclass) {
int available_registers(RegClass rclass) {
int i;
int count = 0;
@@ -92,7 +86,7 @@ int available_registers(char rclass) {
return count;
}
UInt32 volatile_registers(char rclass) {
UInt32 volatile_registers(RegClass rclass) {
UInt32 mask = 0;
int i;
int reg;
@@ -106,7 +100,7 @@ UInt32 volatile_registers(char rclass) {
return mask;
}
short obtain_nonvolatile_register(char rclass) {
short obtain_nonvolatile_register(RegClass rclass) {
int best = -1;
while (used_nonvolatile_registers[rclass] < n_nonvolatile_registers[rclass]) {
@@ -121,54 +115,45 @@ short obtain_nonvolatile_register(char rclass) {
}
void open_temp_registers(void) {
int rclass;
RegClass rclass;
for (rclass = 0; (char)rclass < RegClassMax; rclass++) {
int r = used_virtual_registers[(char)rclass];
//last_temporary_register[rclass] = r;
//first_temporary_register[rclass] = r;
first_temporary_register[(char)rclass] = last_temporary_register[(char)rclass] = r;
for (rclass = 0; rclass < RegClassMax; rclass++) {
int r = used_virtual_registers[rclass];
first_temporary_register[rclass] = last_temporary_register[rclass] = r;
}
/*rclass = 0;
while (rclass < RegClassMax) {
r = used_virtual_registers[(char)rclass];
last_temporary_register[(char)rclass] = r;
first_temporary_register[(char)rclass] = r;
rclass = rclass + 1;
}*/
}
void check_temp_registers(void) {
char rclass;
RegClass rclass;
if (!optimizing) {
for (rclass = 0; rclass < RegClassMax; rclass++) {
if (used_virtual_registers[(char)rclass] > last_temporary_register[(char)rclass])
last_temporary_register[(char)rclass] = used_virtual_registers[(char)rclass];
if (used_virtual_registers[(char)rclass] > 256)
used_virtual_registers[(char)rclass] = first_temporary_register[(char)rclass];
if (used_virtual_registers[rclass] > last_temporary_register[rclass])
last_temporary_register[rclass] = used_virtual_registers[rclass];
if (used_virtual_registers[rclass] > 256)
used_virtual_registers[rclass] = first_temporary_register[rclass];
}
}
}
void close_temp_registers(void) {
char rclass;
RegClass rclass;
for (rclass = 0; rclass < RegClassMax; rclass++) {
if (used_virtual_registers[(char)rclass] < last_temporary_register[(char)rclass])
used_virtual_registers[(char)rclass] = last_temporary_register[(char)rclass];
if (used_virtual_registers[rclass] < last_temporary_register[rclass])
used_virtual_registers[rclass] = last_temporary_register[rclass];
else
last_temporary_register[(char)rclass] = used_virtual_registers[(char)rclass];
last_temporary_register[rclass] = used_virtual_registers[rclass];
}
}
int count_scratch_registers(void) {
int rclass;
RegClass rclass;
int count;
count = 0;
for (rclass = 0; (char)rclass < RegClassMax; rclass++)
count += n_scratch_registers[(char)rclass];
for (rclass = 0; rclass < RegClassMax; rclass++)
count += n_scratch_registers[rclass];
return count;
}
@@ -180,19 +165,23 @@ void init_modified_registers(void) {
}
static void compute_modified_registers(UInt32 *masks) {
int rclass;
RegClass rclass;
PCodeBlock *block;
PCode *pcode;
PCodeArg *op;
int i;
for (rclass = 0; rclass < RegClassMax; rclass++)
masks[(char)rclass] = 0;
masks[rclass] = 0;
for (block = pcbasicblocks; block; block = block->nextBlock) {
for (pcode = block->firstPCode; pcode; pcode = pcode->nextPCode) {
for (i = 0; i < pcode->argCount; i++) {
if (pcode->args[i].kind == PCOp_REGISTER && pcode->args[i].data.reg.effect & EffectWrite)
masks[pcode->args[i].arg] |= 1 << pcode->args[i].data.reg.reg;
op = pcode->args;
i = pcode->argCount;
while (i--) {
if (op->kind == PCOp_REGISTER && (op->data.reg.effect & EffectWrite))
masks[op->arg] |= 1 << op->data.reg.reg;
op++;
}
}
}
@@ -204,25 +193,25 @@ void note_modified_registers(Object *obj) {
mr = galloc(sizeof(ModifiedRegisters));
mr->obj = obj;
compute_modified_registers(mr->mask);
mr->next = mod_regs_table[obj->name->hashval];
mod_regs_table[obj->name->hashval] = mr;
mr->next = mod_regs_table[obj->name->hashval & 127];
mod_regs_table[obj->name->hashval & 127] = mr;
}
void find_modified_registers(Object *obj, UInt32 *masks) {
char rclass;
RegClass rclass;
ModifiedRegisters *scan;
for (rclass = 0; rclass < RegClassMax; rclass++)
masks[(char)rclass] = 0xFFFFFFFF;
masks[rclass] = 0xFFFFFFFF;
if (CParser_HasInternalLinkage(obj)) {
for (scan = mod_regs_table[obj->name->hashval]; scan; scan = scan->next) {
for (scan = mod_regs_table[obj->name->hashval & 127]; scan; scan = scan->next) {
if (scan->obj == obj)
break;
}
if (scan) {
for (rclass = 0; rclass < RegClassMax; rclass++)
masks[(char)rclass] = scan->mask[(char)rclass];
masks[rclass] = scan->mask[rclass];
}
}
}