// 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);
}
void gen_stmt_for(stmt *s)
{
char *lbl_test = asm_label_flow("for_test");
/* don't else-if, possible to have both (comma-exp for init) */
if(s->flow->for_init){
gen_expr(s->flow->for_init, s->flow->for_init_symtab);
asm_temp(1, "pop rax ; unused for init");
}
asm_label(lbl_test);
if(s->flow->for_while){
gen_expr(s->flow->for_while, s->flow->for_init_symtab);
asm_temp(1, "pop rax");
asm_temp(1, "test rax, rax");
asm_temp(1, "jz %s", s->lbl_break);
}
gen_stmt(s->lhs);
asm_label(s->lbl_continue);
if(s->flow->for_inc){
gen_expr(s->flow->for_inc, s->flow->for_init_symtab);
asm_temp(1, "pop rax ; unused for inc");
}
asm_temp(1, "jmp %s", lbl_test);
asm_label(s->lbl_break);
free(lbl_test);
}
void gen_expr_if(expr *e, symtable *stab)
{
char *lblfin, *lblelse;
lblfin = asm_label_code("ifexpa");
gen_expr(e->expr, stab);
if(e->lhs){
lblelse = asm_label_code("ifexpb");
asm_temp(1, "pop rax");
asm_temp(1, "test rax, rax");
asm_temp(1, "jz %s", lblelse);
gen_expr(e->lhs, stab);
asm_temp(1, "jmp %s", lblfin);
asm_label(lblelse);
}else{
asm_temp(1, "mov rax, [rsp] ; save for ?:");
asm_temp(1, "test rax, rax");
asm_temp(1, "jnz %s", lblfin);
asm_temp(1, "pop rax ; discard lhs");
}
gen_expr(e->rhs, stab);
asm_label(lblfin);
if(e->lhs)
free(lblelse);
free(lblfin);
}
void gen_stmt_do(stmt *s)
{
char *begin = asm_label_flow("do_start");
asm_label(begin);
gen_stmt(s->lhs);
asm_label(s->lbl_continue);
gen_expr(s->expr, s->symtab);
asm_temp(1, "pop rax");
asm_temp(1, "test rax, rax");
asm_temp(1, "jnz %s", begin);
asm_label(s->lbl_break);
free(begin);
}
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_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;
}
}
void gen_stmt_if(stmt *s)
{
char *lbl_else = asm_label_code("else");
char *lbl_fi = asm_label_code("fi");
gen_expr(s->expr, s->symtab);
asm_temp(1, "pop rax");
asm_temp(1, "test rax, rax");
asm_temp(1, "jz %s", lbl_else);
gen_stmt(s->lhs);
asm_temp(1, "jmp %s", lbl_fi);
asm_label(lbl_else);
if(s->rhs)
gen_stmt(s->rhs);
asm_label(lbl_fi);
free(lbl_else);
free(lbl_fi);
}
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);
}
TCA emitCallToExit(CodeBlock& cb) {
X64Assembler a { cb };
// Emit a byte of padding. This is a kind of hacky way to avoid
// hitting an assert in recordGdbStub when we call it with stub - 1
// as the start address.
a.emitNop(1);
auto const start = a.frontier();
if (RuntimeOption::EvalHHIRGenerateAsserts) {
Label ok;
a.emitImmReg(uintptr_t(enterTCExit), reg::rax);
a.cmpq(reg::rax, *rsp());
a.je8 (ok);
a.ud2();
asm_label(a, ok);
}
// Emulate a ret to enterTCExit without actually doing one to avoid
// unbalancing the return stack buffer. The call from enterTCHelper() that
// got us into the TC was popped off the RSB by the ret that got us to this
// stub.
a.addq(8, rsp());
if (a.jmpDeltaFits(TCA(enterTCExit))) {
a.jmp(TCA(enterTCExit));
} else {
// can't do a near jmp and a rip-relative load/jmp would require threading
// through extra state to allocate a literal. use an indirect jump through
// a register
a.emitImmReg(uintptr_t(enterTCExit), reg::rax);
a.jmp(reg::rax);
}
// On a backtrace, gdb tries to locate the calling frame at address
// returnRIP-1. However, for the first VM frame, there is no code at
// returnRIP-1, since the AR was set up manually. For this frame,
// record the tracelet address as starting from this callToExit-1,
// so gdb does not barf.
return start;
}
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);
}
void gen_stmt_label(stmt *s)
{
asm_label(s->expr->spel);
gen_stmt(s->lhs); /* the code-part of the compound stmtement */
}
/* Entry point for the assembler. code_ref is assumed to be attached
to the gc. */
size_t asm_string(gc_type *gc, char *str, uint8_t **code_ref) {
yyscan_t scanner = 0;
op_type token = 0;
buffer_type *buf = 0;
hashtable_type *labels = 0;
jump_type *jump_list = 0;
size_t length = 0;
gc_register_root(gc, &buf);
gc_register_root(gc, &labels);
gc_register_root(gc, (void **)&jump_list);
/* create an output buffer */
buffer_create(gc, &buf);
hash_create_string(gc, &labels);
yylex_init(&scanner);
/* yyset_debug(1, scanner); */
/* set the scanners input */
yy_scan_string(str, scanner);
/* match until there is nothing left to match */
while((token = yylex(scanner)) != END_OF_FILE) {
/* Handle individual tokens */
switch((int)token) {
case OP_LIT_FIXNUM:
asm_lit_fixnum(buf, scanner);
break;
case OP_LIT_CHAR:
asm_lit_char(buf, scanner);
break;
case STRING_START_TOKEN:
EMIT(buf, OP_LIT_STRING, 1);
asm_lit_string(buf, scanner);
break;
case SYMBOL_START_TOKEN:
EMIT(buf, OP_LIT_SYMBOL, 1);
asm_lit_string(buf, scanner);
break;
case OP_JMP:
case OP_JNF:
case OP_CALL:
case OP_PROC:
case OP_CONTINUE:
EMIT(buf, token, 1); /* emit the jump operation */
asm_jump(gc, buf, scanner, &jump_list);
break;
case LABEL_TOKEN:
asm_label(gc, buf, labels, get_text(scanner));
break;
/* All otherwise not defined tokens are
their opcode */
default:
EMIT(buf, token, 1);
break;
}
}
yylex_destroy(scanner);
/* build a code_ref */
length = buffer_size(buf);
/* *code_ref = gc_alloc(gc, 0, length); */
gc_alloc(gc, 0, length, (void **)code_ref);
length = buffer_read(buf, *code_ref, length);
/* replace jump address fields */
rewrite_jumps(*code_ref, jump_list, labels);
gc_unregister_root(gc, &buf);
gc_unregister_root(gc, &labels);
gc_unregister_root(gc, (void **)&jump_list);
return length;
}
