// pops a matrix that is on the stack, into the variable contained in node
static void pop_into_whole_matrix(ClmExpNode *node) {
// TODO case where matrix on stack is actually a pointer
char index_str[64];
ClmSymbol *var = clm_scope_find(data.scope, node->indExp.id);
char cmp_label[LABEL_SIZE];
char end_label[LABEL_SIZE];
next_label(cmp_label);
next_label(end_label);
asm_pop(EAX); // pop type
asm_pop(ECX); // pop rows
asm_pop(EBX); // pop cols;
// todo assert rows == A.rows && cols == A.cols
asm_imul(ECX, EBX); // ecx now contains rows * cols
asm_dec(ECX);
asm_label(cmp_label);
asm_cmp(ECX, "0");
asm_jmp_l(end_label);
asm_mov(EAX, ECX);
asm_imul(EAX, "4");
load_var_location(var, index_str, 12, EAX);
asm_pop(index_str);
asm_dec(ECX);
asm_jmp(cmp_label);
asm_label(end_label);
}
static void gen_conditional(ClmStmtNode *node) {
push_expression(node->conditionStmt.condition);
if (node->conditionStmt.falseBody == NULL) {
char end_label[LABEL_SIZE];
next_label(end_label);
ClmScope *trueScope =
clm_scope_find_child(data.scope, node->conditionStmt.trueBody);
asm_pop(EAX);
asm_cmp(EAX, "1");
asm_jmp_neq(end_label);
data.scope = trueScope;
gen_statements(node->conditionStmt.trueBody);
asm_label(end_label);
data.scope = trueScope->parent;
} else {
char end_label[LABEL_SIZE];
char false_label[LABEL_SIZE];
next_label(end_label);
next_label(false_label);
ClmScope *trueScope =
clm_scope_find_child(data.scope, node->conditionStmt.trueBody);
ClmScope *falseScope =
clm_scope_find_child(data.scope, node->conditionStmt.falseBody);
asm_pop(EAX);
asm_cmp(EAX, "1");
asm_jmp_neq(false_label);
data.scope = trueScope;
gen_statements(node->conditionStmt.trueBody);
asm_jmp(end_label);
asm_label(false_label);
data.scope = falseScope;
gen_statements(node->conditionStmt.falseBody);
asm_label(end_label);
data.scope = falseScope->parent;
}
}
static void gen_while_loop(ClmStmtNode *node) {
char cmp_label[LABEL_SIZE];
char end_label[LABEL_SIZE];
next_label(cmp_label);
next_label(end_label);
asm_label(cmp_label);
// don't need to store this - just evaulate every loop
push_expression(node->whileLoopStmt.condition);
pop_int_into(EAX);
asm_cmp(EAX, "0");
asm_jmp_eq(end_label);
gen_statements(node->whileLoopStmt.body);
asm_jmp(cmp_label);
asm_label(end_label);
}
static void gen_for_loop(ClmStmtNode *node) {
char cmp_label[LABEL_SIZE];
char end_label[LABEL_SIZE];
next_label(cmp_label);
next_label(end_label);
ClmSymbol *var = clm_scope_find(data.scope, node->forLoopStmt.varId);
char loop_var[32];
load_var_location(var, loop_var, 4, NULL);
// don't need to store this - just evaluate and put into loop var
push_expression(node->forLoopStmt.start);
pop_int_into(loop_var);
asm_label(cmp_label);
// don't need to store this - just evaulate every loop
push_expression(node->forLoopStmt.end);
pop_int_into(EAX);
asm_cmp(loop_var, EAX);
asm_jmp_g(end_label);
gen_statements(node->forLoopStmt.body);
if (node->forLoopStmt.delta->type == EXP_TYPE_INT &&
node->forLoopStmt.delta->ival == 1) {
asm_inc(loop_var);
} else if (node->forLoopStmt.delta->type == EXP_TYPE_INT &&
node->forLoopStmt.delta->ival == -1) {
asm_dec(loop_var);
} else if (node->forLoopStmt.delta->type == EXP_TYPE_INT) {
asm_add_i(loop_var, node->forLoopStmt.delta->ival);
} else {
push_expression(node->forLoopStmt.delta);
asm_pop(EAX);
asm_add(loop_var, EAX);
}
asm_jmp(cmp_label);
asm_label(end_label);
}
// pushes a matrix identified by the node onto the stack
static void push_whole_matrix(ClmExpNode *node) {
// TODO case where matrix on stack is actually a pointer
char index_str[64];
ClmSymbol *var = clm_scope_find(data.scope, node->indExp.id);
char cmp_label[LABEL_SIZE];
char end_label[LABEL_SIZE];
next_label(cmp_label);
next_label(end_label);
LOAD_COLS(var, index_str);
asm_mov(EDX, index_str); // edx = cols
LOAD_ROWS(var, index_str);
asm_mov(EBX, index_str); // ebx = rows
asm_mov(ECX, EBX);
asm_imul(ECX, EDX);
asm_dec(ECX); // ecx = rows * cols - 1
asm_label(cmp_label);
asm_cmp(ECX, "0");
asm_jmp_l(end_label);
asm_mov(EAX, ECX);
asm_imul(EAX, "4");
load_var_location(var, index_str, 12, EAX);
asm_push(index_str);
asm_dec(ECX);
asm_jmp(cmp_label);
asm_label(end_label);
// push type info
asm_push(EDX); // cols
asm_push(EBX); // rows
asm_push_const_i((int)CLM_TYPE_MATRIX);
}
void run() {
while (true) {
//usleep(2);
//usleep(50000); //0.05 seconds
/*debug_machine_print(*this);
getch(true);
cout << endl;*/
instr_ptr++;
//cout << instr_ptr << endl;
if (!mem[instr_ptr]) err("Bad instruction");
instr.uint64 = mem[instr_ptr];
Op op = Op(instr.o);
OpLayout layout = op.getLayout();
OpType type = op.getType();
switch (type) {
case OpType::NOP:
continue;
break;
case OpType::HALT:
return;
break;
case OpType::MOV: {
apply(op, [&](void* a, void* b, u8 size) {
memcpy(a, b, size);
//*a = *b;
});
break;
}
case OpType::PUSH: {
apply(op, [&](void* val, void* unused, u8 size) {
memcpy(&mem[stack_ptr++], val, size);
});
break;
}
case OpType::POP: {
apply(op, [&](void* val, void* unused, u8 size) {
assert(layout == OpLayout::R);
//memcpy(&r[*(u16*)val], &mem[stack_ptr--], size);
memcpy(val, &mem[(stack_ptr--)-1], size);
});
break;
}
case OpType::INT: {
assert(layout == OpLayout::C);
u8 cmd = instr.c;
switch (cmd) {
case 0:
usleep(r[0]);
break;
case 1:
cout << (char)r[0];
break;
case 2:
r[0] = getch(false);
break;
default:
err("interrupt not implemented");
cout << cmd;
break;
}
break;
}
case OpType::JMP: {
apply(op, [&](void* val, void* unused, u8 size) {
//KK TODO assert(layout == OpLayout::M);
assert(layout == OpLayout::C || layout == OpLayout::R);
instr_ptr = *((u16*)val);
});
break;
}
case OpType::CMP: {
apply(op, [&](void* a, void* b, u8 size) {
cmp_result = asm_cmp(a, b, size);
});
break;
}
case OpType::JE: {
apply(op, [&](void* val, void* unused, u8 size) {
assert(layout == OpLayout::C);
if (cmp_result == 4)
err("jump without previous cmp");
if (cmp_result == 0)
instr_ptr = *((u16*)val);
});
break;
}
case OpType::SUB: {
assert(layout == OpLayout::RC); //temporary only for fib
apply(op, [&](void* a, void* b, u8 size) {
assert(size == 4);
*(u64*)a =(u64) *(u32*)a - *(u32*)b;
});
break;
}
case OpType::ADD: {
assert(layout == OpLayout::RR); //temporary only for fib
apply(op, [&](void* a, void* b, u8 size) {
assert(size == 8);
*(u64*)a =(u64) *(u64*)a + *(u64*)b;
});
break;
}
default:
op.print();
err("Command not implemented");
break;
}
}
}
static void gen_func_dec(ClmStmtNode *node) {
int i;
char func_label[LABEL_SIZE];
sprintf(func_label, "_%s", node->funcDecStmt.name);
ClmScope *funcScope = clm_scope_find_child(data.scope, node);
asm_label(func_label);
asm_push(EBP);
asm_mov(EBP, ESP);
int local_var_size = 2 * 4 * (funcScope->symbols->length -
node->funcDecStmt.parameters->length);
char local_var_size_str[32];
sprintf(local_var_size_str, "%d", local_var_size);
asm_sub(ESP, local_var_size_str);
// each local var has 2 slots on the stack, their type and the value
// for matrices, the value is a pointer to the location on the stack
// these are all declared below the local variables
ClmSymbol *sym;
ClmExpNode *dec;
char cmp_label[LABEL_SIZE];
char end_label[LABEL_SIZE];
char index_str[32];
for (i = 0; i < funcScope->symbols->length; i++) {
sym = funcScope->symbols->data[i];
dec = sym->declaration;
if (sym->location == LOCATION_PARAMETER)
continue;
// setting the type of the local var
load_var_location(sym, index_str, 0, NULL);
asm_mov_i(index_str, (int)sym->type);
// setting the value of the local var
load_var_location(sym, index_str, 4, NULL);
asm_mov_i(index_str, 0);
if (sym->type == CLM_TYPE_MATRIX) {
// TODO what does this do? does it work?
next_label(cmp_label);
next_label(end_label);
gen_exp_size(dec);
asm_pop(EAX); // eax contains num of rows
asm_pop(EBX); // ebx contains num of cols
asm_mov(ECX, EAX);
asm_imul(ECX, EBX);
asm_label(cmp_label);
asm_dec(ECX);
asm_cmp(ECX, "0");
asm_jmp_eq(end_label);
asm_push_const_i(0);
asm_jmp(cmp_label);
asm_label(end_label);
asm_push(EBX); // cols
// setting the pointer to point at the rows
// note: push changes the value at esp and THEN
// decrements it
load_var_location(sym, index_str, 4, NULL);
asm_mov(index_str, ESP);
asm_push(EAX); // rows
}
}
// TODO figure out strings though!
data.inFunction = 1;
data.scope = funcScope;
gen_statements(node->funcDecStmt.body);
data.scope = funcScope->parent;
data.inFunction = 0;
if (node->funcDecStmt.returnSize.rows == -1) {
// no return value!
asm_mov(ESP, EBP);
asm_pop(EBP);
}
asm_ret();
}
// stack should look like this:
// val
// type
static void push_expression(ClmExpNode *node) {
if (node == NULL)
return;
ClmType expression_type = clm_type_of_exp(node, data.scope);
switch (node->type) {
case EXP_TYPE_INT:
asm_push_const_i(node->ival);
asm_push_const_i((int)expression_type);
break;
case EXP_TYPE_FLOAT:
asm_push_const_f(node->fval);
asm_push_const_i((int)expression_type);
break;
case EXP_TYPE_STRING:
// TODO push a string onto the stack
break;
case EXP_TYPE_ARITH: {
ClmType right_type = clm_type_of_exp(node->arithExp.right, data.scope);
ClmType left_type = clm_type_of_exp(node->arithExp.left, data.scope);
if (left_type == CLM_TYPE_MATRIX && clm_type_is_number(right_type)) {
// here the only ops are mul & div... we are scaling matrix
// gen left and then right here... if we don't then we have
// int val
// int type
// matrix
// cols
// rows
// matrix type
// and we have to pop the int after we generate the value... which is hard
// and since we are multiplying the matrix in place, it would be easiest
// to
// gen the matrix first and then the int, so we just have to pop two
// values
// in total
push_expression(node->arithExp.left);
asm_mov(EDX, ESP);
push_expression(node->arithExp.right);
gen_arith(node);
} else {
push_expression(node->arithExp.right);
asm_mov(EDX, ESP);
push_expression(node->arithExp.left);
gen_arith(node);
}
break;
}
case EXP_TYPE_BOOL:
push_expression(node->boolExp.right);
asm_mov(EDX, ESP);
push_expression(node->boolExp.left);
gen_bool(node);
break;
case EXP_TYPE_CALL: {
// first push everything thats not a matrix... and for matrices push a pointer
int tempStartID = data.temporaryID;
int i;
ClmExpNode *param;
char temporary[256];
// first for any matrices that are parameters that will be pushed through
// the stack, push them on the stack and save their location into a temporary
// global
for (i = node->callExp.params->length - 1; i >= 0; i--) {
param = node->callExp.params->data[i];
if(param->type == CLM_TYPE_MATRIX){
ClmLocation location = clm_location_of_exp(param, data.scope);
switch(location){
case LOCATION_STACK:
push_expression(param);
next_temporary(temporary);
asm_mov(temporary, ESP);
break;
default:
break;
}
}
}
// then push every expression.. when we get to a matrix, push the pointer
// to its location
int tempOffset = 1;
char index_str[256];
for (i = node->callExp.params->length - 1; i >= 0; i--) {
param = node->callExp.params->data[i];
if(param->type == CLM_TYPE_MATRIX){
ClmLocation location = clm_location_of_exp(param, data.scope);
switch(location){
case LOCATION_STACK:
sprintf(temporary, "dword [temporary%d]", tempStartID + tempOffset);
asm_push(temporary);
tempOffset++;
break;
default:
{
// the only way its a matrix and not on the stack is if its an
// ind exp with no indices
ClmSymbol *symbol = clm_scope_find(data.scope, param->indExp.id);
load_var_location(symbol, index_str, 0, NULL);
asm_push(index_str);
break;
}
}
asm_push_const_i((int) CLM_TYPE_MATRIX);
}else{
push_expression(param);
}
}
asm_call(node->callExp.name);
// TODO pop off arguments from the stack
break;
}
case EXP_TYPE_INDEX:
push_index(node);
break;
case EXP_TYPE_MAT_DEC: {
int i;
if (node->matDecExp.arr != NULL) {
for (i = node->matDecExp.length - 1; i >= 0; i--) {
// TODO... push f or push i?
asm_push_const_i((int)node->matDecExp.arr[i]);
}
asm_push_const_i(node->matDecExp.size.cols);
asm_push_const_i(node->matDecExp.size.rows);
asm_push_const_i((int)CLM_TYPE_MATRIX);
} else {
// push a matrix onto the stack with all 0s
char cmp_label[LABEL_SIZE];
char end_label[LABEL_SIZE];
next_label(cmp_label);
next_label(end_label);
gen_exp_size(node);
asm_pop(EAX); // # rows
asm_pop(EBX); // # cols
asm_mov(ECX, EAX);
asm_imul(ECX, EBX);
asm_dec(ECX);
asm_label(cmp_label);
asm_cmp(ECX, "0");
asm_jmp_l(end_label);
asm_push_const_i(0);
asm_dec(ECX);
asm_jmp(cmp_label);
asm_label(end_label);
asm_push(EBX);
asm_push(EAX);
asm_push_const_i((int)CLM_TYPE_MATRIX);
}
break;
}
case EXP_TYPE_PARAM:
break;
case EXP_TYPE_UNARY:
push_expression(node->unaryExp.node);
gen_unary(node);
break;
}
}
// pushes a row or col of the matrix identified by node onto the stack
static void push_row_or_col(ClmExpNode *node) {
// TODO case where matrix on stack is actually a pointer
char index_str[64];
ClmSymbol *var = clm_scope_find(data.scope, node->indExp.id);
char cmp_label[LABEL_SIZE];
char end_label[LABEL_SIZE];
next_label(cmp_label);
next_label(end_label);
// put index value into EDX
if(node->indExp.rowIndex != NULL){
gen_index_into(EDX, node->indExp.rowIndex);
}else{
gen_index_into(EDX, node->indExp.colIndex);
}
if (node->indExp.rowIndex != NULL) {
/*
push A[x,]
for i in A.cols,-1..1 do
push A[x * A.cols + i]
end
*/
LOAD_COLS(var, index_str);
asm_mov(ECX, index_str);
asm_imul(EDX, ECX);
asm_dec(ECX);
asm_label(cmp_label);
asm_cmp(ECX, "0");
asm_jmp_l(end_label);
asm_mov(EAX, EDX);
asm_add(EAX, ECX); // eax = rowIndex * A.cols + i
asm_imul(EAX, "4");
load_var_location(var, index_str, 12, EAX);
asm_push(index_str);
} else {
/*
push A[,y]
for i in A.rows,-1..1 do
push A[i * A.cols + y]
end
*/
LOAD_ROWS(var, index_str);
asm_mov(ECX, index_str);
asm_dec(ECX);
asm_label(cmp_label);
asm_cmp(ECX, "0");
asm_jmp_l(end_label);
asm_mov(EAX, ECX);
asm_imul(EAX, index_str);
asm_add(EAX, EDX); // eax = i * A.cols + y
asm_imul(EAX, "4");
load_var_location(var, index_str, 12, EAX);
asm_push(index_str);
}
asm_inc(ECX);
asm_jmp(cmp_label);
asm_label(end_label);
}
// pops a matrix from the stack into a row or column of a matrix identified by
// node
static void pop_into_row_or_col(ClmExpNode *node) {
// TODO case where matrix on stack is actually a pointer
char index_str[64];
ClmSymbol *var = clm_scope_find(data.scope, node->indExp.id);
char cmp_label[LABEL_SIZE];
char end_label[LABEL_SIZE];
next_label(cmp_label);
next_label(end_label);
// put index value into EDX
if(node->indExp.rowIndex != NULL){
gen_index_into(EDX, node->indExp.rowIndex);
}else{
gen_index_into(EDX, node->indExp.colIndex);
}
asm_pop(EAX); // pop type
asm_pop(EAX); // pop rows
asm_pop(EBX); // pop cols
// todo assert rows == A.rows or cols == A.cols
asm_mov(ECX, "0");
if (node->indExp.rowIndex != NULL) {
/*
A[x,]
for i in 1..A.cols do
A[x * A.cols + i] = pop
end
*/
LOAD_COLS(var, index_str);
asm_imul(EDX, index_str);
asm_label(cmp_label);
asm_cmp(ECX, index_str);
asm_jmp_eq(end_label);
asm_mov(EAX, EDX);
asm_add(EAX, ECX); // eax now contains rowIndex * A.cols + i
asm_imul(EAX, "4");
load_var_location(var, index_str, 12, EAX);
asm_pop(index_str);
} else {
/*
A[,y]
for i in 1..A.rows do
A[i * A.cols + y] = pop
end
*/
LOAD_ROWS(var, index_str);
asm_label(cmp_label);
asm_cmp(ECX, index_str);
asm_jmp_eq(end_label);
asm_mov(EAX, ECX);
asm_imul(EAX, index_str);
asm_add(EAX, EDX);
asm_imul(EAX, "4");
load_var_location(var, index_str, 12, EAX);
asm_pop(index_str);
}
asm_inc(ECX);
asm_jmp(cmp_label);
asm_label(end_label);
}