// 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_statement(ClmStmtNode *node) { switch (node->type) { case STMT_TYPE_ASSIGN: push_expression(node->assignStmt.rhs); pop_into_lhs(node->assignStmt.lhs); break; case STMT_TYPE_CALL: push_expression(node->callExpr); break; case STMT_TYPE_CONDITIONAL: gen_conditional(node); break; case STMT_TYPE_FUNC_DEC: gen_func_dec(node); break; case STMT_TYPE_FOR_LOOP: gen_for_loop(node); break; case STMT_TYPE_WHILE_LOOP: gen_while_loop(node); break; case STMT_TYPE_PRINT: push_expression(node->printStmt.expression); gen_print_type(clm_type_of_exp(node->printStmt.expression, data.scope), node->printStmt.appendNewline); break; case STMT_TYPE_RET: // reset the stack pointer, // save the frame pointer & the stack address // push the return expression onto the stack so the stack looks like this // on return: // // return val // return type // <- esp // note: T_EAX and T_EBX are globals defined in clm_asm.h asm_mov(ESP, EBP); // reset stack pointer to above the function asm_pop("[" T_EBX "]"); // pop the old frame pointer into t_ebx asm_pop("[" T_EAX "]"); // pop the stack address of the next instruction to // execute after call finishes push_expression(node->returnExpr); asm_mov(EBP, "[" T_EBX "]"); // move the old frame pointer into ebp asm_push("[" T_EAX "]"); // push the stack address of the next instruction to // execute after call finishes asm_ret(); // return break; } }
// Сначала DE, потом HL bool pushHLDE(bool canSwap, bool self) { // Второй аргумент Place p = stack[stack.size()-2].place; // Оптимизация последовательности lxi h + xchg + lhld if(canSwap && (p==pConst || p==pStack8 || p==pStack16 || p==pConstStr || p==pBC)) { pushHL(); peekDE(/*canSwap=*/true, /*saveHL=*/true); if(!self) asm_pop(); return true; } // Если команда загрузки DE оканчивается кодом XCHG, то выгоднее DE поместить в стек последним. // DE выгоднее класть в стек последним, так как для загрузки HL освобождается регистр DE. if(!self && canSwap && lastHL!=stack.size()-1 && lastA!=stack.size()-1) { Stack x = stack.back(); stack.pop_back(); peekHL(/*saveDE=*/false); if(!self) asm_pop(); stack.push_back(x); peekDE(/*canSwap=*/true, /*saveHL=*/true); asm_pop(); return true; } // peekDE поместит значение HL в DE. Или оставит на месте. if(p==pHL && !self && canSwap) { peekDE(/*canSwap=*/true, /*saveHL=*/true); asm_pop(); asm_pop(); return false; } peekDE(/*canSwap=*/false, /*saveHL=*/lastHL!=-1 && lastHL!=stack.size()-1); asm_pop(); peekHL(/*saveDE=*/true); if(!self) asm_pop(); return false; }
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_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); }
void pushAasHL_(/*bool de*/) { peekAasHL_(); asm_pop(); }
void pushD() { peekD(); asm_pop(); }
void pushA() { peekA(); asm_pop(); }
void pushPeekHL (bool s) { peekHL(); if(!s) asm_pop(); }
void pushDE(bool canSwap, bool saveHL) { peekDE(canSwap, saveHL); asm_pop(); }
void pushBC() { peekBC(); asm_pop(); }
void pushHL() { peekHL(); asm_pop(); }
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; } }
// 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); }