From 67902869dbe033c80351a8e5d07bf55ed91b6c34 Mon Sep 17 00:00:00 2001 From: Bernhard Urban Date: Sun, 6 Mar 2011 14:45:52 +0000 Subject: [PATCH] arm: init from ppc --- gesamt_arm/Makefile | 48 ++++ gesamt_arm/TODO | 0 gesamt_arm/chelper.c | 97 +++++++ gesamt_arm/chelper.h | 11 + gesamt_arm/code.bfe | 392 ++++++++++++++++++++++++++ gesamt_arm/parser.y | 624 +++++++++++++++++++++++++++++++++++++++++ gesamt_arm/scanner.lex | 67 +++++ gesamt_arm/symtable.c | 149 ++++++++++ gesamt_arm/symtable.h | 26 ++ gesamt_arm/tree.c | 149 ++++++++++ gesamt_arm/tree.h | 60 ++++ 11 files changed, 1623 insertions(+) create mode 100644 gesamt_arm/Makefile create mode 100644 gesamt_arm/TODO create mode 100644 gesamt_arm/chelper.c create mode 100644 gesamt_arm/chelper.h create mode 100644 gesamt_arm/code.bfe create mode 100644 gesamt_arm/parser.y create mode 100644 gesamt_arm/scanner.lex create mode 100644 gesamt_arm/symtable.c create mode 100644 gesamt_arm/symtable.h create mode 100644 gesamt_arm/tree.c create mode 100644 gesamt_arm/tree.h diff --git a/gesamt_arm/Makefile b/gesamt_arm/Makefile new file mode 100644 index 0000000..f00f271 --- /dev/null +++ b/gesamt_arm/Makefile @@ -0,0 +1,48 @@ +SHELL := bash +NAME := gesamt_ppc +CFLAGS := -ansi -pedantic -D_GNU_SOURCE -g +OBJS := scanner.o parser.o symtable.o code.o chelper.o tree.o + +all: $(NAME) + +$(NAME): $(OBJS) + @echo " LINK $@" + @gcc -o $@ $(OBJS) -lfl + +scanner.c: oxout.l + @echo " FLEX $<" + @flex -o$@ $< + +#dirty deps ;) +%.o: %.c parser.h symtable.h chelper.h tree.h + @echo " CC $<" + @cp $< tmp.c + @gcc -c $(CFLAGS) $< #-Wall + @rm tmp.c + +parser.c: oxout.y chelper.h tree.h + @echo " YACC $<" + @yacc -t -v -d $< -o $@ + +parser.h: parser.c + +oxout.y oxout.l: parser.y scanner.lex + @echo " OX $^" + @ox $^ + +%.c: %.bfe chelper.h tree.h + @echo " IBURG $<" + @bfe < $< | iburg > $@ + +.PHONY: clean +clean: + rm -f $(NAME) $(OBJS) scanner.c parser.{h,c,output} oxout.{y,l,h} code.c + +1test: + ~/test/scripts/modlvatest_$(NAME).sh 2>&1 + +lvatest: + /usr/ftp/pub/ublu/test/$(NAME)/test 2>&1 + +bench: + ~/test/scripts/bench.sh $(NAME) diff --git a/gesamt_arm/TODO b/gesamt_arm/TODO new file mode 100644 index 0000000..e69de29 diff --git a/gesamt_arm/chelper.c b/gesamt_arm/chelper.c new file mode 100644 index 0000000..2e736ea --- /dev/null +++ b/gesamt_arm/chelper.c @@ -0,0 +1,97 @@ +#include +#include +#include +#include "chelper.h" +#include "tree.h" + +#if 0 +#define DDCHELP +#endif + +#define REGLEN 5 +static char *regsppc[] = {"14", "15", "16", "17", "18"}; + +/* ja, dirty.. */ +static char *akt_func_name = (char*) NULL; +static char need_stack = 0; + +void func_header(char *s, int vars, int parms, int call) +{ + printf("\t.globl %1$s\n\t.type %1$s, @function\n%1$s:\n", s); + printf("\t#vars: %i, parms: %i, call(bool): %i\n", vars, parms, call); + akt_func_name = s; + + need_stack = (vars || parms) && call; + if(need_stack) { + /* save the link register */ + printf("\tmflr 0; stw 0,-8(1)\n"); + /* create the stack */ + printf("\tstwu 1, -80(1)\n"); + } +} + +char *get_func_name(void) +{ + return akt_func_name; +} + +void func_footer(void) +{ + if(need_stack) { + /* remove stack frame */ + printf("\taddi 1,1,80\n"); + /* restore link register */ + printf("\tlwz 0,-8(1); mtlr 0\n"); + } + printf("\tblr\n\n\n"); +} + +void move(char *src, char *dst) +{ + if(src == (char*) NULL) return; + if(strcmp(src,dst) != 0) { + printf("\tmr %s,%s\n", dst, src); + } +} + +void moveimm(long imm, char *dst) +{ + if((imm > 65536-1) || (imm < -65536)) { + /* high word */ + printf("\tlis %s,%d@ha\n", dst, imm); + /* low word */ + printf("\taddi %s,%s,%d@l\n", dst, dst, imm); + } else { + /* just low word */ + printf("\tli %s,%d@l\n", dst, imm); + } +} + +char *next_reg(char *s, int params) +{ + int i = 0; + if (s != (char*) NULL) { + while(strcmp(s, regsppc[i]) != 0) { + i = (i+1) % REGLEN; + } + i = (i+1) % REGLEN; + } +#ifdef DDCHELP + fprintf(stderr, "next_reg(): %s (bei %i parameter)\n", regsppc[i], params); +#endif + return regsppc[i]; +} + +char *reg_64to8l(char *s) +{ + fprintf(stderr, "reg_64to8l(): sollte nicht passieren\n"); + exit(4); + return ""; +} + +char *param_reg(int num) +{ + char *regs[] = {"3", "4", "5", "6", "7", "8", "9", "10"}; + return regs[num]; +} + diff --git a/gesamt_arm/chelper.h b/gesamt_arm/chelper.h new file mode 100644 index 0000000..5c8eb27 --- /dev/null +++ b/gesamt_arm/chelper.h @@ -0,0 +1,11 @@ +#ifndef __CHELPER_H +#define __CHELPER_H + +void func_header(char *s, int vars, int parms, int call); +char *get_func_name(void); +void func_footer(void); +char *next_reg(char *s, int params); +char *param_reg(int num); +char *reg_64to8l(char *s); +void move(char *src, char *dest); +#endif diff --git a/gesamt_arm/code.bfe b/gesamt_arm/code.bfe new file mode 100644 index 0000000..f97b517 --- /dev/null +++ b/gesamt_arm/code.bfe @@ -0,0 +1,392 @@ +%{ +#define BFEHAX + +/* macros zum registerzugriff bei kinder */ +#define KID_REG(A) bnode->kids[A]->reg +#define KIDKID_REG(A,B) bnode->kids[A]->kids[B]->reg +#define KIDKIDKID_REG(A,B,C) bnode->kids[A]->kids[B]->kids[C]->reg + +/* macros zum wertezugriff bei kindern */ +#define KID_VAL(A) bnode->kids[A]->val +#define KIDKID_VAL(A,B) bnode->kids[A]->kids[B]->val +#define KIDKIDKID_VAL(A,B,C) bnode->kids[A]->kids[B]->kids[C]->val + +#define KID_PARM(A) bnode->kids[A]->param_index +#define KIDKID_PARM(A,B) bnode->kids[A]->kids[B]->param_index +#define KIDKIDKID_PARM(A,B,C) bnode->kids[A]->kids[B]->kids[C]->param_index + +/* macros zum zugriff des aktuellen knotens */ +#define BN_REG bnode->reg +#define BN_VAL bnode->val + +/* wenn sich ein parameter auf der "leseseite" (also links bei at&t syntax) + * befindet, dann soll dieses register verwendet werden */ +#define KIDREG2PARM(A) if(bnode->kids[A]->param_index > -1) { bnode->kids[A]->reg = param_reg(bnode->kids[A]->param_index); } +#define KIDKIDREG2PARM(A,B) if(bnode->kids[A]->kids[B]->param_index > -1) { bnode->kids[A]->kids[B]->reg = param_reg(bnode->kids[A]->kids[B]->param_index); } +#define KIDKIDKIDREG2PARM(A,B,C) if(bnode->kids[A]->kids[B]->kids[C]->param_index > -1) { bnode->kids[A]->kids[B]->kids[C]->reg = param_reg(bnode->kids[A]->kids[B]->kids[C]->param_index); } + +/* wenn sich ein parameter auf der "schreibeseite" befindet (also rechts bei + * at&t syntax), dann muss es vorher in ein temporaeres register gemovt werden */ +#define KIDREG2ID(A) if(bnode->kids[A]->op == O_ID && bnode->kids[A]->param_index > -1) move(param_reg(bnode->kids[A]->param_index), bnode->kids[A]->reg); + +#include +#include +#include +#include "tree.h" +#include "chelper.h" + +void gen_e_eno(struct treenode *bnode, char *instr) +{ + printf("\t#gen_e_eno(%s)\n", instr); + KIDREG2PARM(0); + KIDREG2PARM(1); + printf("\t%s %s,%s,%s\n", instr, BN_REG, KID_REG(0), KID_REG(1)); +} + +void gen_id_eno(struct treenode *bnode) +{ + printf("\t#gen_id_eno\n"); + KIDKIDREG2PARM(1,0); + KIDKIDREG2PARM(1,1); + KIDREG2PARM(0); + + printf("\tsub %s,%s,%s\n", BN_REG, KID_REG(0), KIDKID_REG(1,1)); + printf("\tsub %s,%s,%s\n", BN_REG, BN_REG, KIDKID_REG(1,0)); +} + +void gen_e_imm(struct treenode *bnode, char *instr) +{ + printf("\t#gen_e_imm(%s)\n", instr); + KIDREG2PARM(0); + KIDREG2ID(1); + /* man kann sich ein move der konstante bei der multiplikation ersparen */ + if(strcmp(instr, "mullw") == 0) { + if(KID_VAL(1) == 1 && strcmp(KID_REG(0), BN_REG) == 0) { + printf("\t#multiplikation mit 1 wegoptimiert\n"); + } else { + if(KID_VAL(1) > (65536)-1 || KID_VAL(1) < -65536) { + moveimm(KID_VAL(1), next_reg(BN_REG,0)); + printf("\tmullw %s,%s,%s\n", BN_REG, KID_REG(0), next_reg(BN_REG,0)); + } else { + printf("\tmulli %s,%s,%d\n", BN_REG, KID_REG(0), KID_VAL(1)); + } + } + } else { + if(strcmp(instr, "sub") == 0 && KID_VAL(1) == 0) { + printf("\t#subtraktion mit 0 wegoptimiert\n"); + move(KID_REG(0), BN_REG); + } else { + if(KID_VAL(1) > (65536)-1 || KID_VAL(1) < -65536) { + moveimm(KID_VAL(1), next_reg(BN_REG,0)); + printf("\t%s %s,%s,%s\n", instr, BN_REG, KID_REG(0), next_reg(BN_REG,0)); + } else { + printf("\t%si %s,%s,%d\n", instr, BN_REG, KID_REG(0), KID_VAL(1)); + } + } + } +} + +void gen_imm_eno(struct treenode *bnode, char *instr) +{ + printf("\t#gen_imm_eno(%s)\n", instr); + KIDREG2ID(0); + KIDREG2PARM(1); + /* man kann sich ein move der konstante bei der multiplikation ersparen */ + if(strcmp(instr, "mullw") == 0) { + if(KID_VAL(0) == 1 && strcmp(KID_REG(1), BN_REG) == 0) { + printf("\t#multiplikation mit 1 wegoptimiert\n"); + } else { + if(KID_VAL(0) > (65536)-1 || KID_VAL(0) < -65536) { + moveimm(KID_VAL(0), next_reg(BN_REG,0)); + printf("\tmullw %s,%s,%s\n", BN_REG, KID_REG(1), next_reg(BN_REG,0)); + } else { + printf("\tmulli %s,%s,%d\n", BN_REG, KID_REG(1), KID_VAL(0)); + } + } + } else { /* addq */ + /* TODO: imm check einbauen */ + printf("\taddi %s,%s,%d\n", BN_REG, KID_REG(1), KID_VAL(0)); + } +} + +void gen_eqless(struct treenode *bnode, char *op, short e0, short e1, short deep) +{ + printf("\t#gen_eqless_%i%i @ %i (op: %s)\n", e0, e1, deep, op); +#if 0 + if(e0) { KIDREG2PARM(0); } else { KIDREG2ID(0); } + if(e1) { KIDREG2PARM(1); } else { KIDREG2ID(1); } + + if(e0 && e1) { + if(deep) { + KIDKIDREG2PARM(1,0); + printf("\tcmp %d(%%%s), %%%s\n", bnode->kids[1]->soffset *8, KIDKID_REG(1,0), KID_REG(0)); + } else { + printf("\tcmp %%%s, %%%s\n", KID_REG(1), KID_REG(0)); + } + } else if(e0 && !e1) { + if (deep == 0) { + printf("\tcmp $%d, %%%s\n", KID_VAL(1), KID_REG(0)); + } else if (deep == 1) { + KIDKIDREG2PARM(0,0); + printf("\tcmp $%d, %%%s\n", KID_VAL(1), KIDKID_REG(0,0)); + } else if (deep == 2) { + KIDKIDKIDREG2PARM(0,0,0); + printf("\tcmp $%d, %%%s\n", KID_VAL(1), KIDKIDKID_REG(0,0,0)); + } + } else if(!e0 && e1) { + printf("\tcmp $%d, %%%s\n", KID_VAL(0), KID_REG(1)); + } + printf("\tset%s %%%s\n", op, reg_64to8l(BN_REG)); + printf("\tand $1, %%%s\n", BN_REG); +#else + if(e0) { KIDREG2PARM(0); } else { moveimm(KID_VAL(0), BN_REG); } + if(e1) { KIDREG2PARM(1); } + if(strcmp(op,"e")==0 && bnode->kids[1]->op == O_NULL) { + /* not */ + printf("\tcntlzw %s,%s\n", KID_REG(0), KID_REG(0)); + printf("\tsrwi %s,%s,5\n", BN_REG, KID_REG(0)); + } else { + if(!e1) { + moveimm(KID_VAL(1), KID_REG(1)); + } + if(strcmp(op, "e")==0) { + /* eq */ + printf("\txor %s,%s,%s\n", BN_REG, KID_REG(0), KID_REG(1)); + printf("\tcntlzw %s,%s\n", BN_REG, BN_REG); + printf("\tsrwi %s,%s,5\n", BN_REG, BN_REG); + } else if(strcmp(op, "l")==0 || strcmp(op, "g")==0) { + /* less */ + printf("\tcmpw 7,%s,%s\n", KID_REG(1), KID_REG(0)); + printf("\tmfcr %s\n", BN_REG); + /* EQ, GT, LT */ + /* um (32-29)=3 nach rechts shiften und das LSB anschauen */ + printf("\trlwinm %s,%s,%i,31,31\n", BN_REG, BN_REG, strcmp(op,"l")==0 ? 30 : 30); + } + } + /* vergleich mit null und in CR0 speichern */ + printf("\tcmpwi %s,0\n", BN_REG); +#endif +} + +void gen_subspecial(struct treenode *bnode, short e) +{ + /* tritt z.b. bei snafu_05.0 auf */ + printf("\t#gen_subspecial(%i)\n", e); + KIDREG2ID(0); + KIDKIDREG2PARM(1,0); + + /* TODO: Loong@ codea_snafu_03.0 */ + + if(e) { + if(KIDKID_VAL(1,0) != 0) { + printf("\tsubi %s,%s,%d\n", BN_REG, BN_REG, KIDKID_VAL(1,0)); + } + } else { + printf("\tsub %s,%s,%s\n", BN_REG, BN_REG, KIDKID_REG(1,0)); + } + if(e) KIDKIDREG2PARM(1,1); + printf("\tadd %s,%s,%s\n", BN_REG, BN_REG, KIDKID_REG(1,1)); +} + +void assign_var(struct treenode *bnode) +{ + printf("\t#assign_var\n"); + KIDREG2PARM(1); + if (strcmp(bnode->kids[0]->kids[0]->name, bnode->kids[1]->name) != 0) { + KIDKIDREG2PARM(0,0); + printf("\tmr %s,%s\n", KID_REG(1), KIDKID_REG(0,0)); + } /*else: x := x - 1 geht in einem befehl */ + printf("\tsubi %s,%s,%d\n", KID_REG(1), KID_REG(1), KIDKID_VAL(0,1)); +} + +/* ... dirty */ +static short sc[8] = {0}; +void make_call(struct treenode *bnode) +{ + int j; + printf("\t#params pushen\n"); + for(j = 0; j < bnode->soffset; j++) { + if(sc[j] == 1) { + printf("\tlwz 20,%d(1)\n", j*4); + printf("\tstw %s,%d(1)\n", param_reg(j), j*4); + printf("\tmr %s,20\n", param_reg(j)); + } else if (sc[j] == 0) { + printf("\tstw %s,%d(1)\n", param_reg(j), j*4); + } + } + printf("\t#vars pushen\n"); + for(j = bnode->soffset; j < bnode->soffset + bnode->vars; j++) { + printf("\tstw %s,%d(1)\n", param_reg(j), j*4); + } + + /* TODO: schoener machen... */ + if(strcmp(BN_REG, "14")!=0) { + printf("\t#tmp register pushen\n"); + printf("\tstw 14,52(1)\n"); + if(strcmp(BN_REG, "15")!=0) { + printf("\tstw 15,56(1)\n"); + if(strcmp(BN_REG, "16")!=0) { + printf("\tstw 16,60(1)\n"); + } + } + } + + printf("\tbl %s\n", bnode->name); + move("3", BN_REG); + + if(strcmp(BN_REG, "14")!=0) { + printf("\t#tmp register poppen\n"); + if(strcmp(BN_REG, "15")!=0) { + if(strcmp(BN_REG, "16")!=0) { + printf("\tlwz 16,60(1)\n"); + } + printf("\tlwz 15,56(1)\n"); + } + printf("\tlwz 14,52(1)\n"); + } + + printf("\t#vars poppen\n"); + for(j = bnode->soffset + bnode->vars - 1; j > bnode->soffset - 1; j--) { + printf("\tlwz %s,%d(1)\n", param_reg(j), j*4); + } + + printf("\t#params poppen\n"); + for(j = bnode->soffset - 1; j >= 0; j--) { + if(sc[j] == 0) + printf("\tlwz %s,%d(1)\n", param_reg(j), j*4); + } + for(j = 0; j < bnode->soffset; j++) { + if(sc[j] > 0) + printf("\tlwz %s,%d(1)\n", param_reg(j), j*4); + } + + /* clear stack control array */ + for(j = 0; j < sizeof sc / sizeof sc[0]; j++) + sc[j] = 0; +} + +void prep_arg(struct treenode *bnode, int moveit) +{ + printf("\t#args-nr-> %i (%%%s) [moveit= %i]\n", bnode->soffset, param_reg(bnode->soffset), moveit); + sc[bnode->soffset] = 1; + if(moveit) { /* expr */ + if((BN_REG == (char *) NULL) || (bnode->kids[1] != TREENULL && bnode->kids[1]->op == O_ID && bnode->kids[1]->kids[0] == TREENULL && bnode->kids[1]->kids[1] == TREENULL)) { + if(bnode->kids[1]->name != (char *) NULL && strcmp(bnode->kids[1]->name,"this")!=0) { + KIDREG2PARM(1); + printf("\tstw %s,%d(1)\n", KID_REG(1),bnode->soffset*4); + } else { + printf("\tstw %s,%d(1)\n", param_reg(bnode->soffset), bnode->soffset*4); + sc[bnode->soffset] = 2; + } + } else { + printf("\tstw %s,%d(1)\n", BN_REG, bnode->soffset*4); + } + } else { /* just O_ID */ + KIDREG2PARM(0); + printf("\tstw %s,%d(1)\n", KID_REG(0), bnode->soffset*4); + } +} + +%} + +%start begin +%term O_RET=1 O_NULL=2 O_SUB=3 O_MUL=4 O_OR=5 O_LESS=6 O_EQ=7 O_ID=8 O_ADD=9 O_NUM=10 O_FIELD=11 O_MTWO=12 O_MFOUR=13 O_MEIGHT=14 O_MONE=15 O_ASSIGN=16 O_IF=17 O_BOOL=18 O_CALL=19 O_ARG=20 O_NOTHING=21 O_EXPR=22 + +%% + +begin: ret # 0 # +begin: assign # 0 # +begin: ifstat # 0 # +begin: args # 0 # + + +assign: O_ASSIGN(expr, O_ID) # 1 # KIDREG2PARM(1); printf("\tmr %s,%s\n", KID_REG(1), BN_REG); +assign: O_ASSIGN(imm, O_ID) # 1 # KIDREG2PARM(1); moveimm(KID_VAL(0), KID_REG(1)); +assign: O_ASSIGN(O_ID, O_ID) # 1 # KIDREG2PARM(1); KIDREG2PARM(0); printf("\tmr %s,%s\n", KID_REG(1), KID_REG(0)); + +assign: O_ASSIGN(O_SUB(O_ID,O_NUM), O_ID) # 1 # assign_var(bnode); + +assign: O_ASSIGN(expr, O_FIELD(expr)) # 1 # KIDKIDREG2PARM(1,0); printf("\tstw %s,%d(%s)\n", BN_REG, bnode->kids[1]->soffset * 4, KIDKID_REG(1,0)); +assign: O_ASSIGN(O_ID, O_FIELD(expr)) # 1 # KIDREG2PARM(0); KIDKIDREG2PARM(1,0); printf("\tstw %s,%d(%s)\n", KID_REG(0), bnode->kids[1]->soffset * 4, KIDKID_REG(1,0)); + + +ifstat: O_IF(O_ID) # 1 # /* fuer faelle wie "if bla then" noetig */ KIDREG2PARM(0); printf("\tcmpwi %s,0\n", KID_REG(0)); +ifstat: O_IF(O_BOOL(imm)) # 1 # printf("\tcmpwi %s,0\n", BN_REG); +ifstat: O_IF(expr) # 2 # /* iburg beschummeln :/ */ printf("\tcmpwi %s,0\n", BN_REG); +ifstat: O_IF(O_BOOL(expr)) # 1 # /* dann braucht man kein test */ + + +ret: O_RET(retexpr) # 2 # printf("\t/*o_ret(expr)*/\n"); move(BN_REG, "3"); +ret: O_EXPR(expr) # 0 # + +retexpr: O_ID # 1 # printf("\t/*retexpr*/\n"); if(bnode->param_index > -1) move(param_reg(bnode->param_index), BN_REG); +retexpr: expr + + +expr: O_ID # 0 # +expr: imm # 1 # moveimm(BN_VAL, BN_REG); +expr: O_BOOL(expr) # 0 # + +expr: O_CALL(expr) # 0 # make_call(bnode); +expr: O_ARG(expr,expr) # 1 # prep_arg(bnode, 1); +expr: O_ARG(O_ID,expr) # 1 # prep_arg(bnode, 0); +expr: O_NOTHING # 0 # + +expr: O_SUB(expr,expr) # 2 # gen_e_eno(bnode, "sub"); +expr: O_SUB(expr,imm) # 1 # gen_e_imm(bnode, "sub"); + +expr: O_SUB(expr,O_SUB(O_ID,expr)) # 2 # gen_subspecial(bnode, 0); +expr: O_SUB(expr,O_SUB(imm,expr)) # 2 # gen_subspecial(bnode, 1); + +expr: O_SUB(expr, O_ADD(O_ID,expr)) # 1 # gen_id_eno(bnode); + + +expr: O_ADD(expr,expr) # 1 # gen_e_eno(bnode, "add"); +expr: O_ADD(expr,imm) # 1 # gen_e_imm(bnode, "add"); +expr: O_ADD(imm,expr) # 1 # gen_imm_eno(bnode, "add"); + + +expr: O_MUL(expr,expr) # 1 # gen_e_eno(bnode, "mullw"); +expr: O_MUL(expr,imm) # 1 # gen_e_imm(bnode, "mullw"); +expr: O_MUL(imm,expr) # 1 # gen_imm_eno(bnode, "mullw"); + + +expr: O_OR(expr,expr) # 1 # gen_e_eno(bnode, "or"); +expr: O_OR(expr,imm) # 2 # gen_e_imm(bnode, "or"); + + +expr: O_LESS(expr,expr) # 3 # gen_eqless(bnode, "l", 1, 1, 0); +expr: O_LESS(expr,imm) # 3 # gen_eqless(bnode, "l", 1, 0, 0); +expr: O_LESS(imm,expr) # 3 # gen_eqless(bnode, "g", 0, 1, 0); + + +expr: O_EQ(expr,expr) # 3 # gen_eqless(bnode, "e", 1, 1, 0); +expr: O_EQ(expr,imm) # 3 # gen_eqless(bnode, "e", 1, 0, 0); +expr: O_EQ(imm,expr) # 3 # gen_eqless(bnode, "e", 0, 1, 0); +expr: O_EQ(expr,O_NULL) # 3 # gen_eqless(bnode, "e", 1, 0, 0); + +expr: O_EQ(O_EQ(expr,O_NULL),O_NULL) # 3 # gen_eqless(bnode, "ne", 1, 0, 1); +expr: O_EQ(O_EQ(O_EQ(expr,O_NULL),O_NULL),O_NULL) # 3 # gen_eqless(bnode, "e", 1, 0, 2); + + +expr: O_FIELD(expr) # 1 # printf("\t/* field(expr)*/\n"); KIDREG2PARM(0); printf("\tlwz %s, %d(%s)\n", BN_REG, bnode->soffset * 4, KID_REG(0)); +expr: O_FIELD(imm) # 1 # printf("\t/* field(imm)*/\n"); moveimm(KID_VAL(0), BN_REG); printf("\tlwz %s,%d(%s)\n", BN_REG, bnode->soffset * 4, BN_REG); + + +imm: O_ADD(imm,imm) # 0 # BN_VAL = KID_VAL(0) + KID_VAL(1); +imm: O_SUB(imm,imm) # 0 # BN_VAL = KID_VAL(0) - KID_VAL(1); +imm: O_MUL(imm,imm) # 0 # BN_VAL = KID_VAL(0) * KID_VAL(1); +imm: O_LESS(imm,imm) # 0 # BN_VAL = KID_VAL(0) < KID_VAL(1) ? 1 : 0; +imm: O_EQ(imm,imm) # 0 # BN_VAL = KID_VAL(0) == KID_VAL(1) ? 1 : 0; +imm: O_OR(imm,imm) # 0 # BN_VAL = KID_VAL(0) | KID_VAL(1); +imm: O_NUM # 0 # +imm: O_MONE # 0 # +imm: O_MTWO # 0 # +imm: O_MFOUR # 0 # +imm: O_MEIGHT # 0 # +imm: O_NULL # 0 # + +%% + +/* vim: filetype=c + */ diff --git a/gesamt_arm/parser.y b/gesamt_arm/parser.y new file mode 100644 index 0000000..e6fc7a5 --- /dev/null +++ b/gesamt_arm/parser.y @@ -0,0 +1,624 @@ +%{ + #include + #include + #include + #include "symtable.h" + #include "chelper.h" + #include "tree.h" + + #define MAX(A,B) (A > B ? A : B) +%} + +%start Input +%token STRUCT END METHOD VAR IF THEN ELSE WHILE DO RETURN NOT OR THIS IDENT NUM ASSIGN + +@macro xxputsin(xx,) + @i xx = @Statement.sin@; +@end + +@macro statinout() + @i @Statement.sout@ = @Statement.sin@; + /* das + *> xxputsin(@Statement.sout@,) + * geht nicht, weil verschachtelte macros deaktiviert sind */ +@end + +@macro lblcountinout() + @i @Statement.lblcnt_out@ = @Statement.lblcnt_in@; +@end + +@macro varsinout() + @i @Statement.vars_out@ = @Statement.vars_in@; +@end + +/* beschreibung der attribute + * s: symboltabelle + * f: symboltabelle fuer quirks mit structur und parameter + * gparamges: anzahl der parameter in einer methode + * parms: parametercounter + * node: baum fuer iburg + * sin: symboltabelle fuer statement ("eingabe") + * sout: symboltabelle die aus einem statement wieder rauskommt ("ausgabe") + */ +@autoinh s gparamges vars_in +@autosyn node imm call + +@attributes { char *name; } IDENT +@attributes { long val; } NUM +@attributes { struct symbol *f; int paramges; int parms; } Parms +@attributes { struct symbol *f; } Program Structdef; +@attributes { struct symbol *f; int offsetcount; } FeldID +@attributes { struct symbol *s; } Methoddef +@attributes { struct symbol *s; int gparamges; int vars_in; int cnt; int paramcount; struct treenode *node; } Exprs +@attributes { struct symbol *s; int gparamges; int lblcnt_in; int lblcnt_out; int vars_in; int vars_out; int call; } Statseq +@attributes { struct symbol *s; int gparamges; int lblcnt_in; int lblcnt_out; int reallblcnt; int vars_in; int vars_out; int call; } Elsestat +@attributes { struct symbol *s; int gparamges; int vars_in; struct treenode *node; short imm; int call; } Expr Minusterm Multerm Orterm Feld Term +@attributes { struct symbol *s; int gparamges; int vars_in; struct treenode *node; } Lexpr +@attributes { struct symbol *sin; int gparamges; struct symbol *sout; struct treenode *node; int vars_in; int vars_out; int lblcnt_in; int lblcnt_out; int call; } Statement + +@traversal @postorder c +@traversal @preorder reg +@traversal @preorder gen + +%% +Input: + Program + @{ + @i @Program.f@ = tab_new(); + @gen printf("\t.section\t\".text\"\n"); + @} + ; + +Program: + Methoddef ';' Program + @{ + @i @Methoddef.s@ = @Program.0.f@; + @i @Program.1.f@ = @Program.0.f@; + @} + + | Structdef ';' Program + @{ + @i @Program.1.f@ = tab_merge(@Program.0.f@, @Structdef.f@, 1); + @} + | + ; + +Methoddef: + METHOD IDENT '(' Parms ')' Statseq END + @{ + @i @Parms.parms@ = 1; + @i @Statseq.s@ = tab_merge(@Methoddef.s@, @Parms.f@, 0); + @i @Statseq.vars_in@ = 0; + @i @Statseq.gparamges@ = @Parms.paramges@; + @i @Statseq.lblcnt_in@ = 0; + @gen func_header(@IDENT.name@, @Statseq.vars_out@, @Parms.paramges@, @Statseq.call@); + @} + ; + +Structdef: + STRUCT FeldID END + @{ + @i @Structdef.f@ = @FeldID.f@; + @i @FeldID.offsetcount@ = 0; + @} + ; + +Parms: + /* lokale Vars werden in Statement in die tabelle eingefuegt */ + IDENT Parms + @{ + @i @Parms.1.parms@ = @Parms.0.parms@ + 1; + @i @Parms.0.paramges@ = @Parms.1.paramges@; + @i @Parms.0.f@ = tab_add_symbol(@Parms.1.f@, @IDENT.name@, S_PARM, 1, @Parms.parms@, -1); + @} + + | + @{ + @i @Parms.f@ = tab_new(); + @i @Parms.paramges@ = @Parms.parms@; + @} + ; + +FeldID: + IDENT FeldID + @{ + @i @FeldID.1.offsetcount@ = @FeldID.0.offsetcount@ + 1; + @i @FeldID.0.f@ = tab_add_symbol(@FeldID.1.f@, @IDENT.name@, S_FIELD, 1, -1, @FeldID.0.offsetcount@); + @} + + | + @{ + @i @FeldID.f@ = tab_new(); + @} + ; + +Statseq: + Statement ';' Statseq + @{ + @i @Statement.sin@ = @Statseq.0.s@; + @i @Statement.lblcnt_in@ = @Statseq.0.lblcnt_in@; + + @i @Statseq.1.s@ = @Statement.sout@; + @i @Statseq.1.lblcnt_in@ = @Statement.lblcnt_out@; + @i @Statseq.1.gparamges@ = @Statseq.0.gparamges@; + + @i @Statement.vars_in@ = @Statseq.0.vars_in@; + @i @Statseq.1.vars_in@ = @Statement.vars_out@; + + @i @Statseq.0.lblcnt_out@ = @Statseq.1.lblcnt_out@; + @i @Statseq.0.vars_out@ = @Statseq.1.vars_out@; + + @i @Statseq.0.call@ = @Statement.call@ || @Statseq.1.call@; + @} + + | + @{ + @i @Statseq.0.lblcnt_out@ = @Statseq.0.lblcnt_in@; + @i @Statseq.0.vars_out@ = @Statseq.0.vars_in@; + @i @Statseq.0.call@ = 0; + @} + ; + +Statement: + Lexpr ASSIGN Expr + @{ + statinout() + lblcountinout() + varsinout() + xxputsin(@Lexpr.s@,) + xxputsin(@Expr.s@,) + @i @Statement.node@ = new_node(O_ASSIGN, @Expr.node@, @Lexpr.node@); + @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@); + @reg @Lexpr.node@->reg = next_reg(@Expr.node@->reg, @Expr.gparamges@); + + @gen write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1); + @} + + | VAR IDENT ASSIGN Expr + @{ + /* tab_clone ist hier noetig, vgl. folgendes statement + * > var x := x - 1; */ + @i @Statement.sout@ = tab_add_symbol(tab_clone(@Statement.sin@), @IDENT.name@, S_VAR, 1, @Statement.gparamges@ + @Statement.vars_in@, -1); + lblcountinout() + + @i @Statement.vars_out@ = @Statement.vars_in@ + 1; + + xxputsin(@Expr.s@,) + + @i @Statement.node@ = new_node(O_ASSIGN, @Expr.node@, new_param(O_ID, @IDENT.name@, TREENULL, TREENULL, @Statement.gparamges@ + @Statement.vars_in@)); + @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@); + + @gen write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1); + @} + + | Expr + @{ + statinout() + varsinout() + lblcountinout() + xxputsin(@Expr.s@,) + @i @Statement.node@ = new_node(O_EXPR, @Expr.node@, TREENULL); + @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@); + + @gen write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1); + @} + + | IF Expr THEN Statseq END + @{ + statinout() + @i @Statseq.lblcnt_in@ = @Statement.lblcnt_in@ + 1; + @i @Statement.lblcnt_out@ = @Statseq.lblcnt_out@; + + @i @Statseq.vars_in@ = @Statement.vars_in@; + @i @Statement.vars_out@ = @Statseq.vars_out@; + + @i @Statement.call@ = @Expr.call@ || @Statseq.call@; + + xxputsin(@Expr.s@,) + xxputsin(@Statseq.s@,) + + @i @Statement.node@ = new_node(O_IF, @Expr.node@, TREENULL); + + @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@); + @gen { + printf(".%s_ifstart_%d:\n", get_func_name(), @Statement.lblcnt_in@); + write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1); + printf("\tbeq 0,.%s_ifend_%d\n", get_func_name(), @Statement.lblcnt_in@); + } + @gen @revorder(1) printf(".%s_ifend_%d:\n", get_func_name(), @Statement.lblcnt_in@); + @} + + | IF Expr THEN Statseq Elsestat END + @{ + statinout() + @i @Statseq.0.lblcnt_in@ = @Statement.lblcnt_in@ + 1; + @i @Elsestat.lblcnt_in@ = @Statseq.lblcnt_out@; + @i @Statement.lblcnt_out@ = @Elsestat.lblcnt_out@; + + /* im Elsestat muss noch ein label numeriert werden */ + @i @Elsestat.reallblcnt@ = @Statement.lblcnt_in@; + + @i @Statseq.vars_in@ = @Statement.vars_in@; + @i @Elsestat.vars_in@ = @Statement.vars_in@; + @i @Statement.vars_out@ = MAX(@Statseq.vars_out@, @Elsestat.vars_out@); + + @i @Statement.call@ = @Expr.call@ || @Statseq.call@ || @Elsestat.call@; + + xxputsin(@Expr.s@,) + xxputsin(@Statseq.0.s@,) + xxputsin(@Elsestat.s@,) + + @i @Statement.node@ = new_node(O_IF, @Expr.node@, TREENULL); + + @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@); + @gen { + printf(".%s_ifstart_%d:\n", get_func_name(), @Statement.lblcnt_in@); + write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1); + printf("\tbeq 0,.%s_ifelse_%d\n", get_func_name(), @Statement.lblcnt_in@); + } + @gen @revorder(1) printf(".%s_ifend_%d:\n", get_func_name(), @Statement.lblcnt_in@); + @} + + | WHILE Expr DO Statseq END + @{ + statinout() + @i @Statseq.lblcnt_in@ = @Statement.lblcnt_in@ + 1; + @i @Statement.lblcnt_out@ = @Statseq.lblcnt_out@; + + @i @Statseq.vars_in@ = @Statement.vars_in@; + @i @Statement.vars_out@ = @Statseq.vars_out@; + + @i @Statement.call@ = @Expr.call@ || @Statseq.call@; + + xxputsin(@Expr.s@,) + xxputsin(@Statseq.s@,) + + @i @Statement.node@ = new_node(O_IF, @Expr.node@, TREENULL); + + @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@); + @gen { + printf(".%s_whilestart_%d:\n", get_func_name(), @Statement.lblcnt_in@); + write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1); + printf("\tbeq 0,.%s_whileend_%d\n", get_func_name(), @Statement.lblcnt_in@); + } + @gen @revorder(1) printf("\tb .%s_whilestart_%d\n.%s_whileend_%d:\n", get_func_name(), @Statement.lblcnt_in@, get_func_name(), @Statement.lblcnt_in@); + @} + + | RETURN Expr + @{ + statinout() + lblcountinout() + varsinout() + xxputsin(@Expr.s@,) + + @i @Statement.node@ = new_node(O_RET, @Expr.node@, TREENULL); + @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@); + + @gen write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1); func_footer(); + @} + ; + +Elsestat: + ELSE Statseq + @{ + @i @Statseq.lblcnt_in@ = @Elsestat.lblcnt_in@; + @i @Elsestat.lblcnt_out@ = @Statseq.lblcnt_out@; + + @i @Statseq.vars_in@ = @Elsestat.vars_in@; + @i @Elsestat.vars_out@ = @Statseq.vars_out@; + + @gen printf("\tb .%s_ifend_%d\n.%s_ifelse_%d:\n", get_func_name(), @Elsestat.reallblcnt@, get_func_name(), @Elsestat.reallblcnt@); + @} + +Lexpr: + IDENT + @{ + @c check(@Lexpr.s@, @IDENT.name@, S_VAR|S_PARM); + + /* TODO: selbe Code wie bei Term/IDENT -- schoener machen! */ + @i { + @Lexpr.node@ = TREENULL; + if(tab_lookup(@Lexpr.s@, @IDENT.name@, S_VAR|S_PARM) == SYMNULL) { + /* es handelt sich um ein feldzugriff auf this */ + @Lexpr.node@ = new_field(@IDENT.name@, new_param(O_ID, strdup("this"), TREENULL, TREENULL, 0), TREENULL, tab_lookup(@Lexpr.s@, @IDENT.name@, S_FIELD) == SYMNULL ? -1 : tab_lookup(@Lexpr.s@, @IDENT.name@, S_FIELD)->soffset); + } else { /* param oder var */ + int tmp = tab_lookup(@Lexpr.s@, @IDENT.name@, S_VAR|S_PARM) == SYMNULL ? -1 : tab_lookup(@Lexpr.s@, @IDENT.name@, S_VAR|S_PARM)->param_index; + @Lexpr.node@ = new_param(O_ID, @IDENT.name@, TREENULL, TREENULL, tmp); + } + } + + @reg if(tab_lookup(@Lexpr.s@, @IDENT.name@, S_VAR|S_PARM) == SYMNULL) { + /* TODO: kein schoener hack? */ + @Lexpr.node@->kids[0]->reg = @Lexpr.node@->reg; + } + @} + + | Feld + ; + +Feld: Term '.' IDENT + @{ + @c check(@Feld.s@, @IDENT.name@, S_FIELD); + @i @Feld.node@ = new_field(@IDENT.name@, @Term.node@, TREENULL, tab_lookup(@Feld.s@, @IDENT.name@, S_FIELD) == SYMNULL ? -1 : tab_lookup(@Feld.s@, @IDENT.name@, S_FIELD)->soffset); + + @reg @Term.node@->reg = next_reg(@Feld.node@->reg, @Term.gparamges@); + @} + ; + +Expr: + Term + @{ + @reg @Term.node@->reg = @Expr.node@->reg; + @} + + | NOT Term + @{ + @i @Expr.node@ = new_node(O_BOOL, new_node(O_EQ, @Term.node@, new_node(O_NULL, TREENULL, TREENULL)), TREENULL); + + @reg @Term.node@->reg = @Expr.node@->kids[0]->reg = @Expr.node@->reg; + @} + + | Term Minusterm + @{ + @i @Expr.node@ = new_node(O_SUB, @Term.node@, @Minusterm.node@); + @i @Expr.imm@ = @Term.imm@ && @Minusterm.imm@; + @i @Expr.call@ = @Term.call@ || @Minusterm.call@; + + @reg { + if(!(@Expr.node@->kids[0] == TREENULL && @Expr.node@->kids[1] == TREENULL)) { + @Term.node@->reg = @Expr.node@->reg; + if(@Minusterm.imm@) { + @Minusterm.node@->reg = @Expr.node@->reg; + } else { + @Minusterm.node@->reg = next_reg(@Term.node@->reg, @Expr.gparamges@); + } + } + } + @} + + | Term Multerm + @{ + @i @Expr.node@ = new_node(O_MUL, @Term.node@, @Multerm.node@); + @i @Expr.imm@ = @Term.imm@ && @Multerm.imm@; + @i @Expr.call@ = @Term.call@ || @Multerm.call@; + + @reg { + @Term.node@->reg = @Expr.node@->reg; + if(@Term.imm@) { + @Multerm.node@->reg = @Expr.node@->reg; + } else { + @Multerm.node@->reg = next_reg(@Term.node@->reg, @Expr.gparamges@); + } + } + @} + + | Term Orterm + @{ + @i @Expr.node@ = new_node(O_OR, @Term.node@, @Orterm.node@); + @i @Expr.imm@ = @Term.imm@ && @Orterm.imm@; + @i @Expr.call@ = @Term.call@ || @Orterm.call@; + + @reg { + @Term.node@->reg = @Expr.node@->reg; + @Orterm.node@->reg = next_reg(@Term.node@->reg, @Expr.gparamges@); + } + @} + + | Term '<' Term + @{ + @i @Expr.node@ = new_node(O_BOOL, new_node(O_LESS, @Term.0.node@, @Term.1.node@), TREENULL); + @i @Expr.imm@ = @Term.0.imm@ && @Term.1.imm@; + @i @Expr.call@ = @Term.0.call@ || @Term.1.call@; + + @reg { + @Term.0.node@->reg = @Expr.node@->kids[0]->reg = @Expr.node@->reg; + @Term.1.node@->reg = next_reg(@Term.0.node@->reg, @Expr.gparamges@); + } + @} + + | Term '=' Term + @{ + @i @Expr.node@ = new_node(O_BOOL, new_node(O_EQ, @Term.0.node@, @Term.1.node@), TREENULL); + @i @Expr.imm@ = @Term.0.imm@ && @Term.1.imm@; + @i @Expr.call@ = @Term.0.call@ || @Term.1.call@; + + @reg { + @Term.0.node@->reg = @Expr.node@->kids[0]->reg = @Expr.node@->reg; + @Term.1.node@->reg = next_reg(@Term.0.node@->reg, @Expr.gparamges@); + } + @} + ; + +Minusterm: + '-' Term Minusterm + @{ + @i @Minusterm.node@ = new_node(O_ADD, @Minusterm.1.node@, @Term.node@); + @i @Minusterm.0.imm@ = @Term.imm@ && @Minusterm.1.imm@; + @i @Minusterm.0.call@ = @Term.call@ || @Minusterm.1.call@; + + @reg { + @Minusterm.1.node@->reg = @Minusterm.node@->reg; + if(@Minusterm.1.imm@) { + @Term.node@->reg = @Minusterm.node@->reg; + } else { + @Term.node@->reg = next_reg(@Minusterm.1.node@->reg, @Minusterm.gparamges@); + } + } + @} + + | '-' Term + @{ + @reg @Term.node@->reg = @Minusterm.node@->reg; + @} + ; + +Multerm: + '*' Term Multerm + @{ + @i @Multerm.node@ = new_node(O_MUL, @Multerm.1.node@, @Term.node@); + @i @Multerm.0.imm@ = @Term.imm@ && @Multerm.1.imm@; + @i @Multerm.0.call@ = @Term.call@ || @Multerm.1.call@; + + @reg { + @Multerm.1.node@->reg = @Multerm.node@->reg; + if(@Multerm.1.imm@) { + @Term.node@->reg = @Multerm.node@->reg; + } else { + @Term.node@->reg = next_reg(@Multerm.1.node@->reg, @Multerm.gparamges@); + } + } + @} + + | '*' Term + @{ + @reg @Term.node@->reg = @Multerm.node@->reg; + @} + ; + +Orterm: + OR Term Orterm + @{ + @i @Orterm.node@ = new_node(O_OR, @Orterm.1.node@, @Term.node@); + @i @Orterm.0.imm@ = @Term.imm@ && @Orterm.1.imm@; + @i @Orterm.0.call@ = @Term.call@ || @Orterm.1.call@; + + @reg { + @Orterm.1.node@->reg = @Orterm.node@->reg; + if(@Orterm.1.imm@) { + @Term.node@->reg = @Orterm.node@->reg; + } else { + @Term.node@->reg = next_reg(@Orterm.1.node@->reg, @Orterm.gparamges@); + } + } + @} + | OR Term + @{ + @reg @Term.node@->reg = @Orterm.node@->reg; + @} + + ; + +Term: + '(' Expr ')' + @{ + @i @Term.node@ = @Expr.node@; + @} + + | NUM + @{ + @i @Term.node@ = new_number(@NUM.val@); + @i @Term.imm@ = 1; + @i @Term.call@ = 0; + @} + + | '-' NUM + @{ + @i @Term.node@ = new_number(-1 * (@NUM.val@)); + @i @Term.imm@ = 1; + @i @Term.call@ = 0; + @} + + | THIS + @{ + @i @Term.node@ = new_param(O_ID, strdup("this"), TREENULL, TREENULL, 0); + @i @Term.imm@ = 0; + @i @Term.call@ = 0; + @} + + | IDENT + @{ + @c check(@Term.s@, @IDENT.name@, S_VAR|S_PARM); + + @i @Term.imm@ = 0; + @i @Term.call@ = 0; + @i { + @Term.node@ = TREENULL; + if(tab_lookup(@Term.s@, @IDENT.name@, S_VAR|S_PARM) == SYMNULL) { + /* es handelt sich um ein feldzugriff auf this */ + @Term.node@ = new_field(@IDENT.name@, new_param(O_ID, strdup("this"), TREENULL, TREENULL, 0), TREENULL, tab_lookup(@Term.s@, @IDENT.name@, S_FIELD) == SYMNULL ? -1 : tab_lookup(@Term.s@, @IDENT.name@, S_FIELD)->soffset); + } else { /* param oder var */ + int tmp = tab_lookup(@Term.s@, @IDENT.name@, S_VAR|S_PARM) == SYMNULL ? -1 : tab_lookup(@Term.s@, @IDENT.name@, S_VAR|S_PARM)->param_index; + @Term.node@ = new_param(O_ID, @IDENT.name@, TREENULL, TREENULL, tmp); + } + } + + @reg if(tab_lookup(@Term.s@, @IDENT.name@, S_VAR|S_PARM) == SYMNULL) { + /* TODO: kein schoener hack? */ + @Term.node@->kids[0]->reg = @Term.node@->reg; + } + @} + + | Feld + @{ + @i @Term.node@ = @Feld.node@; + @i @Term.imm@ = 0; + @} + + | IDENT '(' Exprs ')' + @{ + @i { + @Term.node@ = new_call(@IDENT.name@, new_arg(@Exprs.node@, new_nothing(), 0) /*this*/, + TREENULL, @Term.gparamges@, @Term.vars_in@); + @Term.node@->soffset = MAX(@Exprs.paramcount@, @Term.gparamges@); + } + @i @Exprs.cnt@ = 1; + @i @Term.imm@ = 0; + @i @Term.call@ = 1; + @reg @Exprs.node@->reg = @Term.node@->reg; + @} + + | Term '.' IDENT '(' Exprs ')' + @{ + @i { + @Term.node@ = new_call(@IDENT.name@, new_arg(@Exprs.node@, @Term.1.node@, 0) /*this*/, + TREENULL, @Term.gparamges@, @Term.vars_in@); + @Term.node@->soffset = MAX(@Exprs.paramcount@, @Term.gparamges@); + } + @i @Exprs.cnt@ = 1; + @i @Term.imm@ = 0; + @i @Term.call@ = 1; + @reg @Exprs.node@->reg = @Term.1.node@->reg = @Term.node@->kids[0]->reg = @Term.node@->reg; + @} + + ; + +Exprs: + Expr ',' Exprs + @{ + @i @Exprs.0.node@ = new_arg(@Expr.0.node@, @Exprs.1.node@, @Exprs.0.cnt@); + @i @Exprs.0.paramcount@ = @Exprs.1.paramcount@; + @i @Exprs.1.cnt@ = @Exprs.0.cnt@ + 1; + @reg @Expr.node@->reg = @Exprs.0.node@->reg; @Exprs.1.node@->reg = next_reg(@Exprs.0.node@->reg, @Exprs.gparamges@); + @} + | Expr + @{ + @i @Exprs.0.node@ = new_arg(@Expr.0.node@, new_nothing(), @Exprs.cnt@); + @i @Exprs.paramcount@ = @Exprs.cnt@ + 1; + @reg @Expr.node@->reg = @Exprs.0.node@->reg; + @} + | + @{ + @i @Exprs.0.node@ = new_nothing(); + @i @Exprs.paramcount@ = @Exprs.cnt@; + @} + ; +%% + +extern int yylex(); +extern int yylineno; + +int yyerror(char *error_text) +{ + fprintf(stderr,"Zeile %i: %s\n", yylineno, error_text); + exit(2); +} + +int main(int argc, char **argv) +{ + #if 0 + yydebug=1; + #endif + yyparse(); + return 0; +} + diff --git a/gesamt_arm/scanner.lex b/gesamt_arm/scanner.lex new file mode 100644 index 0000000..92f6df7 --- /dev/null +++ b/gesamt_arm/scanner.lex @@ -0,0 +1,67 @@ + #include + #include + #include + #include "parser.h" + +KEYWORD struct|end|method|var|if|then|else|while|do|return|not|or|this +IDENTIFIER [a-zA-Z_][0-9a-zA-Z_]* +NUMBER_HEX 0x[0-9A-Fa-f]+ +NUMBER_DEC [0-9]+ +WHITESPACE [\t\n\r ] +COMMENT_START \/\* +COMMENT_END \*\/ + +%x COMMENT +%option yylineno +%% + +{COMMENT_START} BEGIN(COMMENT); + +{COMMENT_END} BEGIN(INITIAL); + +<> { + fprintf(stderr, "Kommentar nicht geschlossen\n"); + exit(1); +} + +(.|\n) /* alles im kommentar wird ignoriert */ + +struct return(STRUCT); +end return(END); +method return(METHOD); +var return(VAR); +if return(IF); +then return(THEN); +else return(ELSE); +while return(WHILE); +do return(DO); +return return(RETURN); +not return(NOT); +or return(OR); +this return(THIS); + +{IDENTIFIER} return(IDENT); @{ @IDENT.name@ = strdup(yytext); @} + +{NUMBER_DEC} return(NUM); @{ @NUM.val@ = strtol(yytext, (char **)NULL, 10); @} +{NUMBER_HEX} return(NUM); @{ @NUM.val@ = strtol(yytext, (char **)NULL, 16); @} + +\:= return(ASSIGN); +\; return(';'); +\( return('('); +\) return(')'); +\. return('.'); +\- return('-'); +\* return('*'); +\< return('<'); +\= return('='); +\, return(','); + +{WHITESPACE} /* ignore */ + +. { + fprintf(stderr, "Lexical error on line %i\n", yylineno); + exit(1); +} + +%% + diff --git a/gesamt_arm/symtable.c b/gesamt_arm/symtable.c new file mode 100644 index 0000000..89db8c0 --- /dev/null +++ b/gesamt_arm/symtable.c @@ -0,0 +1,149 @@ +#include +#include +#include +#include "symtable.h" + +#if 0 +#define DD +#endif + +struct symbol *tab_new(void) +{ + return SYMNULL; +} + +struct symbol *tab_clone(struct symbol *tab) +{ + struct symbol *elm = tab; + struct symbol *ntab = tab_new(); +#ifdef DD + fprintf(stderr, "tab_clone: tab(%08X)\n", tab); +#endif + + while(elm != SYMNULL) { + ntab = tab_add_symbol(ntab, elm->ident, elm->type, 0, elm->param_index, elm->soffset); + elm = elm->next; + } + return ntab; +} + +struct symbol *tab_add_symbol(struct symbol *tab, char *ident, short type, short check, int param_index, int soffset) +{ + struct symbol *elm = tab; + struct symbol *new_elm; +#ifdef DD + fprintf(stderr, "tab_add_symbol: tab(%08X), ident(%s), type(%i), check(%i), param_index(%i), soffset(%i)\n", tab, ident, type, check, param_index, soffset); +#endif + +#if 0 + /* kann statt return -3, -4 verursachen... (z.b. codea_ag_snafu_01.3) */ + if(param_index >= 6) { + fprintf(stderr, "eine methode hat zu viele parameter (max. 6 inkl. this erlaubt)\n"); + exit(4); + } +#endif + + if(tab_lookup(tab, ident, type) != SYMNULL || (type == S_VAR && tab_lookup(tab, ident, S_PARM) != SYMNULL)) { + if(check) { + fprintf(stderr, "Identifier doppelt vorhanden: \"%s\"\n", ident); + exit(3); + } else { + tab = tab_remove_symbol(tab, ident, type); + } + } + + new_elm = (struct symbol *) malloc(sizeof(struct symbol)); + new_elm->next = SYMNULL; + new_elm->ident = strdup(ident); + new_elm->type = type; + new_elm->param_index = param_index; + new_elm->soffset = soffset; + + if(tab == SYMNULL) return new_elm; + + while(elm->next != SYMNULL) { + elm = elm->next; + } + elm->next = new_elm; + + return tab; +} + +struct symbol *tab_lookup(struct symbol *tab, char *ident, short type) +{ + struct symbol *elm = tab; + + if(tab == SYMNULL) return SYMNULL; + + do { + if((elm->type & type) && (strcmp(elm->ident, ident) == 0)) { + return elm; + } + elm = elm->next; + } while(elm != SYMNULL); + + return SYMNULL; +} + +struct symbol *tab_merge(struct symbol *tab, struct symbol *to_add, short check) +{ + struct symbol *elm = to_add; + struct symbol *ntab = tab_clone(tab); +#ifdef DD + fprintf(stderr, "tab_merge: tab(%08X), to_add(%08X), check(%i), ntab(%08X)\n", tab, to_add, check, ntab); +#endif + + while(elm != SYMNULL) { + ntab = tab_add_symbol(ntab, elm->ident, elm->type, check, elm->param_index, elm->soffset); + elm = elm->next; + } + + return ntab; +} + +struct symbol *tab_remove_symbol(struct symbol *tab, char *ident, short type) +{ + struct symbol *elm = tab; + struct symbol *previous_elm = SYMNULL; + + while(elm != SYMNULL) { + if((elm->type == type) && (strcmp(elm->ident, ident) == 0)) { + if(previous_elm == SYMNULL) { + tab = elm->next; + } else { + previous_elm->next = elm->next; + } + (void)free(elm->ident); + (void)free(elm); + break; + } + previous_elm = elm; + elm = elm->next; + } + + return tab; +} + +void check(struct symbol *tab, char *ident, short type) +{ + struct symbol *elm; +#ifdef DD + fprintf(stderr, "check: tab(%08X), ident(%s), type(%i), elm(%08X)\n", tab, ident, type, elm); +#endif + + if(type & (S_VAR | S_PARM)) { + elm = tab_lookup(tab, ident, type); + if(elm != SYMNULL) { + return; + } + } + + /* keine passende variable gefunden? + * => vllt gibt es ja ein passenden feldnamen */ + elm = tab_lookup(tab, ident, S_FIELD); + if(elm == SYMNULL) { + fprintf(stderr, "Unbekannter Identifier: \"%s\"\n", ident); + exit(3); + } +} + diff --git a/gesamt_arm/symtable.h b/gesamt_arm/symtable.h new file mode 100644 index 0000000..9892899 --- /dev/null +++ b/gesamt_arm/symtable.h @@ -0,0 +1,26 @@ +#ifndef SYMTABLE_H +#define SYMTABLE_H + +#define S_FIELD (1<<0) +#define S_VAR (1<<1) +#define S_PARM (1<<2) + +#define SYMNULL (struct symbol *)NULL + +struct symbol { + char *ident; + struct symbol *next; + short type; + int param_index; + int soffset; +}; + +struct symbol *tab_clone(struct symbol *tab); +struct symbol *tab_new(void); +struct symbol *tab_add_symbol(struct symbol *tab, char *ident, short type, short check, int param_index, int soffset); +struct symbol *tab_lookup(struct symbol *tab, char *ident, short type); +struct symbol *tab_remove_symbol(struct symbol *tab, char *ident, short type); +struct symbol *tab_merge(struct symbol *tab, struct symbol *to_add, short check); +void check(struct symbol *tab, char *ident, short type); + +#endif diff --git a/gesamt_arm/tree.c b/gesamt_arm/tree.c new file mode 100644 index 0000000..7d70718 --- /dev/null +++ b/gesamt_arm/tree.c @@ -0,0 +1,149 @@ +#include +#include +#include +#include "tree.h" + +#if 0 +#define DDTREE +#endif + +static struct treenode *_new_plain(int op) +{ + struct treenode *new = (TREECAST) malloc(TREESIZE); + new->op = op; + new->kids[0] = new->kids[1] = TREENULL; + new->parent = TREENULL; + new->label = NULL; + new->name = new->reg = (char *)NULL; + new->val = new->paramges = new->vars = 0; + new->param_index = -1; + return new; +} + +struct treenode *new_nothing(void) +{ + return new_node(O_NOTHING, TREENULL, TREENULL); +} + +struct treenode *new_node(int op, struct treenode *l, struct treenode *r) +{ + struct treenode *new = TREENULL; + +#ifdef DDTREE + fprintf(stderr, "new_node: %i (%s)\n", op, o_names[op]); +#endif + if(op == O_SUB && l != TREENULL && r != TREENULL && l->op == O_NUM && r->op == O_NUM) { + new = new_number(l->val - r->val); + free(l); free(r); + } else { + new = _new_plain(op); + new->kids[0] = l; + new->kids[1] = r; + } + new->name = (char *)NULL; + return new; +} + +struct treenode *new_param(int op, char *name, struct treenode *l, struct treenode *r, int param_index) +{ + struct treenode *new = new_node(op, l, r); + +#ifdef DDTREE + fprintf(stderr, "new_param: %i (index)\n", param_index); +#endif + new->param_index = param_index; + new->name = name; + return new; +} + +struct treenode *new_field(char *name, struct treenode *l, struct treenode *r, int soffset) +{ + struct treenode *new = new_node(O_FIELD, l, r); + +#ifdef DDTREE + fprintf(stderr, "new_field: %i (soffset)\n", soffset); +#endif + new->soffset = soffset; + new->name = name; + return new; +} + +struct treenode *new_arg(struct treenode *l, struct treenode *r, int soffset) +{ + struct treenode *new = new_node(O_ARG, l, r); + +#ifdef DDTREE + fprintf(stderr, "new_arg: %i (soffset)\n", soffset); +#endif + new->soffset = soffset; + new->name = (char *) malloc(10); + sprintf(new->name, "%i", soffset); + return new; +} + +struct treenode *new_call(char *name, struct treenode *l, struct treenode *r, int paramges, int vars) +{ + struct treenode *new = new_node(O_CALL, l, r); + +#ifdef DDTREE + fprintf(stderr, "new_call\n"); +#endif + new->name = name; + new->paramges = paramges; + new->vars = vars; + return new; +} + +struct treenode *new_number(long val) +{ + struct treenode *new; + /* TODO: maximal groesse? */ +#define BUFMAX 40 + char *t = (char*) malloc(BUFMAX); + + if (val == 0) { + new = _new_plain(O_NULL); + } else if(val == -1) { + new = _new_plain(O_MONE); + } else if(val == -2) { + new = _new_plain(O_MTWO); + } else if(val == -4) { + new = _new_plain(O_MFOUR); + } else if(val == -8) { + new = _new_plain(O_MEIGHT); + } else { + new = _new_plain(O_NUM); + } + +#ifdef DDTREE + fprintf(stderr, "new_number: %i\n", val); +#endif + new->val = val; + memset(t, 0, BUFMAX); + sprintf(t, "%li", val); + new->name = t; + + return new; +} + +static void write_indent(int i) +{ + int a; + for(a = 0; a < i; a++) { + fprintf(stderr, "| "); + } +} + +void write_tree(struct treenode *node, int indent) +{ + if(node == TREENULL) return; + write_indent(indent); + fprintf(stderr, "%s @ %%%s. \"%s\"\n", o_names[node->op], node->reg, node->name == (char*) NULL ? "" : node->name); + if(node->kids[0] != TREENULL) { + write_tree(node->kids[0], indent+1); + } + if(node->kids[1] != TREENULL) { + write_tree(node->kids[1], indent+1); + } +} + diff --git a/gesamt_arm/tree.h b/gesamt_arm/tree.h new file mode 100644 index 0000000..8a651e7 --- /dev/null +++ b/gesamt_arm/tree.h @@ -0,0 +1,60 @@ +#ifndef __TREE_H +#define __TREE_H + +#define TREENULL (struct treenode *)NULL +#define TREESIZE (sizeof(struct treenode)) +#define TREECAST struct treenode * + +#ifndef BFEHAX +typedef struct burm_state *STATEPTR_TYPE; +#endif + +enum { + O_RET=1, O_NULL, O_SUB, O_MUL, + O_OR=5, O_LESS, O_EQ, O_ID, O_ADD, + O_NUM=10, O_FIELD, O_MTWO, O_MFOUR, O_MEIGHT, + O_MONE=15, O_ASSIGN, O_IF, O_BOOL, O_CALL, + O_ARG=20, O_NOTHING, O_EXPR +}; + +static char *o_names[] = { + "", "O_RET", "O_NULL", "O_SUB", "O_MUL", + "O_OR", "O_LESS", "O_EQ", "O_ID", "O_ADD", + "O_NUM", "O_FIELD", "O_MTWO", "O_MFOUR", "O_MEIGHT", + "O_MONE", "O_ASSIGN", "O_IF", "O_BOOL", "O_CALL", + "O_ARG", "O_NOTHING", "O_EXPR" +}; + +struct treenode { + int op; + struct treenode *kids[2]; + STATEPTR_TYPE label; + char *name; + long val; + char *reg; + struct treenode *parent; + int param_index; + int soffset; + int paramges; + int vars; +}; + +typedef struct treenode *treenodep; + +#define NODEPTR_TYPE treenodep +#define OP_LABEL(p) ((p)->op) +#define LEFT_CHILD(p) ((p)->kids[0]) +#define RIGHT_CHILD(p) ((p)->kids[1]) +#define STATE_LABEL(p) ((p)->label) +#define PANIC printf + +struct treenode *new_node(int op, struct treenode *l, struct treenode *r); +struct treenode *new_number(long val); +struct treenode *new_param(int op, char *name, struct treenode *l, struct treenode *r, int param_index); +struct treenode *new_field(char *name, struct treenode *l, struct treenode *r, int soffset); +struct treenode *new_call(char *name, struct treenode *l, struct treenode *r, int paramges, int vars); +struct treenode *new_arg(struct treenode *l, struct treenode *r, int soffset); +struct treenode *new_nothing(void); +void write_tree(struct treenode *node, int ident); + +#endif -- 2.25.1