/* tripl/arch/x86_64/asm.c
*
* This file is part of tripl.
*
* tripl is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* tripl is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with tripl. If not, see
*/
#include
#include
#include
#include
#include
#include
static char *lbsave;
static int stack_index;
struct klist_node globvars;
static int do_funcall(char *p);
static int set_name(char *p, char *name);
const static char asm_head[] = {
" .file \"%s\"\n"
" .text\n"
" .globl _start\n"
"_start:\n"
" /* call main and exit */\n"
" call main\n"
" movq %%rax, %%rbx\n"
" movq $1, %%rax\n"
" /* exit */\n"
" int $0x80\n\n"
" .globl main\n"
/* use -x(%rbp) to access */
"main: pushq %%rbp\n"
" movq %%rsp, %%rbp\n"
};
const static char global_var[] = {
" .data\n"
" .globl %s\n"
"%s: .long %d\n"
" .text\n"
};
const static char stack_var[] = {
" movq $%d, -%d(%%rbp)\n"
};
const static char wr_stkvar[] = {
" movq $%d, -%d(%%rbp)\n"
};
const static char wr_glbvar[] = {
" movq $%d, %s(%%rip)\n"
};
const static char noarg_funcall[] = {
" call %s\n"
};
const static char funcend[] = {
" popq %%rbp\n"
" ret\n"
};
int x86_64_init_asm(void) {
stack_index = 0;
printf(asm_head, fname);
return 0;
}
int x86_64_asm_fin(void) {
printf(funcend);
return 0;
}
int x86_64_do_asm(char *p, char c) {
char *name = NULL, *save;
int out, type, attr;
lbsave = p;
switch (c) {
case '$':
++p;
_skip_spaces(p);
getword(p, &type, &out);
if (type != WORDTYPE_NAME)
exit(generic_error("'$' requires a name", lbsave, lno));
name = strndup(p, out);
p += out;
_skip_spaces(p);
getword(p, &type, &out);
if (type == WORDTYPE_KWORD) {
if (out != '=')
exit(generic_error("invalid keyword after name", lbsave, lno));
p++;
_skip_spaces(p);
getword(p, &type, &out);
}
if (type != WORDTYPE_NR) {
if (type)
exit(generic_error("'$' requires a number", lbsave, lno));
out = 0;
}
_skip_spaces(p);
_skip_word(p);
_skip_spaces(p);
attr = getattrmask(p, vardef_attrtab);
if (attr & 1) {
/* global variable */
printf(global_var, name, name, out);
__push_nr(&globvars, 0, name, attr);
}
else {
/* variables on stack */
printf(stack_var, out, stack_index << 3);
push_nr(stack_index, name, attr);
stack_index++;
}
break;
case '@':
p++;
_skip_spaces(p);
do_funcall(p);
break;
default:
save = p;
/* setting or function calling */
getword(p, &type, &out);
if (type != WORDTYPE_NAME)
exit(generic_error("unknow keyword", lbsave, lno));
name = strndup(p, out);
_skip_word(p);
_skip_spaces(p);
if (*p == '(') {
do_funcall(save);
break;
}
set_name(p, name);
free(name);
break;
}
return 0;
}
static inline struct klist_node *find_name_stack(char *name) {
struct klist_node *n;
for (n = stack.next; n != &stack; n = n->next)
if (!strcmp(n->payload, name))
return n;
return NULL;
}
static inline struct klist_node *find_name_global(char *name) {
struct klist_node *n;
for (n = globvars.next; n != &globvars; n = n->next)
if (!strcmp(n->payload, name))
return n;
return NULL;
}
static int set_name(char *p, char *name) {
int type, out;
struct klist_node *n;
/* find the name,
* first find in stack */
if ((n = find_name_stack(name))) {
if (n->xmask & 4)
exit(generic_error("variable sets attribute 'read-only'", lbsave, lno));
if (!getword(p, &type, &out))
exit(generic_error("no equal", lbsave, lno));
if (out != '=')
exit(generic_error("not a '='", lbsave, lno));
p++;
_skip_spaces(p);
if (!getword(p, &type, &out))
exit(generic_error("no value", lbsave, lno));
printf(wr_stkvar, out, n->value << 3);
return 0;
}
/* global variables */
if (name[0] != '&')
/* we need a '&' for global variables */
exit(generic_error("name not found (did you forget '&')", lbsave, lno));
if (!find_name_global(name + 1))
exit(generic_error("name not found", lbsave, lno));
_skip_word(p);
_skip_spaces(p);
if (!getword(p, &type, &out))
exit(generic_error("no equal", lbsave, lno));
if (out != '=')
exit(generic_error("not a '='", lbsave, lno));
p++;
_skip_spaces(p);
if (!getword(p, &type, &out))
exit(generic_error("no value", lbsave, lno));
printf(wr_glbvar, out, name + 1);
return 0;
}
int do_funcall(char *p) {
struct klist_node *stknr;
int out, type, n;
char *funcname, *arg;
getword(p, &type, &out);
if (type != WORDTYPE_NAME)
exit(generic_error("a function name required", lbsave, lno));
funcname = strndup(p, out);
p += out;
_skip_spaces(p);
if (*p == '(') {
p++;
_skip_spaces(p);
if (*p == ')') {
printf(noarg_funcall, funcname);
return 0;
}
}
if (*p == ';') {
printf(noarg_funcall, funcname);
return 0;
}
_skip_spaces(p);
/* get all arguments and call them */
while (getword(p, &type, &out)) {
switch (type) {
case WORDTYPE_STR:
arg = strndup(p + 1, out);
printf("string: %s\n", arg);
break;
case WORDTYPE_NAME:
arg = strndup(p, out);
stknr = find_name_stack(arg);
if (!stknr) {
printf("global variable\n");
break;
}
out = stknr->value;
/* fall through */
case WORDTYPE_NR:
printf("number %d\n", out);
break;
case WORDTYPE_KWORD:
if (out != ',' && out != '(' && out != ')')
exit(generic_error("unknow keyword after arguments", lbsave, lno));
if (out == '(' && n)
exit(generic_error("invalid '(' after arguments", lbsave, lno));
if (out == ')') {
p++;
_skip_spaces(p);
getword(p, &type, &out);
if (type)
exit(generic_error("arguments after ')'", lbsave, lno));
goto ok;
}
break;
default:
exit(generic_error("error type passing argument", lbsave, lno));
}
if (type == WORDTYPE_STR)
p += out + 2;
else if (type == WORDTYPE_KWORD) {
p++;
_skip_spaces(p);
}
else
_skip_word(p);
free(arg);
arg = NULL;
n++;
}
ok: free(funcname);
return 0;
}