--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/progs/fun/fun_llvm.sc Sun Oct 25 01:25:01 2020 +0000
@@ -0,0 +1,255 @@
+// A Small LLVM Compiler for a Simple Functional Language
+// (includes an external lexer and parser)
+//
+// call with
+//
+// amm fun_llvm.sc write fact.fun
+//
+// amm fun_llvm.sc write defs.fun
+//
+// this will generate a .ll file. Other options are compile and run.
+//
+// You can interpret an .ll file using lli.
+//
+// The optimiser can be invoked as
+//
+// opt -O1 -S in_file.ll > out_file.ll
+// opt -O3 -S in_file.ll > out_file.ll
+//
+// The code produced for the various architectures can be obtains with
+//
+// llc -march=x86 -filetype=asm in_file.ll -o -
+// llc -march=arm -filetype=asm in_file.ll -o -
+//
+// Producing an executable can be achieved by
+//
+// llc -filetype=obj in_file.ll
+// gcc in_file.o -o a.out
+// ./a.out
+
+
+import $file.fun_tokens, fun_tokens._
+import $file.fun_parser, fun_parser._
+import scala.util._
+
+
+// for generating new labels
+var counter = -1
+
+def Fresh(x: String) = {
+ counter += 1
+ x ++ "_" ++ counter.toString()
+}
+
+// Internal CPS language for FUN
+abstract class KExp
+abstract class KVal
+
+case class KVar(s: String) extends KVal
+case class KNum(i: Int) extends KVal
+case class Kop(o: String, v1: KVal, v2: KVal) extends KVal
+case class KCall(o: String, vrs: List[KVal]) extends KVal
+case class KWrite(v: KVal) extends KVal
+
+case class KIf(x1: String, e1: KExp, e2: KExp) extends KExp {
+ override def toString = s"KIf $x1\nIF\n$e1\nELSE\n$e2"
+}
+case class KLet(x: String, e1: KVal, e2: KExp) extends KExp {
+ override def toString = s"let $x = $e1 in \n$e2"
+}
+case class KReturn(v: KVal) extends KExp
+
+
+// CPS translation from Exps to KExps using a
+// continuation k.
+def CPS(e: Exp)(k: KVal => KExp) : KExp = e match {
+ case Var(s) => k(KVar(s))
+ case Num(i) => k(KNum(i))
+ case Aop(o, e1, e2) => {
+ val z = Fresh("tmp")
+ CPS(e1)(y1 =>
+ CPS(e2)(y2 => KLet(z, Kop(o, y1, y2), k(KVar(z)))))
+ }
+ case If(Bop(o, b1, b2), e1, e2) => {
+ val z = Fresh("tmp")
+ CPS(b1)(y1 =>
+ CPS(b2)(y2 =>
+ KLet(z, Kop(o, y1, y2), KIf(z, CPS(e1)(k), CPS(e2)(k)))))
+ }
+ case Call(name, args) => {
+ def aux(args: List[Exp], vs: List[KVal]) : KExp = args match {
+ case Nil => {
+ val z = Fresh("tmp")
+ KLet(z, KCall(name, vs), k(KVar(z)))
+ }
+ case e::es => CPS(e)(y => aux(es, vs ::: List(y)))
+ }
+ aux(args, Nil)
+ }
+ case Sequence(e1, e2) =>
+ CPS(e1)(_ => CPS(e2)(y2 => k(y2)))
+ case Write(e) => {
+ val z = Fresh("tmp")
+ CPS(e)(y => KLet(z, KWrite(y), k(KVar(z))))
+ }
+}
+
+//initial continuation
+def CPSi(e: Exp) = CPS(e)(KReturn)
+
+// some testcases
+val e1 = Aop("*", Var("a"), Num(3))
+CPSi(e1)
+
+val e2 = Aop("+", Aop("*", Var("a"), Num(3)), Num(4))
+CPSi(e2)
+
+val e3 = Aop("+", Num(2), Aop("*", Var("a"), Num(3)))
+CPSi(e3)
+
+val e4 = Aop("+", Aop("-", Num(1), Num(2)), Aop("*", Var("a"), Num(3)))
+CPSi(e4)
+
+val e5 = If(Bop("==", Num(1), Num(1)), Num(3), Num(4))
+CPSi(e5)
+
+val e6 = If(Bop("!=", Num(10), Num(10)), e5, Num(40))
+CPSi(e6)
+
+val e7 = Call("foo", List(Num(3)))
+CPSi(e7)
+
+val e8 = Call("foo", List(Aop("*", Num(3), Num(1)), Num(4), Aop("+", Num(5), Num(6))))
+CPSi(e8)
+
+val e9 = Sequence(Aop("*", Var("a"), Num(3)), Aop("+", Var("b"), Num(6)))
+CPSi(e9)
+
+val e = Aop("*", Aop("+", Num(1), Call("foo", List(Var("a"), Num(3)))), Num(4))
+CPSi(e)
+
+
+
+
+// convenient string interpolations
+// for instructions, labels and methods
+import scala.language.implicitConversions
+import scala.language.reflectiveCalls
+
+implicit def sring_inters(sc: StringContext) = new {
+ def i(args: Any*): String = " " ++ sc.s(args:_*) ++ "\n"
+ def l(args: Any*): String = sc.s(args:_*) ++ ":\n"
+ def m(args: Any*): String = sc.s(args:_*) ++ "\n"
+}
+
+// mathematical and boolean operations
+def compile_op(op: String) = op match {
+ case "+" => "add i32 "
+ case "*" => "mul i32 "
+ case "-" => "sub i32 "
+ case "/" => "sdiv i32 "
+ case "%" => "srem i32 "
+ case "==" => "icmp eq i32 "
+ case "<=" => "icmp sle i32 " // signed less or equal
+ case "<" => "icmp slt i32 " // signed less than
+}
+
+def compile_val(v: KVal) : String = v match {
+ case KNum(i) => s"$i"
+ case KVar(s) => s"%$s"
+ case Kop(op, x1, x2) =>
+ s"${compile_op(op)} ${compile_val(x1)}, ${compile_val(x2)}"
+ case KCall(x1, args) =>
+ s"call i32 @$x1 (${args.map(compile_val).mkString("i32 ", ", i32 ", "")})"
+ case KWrite(x1) =>
+ s"call i32 @printInt (i32 ${compile_val(x1)})"
+}
+
+// compile K expressions
+def compile_exp(a: KExp) : String = a match {
+ case KReturn(v) =>
+ i"ret i32 ${compile_val(v)}"
+ case KLet(x: String, v: KVal, e: KExp) =>
+ i"%$x = ${compile_val(v)}" ++ compile_exp(e)
+ case KIf(x, e1, e2) => {
+ val if_br = Fresh("if_branch")
+ val else_br = Fresh("else_branch")
+ i"br i1 %$x, label %$if_br, label %$else_br" ++
+ l"\n$if_br" ++
+ compile_exp(e1) ++
+ l"\n$else_br" ++
+ compile_exp(e2)
+ }
+}
+
+
+val prelude = """
+@.str = private constant [4 x i8] c"%d\0A\00"
+
+declare i32 @printf(i8*, ...)
+
+define i32 @printInt(i32 %x) {
+ %t0 = getelementptr [4 x i8], [4 x i8]* @.str, i32 0, i32 0
+ call i32 (i8*, ...) @printf(i8* %t0, i32 %x)
+ ret i32 %x
+}
+
+"""
+
+
+// compile function for declarations and main
+def compile_decl(d: Decl) : String = d match {
+ case Def(name, args, body) => {
+ m"define i32 @$name (${args.mkString("i32 %", ", i32 %", "")}) {" ++
+ compile_exp(CPSi(body)) ++
+ m"}\n"
+ }
+ case Main(body) => {
+ m"define i32 @main() {" ++
+ compile_exp(CPS(body)(_ => KReturn(KNum(0)))) ++
+ m"}\n"
+ }
+}
+
+// main compiler functions
+
+def compile_prog(prog: List[Decl]) : String =
+ prelude ++ (prog.map(compile_decl).mkString)
+
+
+@main
+def compile(fname: String) = {
+ val path = os.pwd / fname
+ val file = fname.stripSuffix("." ++ path.ext)
+ val tks = tokenise(os.read(path))
+ val ast = parse_tks(tks)
+ println(compile_prog(ast))
+}
+
+@main
+def write(fname: String) = {
+ val path = os.pwd / fname
+ val file = fname.stripSuffix("." ++ path.ext)
+ val tks = tokenise(os.read(path))
+ val ast = parse_tks(tks)
+ val code = compile_prog(ast)
+ os.write.over(os.pwd / (file ++ ".ll"), code)
+}
+
+@main
+def run(fname: String) = {
+ val path = os.pwd / fname
+ val file = fname.stripSuffix("." ++ path.ext)
+ val tks = tokenise(os.read(path))
+ val ast = parse_tks(tks)
+ val code = compile_prog(ast)
+ os.write.over(os.pwd / (file ++ ".ll"), code)
+ os.proc("llc", "-filetype=obj", file ++ ".ll").call()
+ os.proc("gcc", file ++ ".o", "-o", file).call()
+ print(os.proc(os.pwd / file).call().out.string)
+}
+
+
+
+
+