projects/dang: gen/CodeGen.d annotate

annotate gen/CodeGen.d @ 92:771ac63898e2 new_gen

A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot.

author	Anders Johnsen <skabet@gmail.com>
date	Mon, 05 May 2008 18:44:20 +0200
parents	a49bb982a7b0
children	621cedba53ea

rev	line source
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1 module gen.CodeGen;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	2
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	3 import tango.io.Stdout,
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	4 Int = tango.text.convert.Integer;
54 d84fec04d462 Move all root var-decls so they are generated before anything else Anders Halager <halager@gmail.com> parents: 53 diff changeset	5 import tango.core.Array : find, partition;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	6
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	7 import llvm.llvm;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	8
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	9 import ast.Decl,
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	10 ast.Stmt,
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	11 ast.Exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	12
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 57 diff changeset	13 import misc.Error,
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 57 diff changeset	14 basic.SmallArray;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	15
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	16 import lexer.Token;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	17
92 771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	18 import sema.Scope,
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	19 sema.Visitor;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	20
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	21 private char[] genBuildCmp(char[] p)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	22 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	23 return `
66 c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	24 Value build`~p~`(Value l, Value r, char[] n)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	25 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	26 return b.buildICmp(IntPredicate.`~p~`, l, r, n);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	27 }`;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	28 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	29
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	30 class CodeGen
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	31 {
66 c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	32 private:
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	33 mixin(genBuildCmp("EQ"));
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	34 mixin(genBuildCmp("NE"));
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	35 mixin(genBuildCmp("SLT"));
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	36 mixin(genBuildCmp("SLE"));
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	37 mixin(genBuildCmp("SGT"));
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	38 mixin(genBuildCmp("SGE"));
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	39
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	40 public:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	41 this()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	42 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	43 alias BinaryExp.Operator op;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	44 b = new Builder;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	45
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	46 opToLLVM = [
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	47 op.Add : &b.buildAdd,
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	48 op.Sub : &b.buildSub,
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	49 op.Mul : &b.buildMul,
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	50 op.Div : &b.buildSDiv,
66 c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	51 op.Eq : &buildEQ,
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	52 op.Ne : &buildNE,
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	53 op.Lt : &buildSLT,
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	54 op.Le : &buildSLE,
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	55 op.Gt : &buildSGT,
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	56 op.Ge : &buildSGE
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	57 ];
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	58 table = new SimpleSymbolTable();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	59
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	60 createBasicTypes();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	61 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	62
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	63 ~this()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	64 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	65 b.dispose();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	66 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	67
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	68 void gen(Decl[] decls, uint handle, bool optimize, bool inline)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	69 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	70 // create module
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	71 m = new Module("main_module");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	72 scope(exit) m.dispose();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	73
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	74 table.enterScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	75
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	76 BytePtr = PointerType.Get(Type.Int8);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	77 auto temp = FunctionType.Get(Type.Void, [BytePtr, BytePtr, Type.Int32, Type.Int32]);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	78 llvm_memcpy = m.addFunction(temp, "llvm.memcpy.i32");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	79
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	80 auto registerFunc =
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	81 (FuncDecl fd)
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	82 {
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	83 Type[] param_types;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	84 foreach (i, p; fd.funcArgs)
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	85 {
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	86 DType t = p.env.find(p.identifier).type;
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	87 if(auto st = t.asStruct)
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	88 {
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	89 Type pointer = PointerType.Get(llvm(st));
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	90 param_types ~= pointer;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	91 }
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	92 else if(auto ar = t.asArray)
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	93 {
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	94 Type pointer = PointerType.Get(llvm(ar));
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	95 param_types ~= pointer;
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	96 }
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	97 else
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	98 param_types ~= llvm(t);
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	99 }
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	100 auto ret_t = fd.env.find(fd.identifier).type;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	101 if(auto st = cast(DStruct)ret_t)
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	102 ret_t = DType.Void;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	103 else if(auto f = cast(DFunction)ret_t)
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	104 ret_t = f.returnType;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	105 auto func_t = FunctionType.Get(llvm(ret_t), param_types);
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	106 auto llfunc = m.addFunction(func_t, fd.identifier.get);
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	107
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	108 foreach (i, p; fd.funcArgs)
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	109 {
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	110 if(i == 0 && fd.sret)
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	111 llfunc.addParamAttr(0, ParamAttr.StructRet);
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	112
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	113 DType t = p.env.find(p.identifier).type;
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	114 if(auto st = t.asStruct)
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	115 {
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	116 if(i == 0 && fd.sret)
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	117 continue;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	118 llfunc.addParamAttr(i,ParamAttr.ByVal);
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	119 }
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	120 else if(auto ar = t.asArray)
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	121 {
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	122 llfunc.addParamAttr(i,ParamAttr.ByVal);
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	123 }
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	124 }
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	125 };
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	126 auto visitor = new VisitFuncDecls(registerFunc);
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	127 visitor.visit(decls);
54 d84fec04d462 Move all root var-decls so they are generated before anything else Anders Halager <halager@gmail.com> parents: 53 diff changeset	128 // Before beginning we move all top level var-decls to the start
d84fec04d462 Move all root var-decls so they are generated before anything else Anders Halager <halager@gmail.com> parents: 53 diff changeset	129 // and then we generate the var-decls first
d84fec04d462 Move all root var-decls so they are generated before anything else Anders Halager <halager@gmail.com> parents: 53 diff changeset	130 // partition is NOT required to be stable, but that should not create
d84fec04d462 Move all root var-decls so they are generated before anything else Anders Halager <halager@gmail.com> parents: 53 diff changeset	131 // any problems.
d84fec04d462 Move all root var-decls so they are generated before anything else Anders Halager <halager@gmail.com> parents: 53 diff changeset	132 partition(decls, (Decl d) { return d.declType == DeclType.VarDecl; });
d84fec04d462 Move all root var-decls so they are generated before anything else Anders Halager <halager@gmail.com> parents: 53 diff changeset	133
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	134 foreach (decl; decls)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	135 genRootDecl(decl);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	136
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	137 table.leaveScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	138
92 771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	139 // debug m.verify();
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	140
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	141 if(optimize)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	142 m.optimize(inline);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	143
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	144 m.writeBitcodeToFileHandle(handle);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	145 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	146
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	147 void genRootDecl(Decl decl)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	148 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	149 switch(decl.declType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	150 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	151 case DeclType.FuncDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	152 FuncDecl funcDecl = cast(FuncDecl)decl;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	153
82 06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	154 // Empty function - declare;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	155 if(funcDecl.emptyFunction)
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	156 return;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	157
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	158 llvm(funcDecl.type);
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	159 auto llfunc = m.getNamedFunction(funcDecl.type.name);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	160 auto func_tp = cast(PointerType)llfunc.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	161 auto func_t = cast(FunctionType)func_tp.elementType();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	162 auto ret_t = func_t.returnType();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	163
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	164
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	165 auto bb = llfunc.appendBasicBlock("entry");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	166 b.positionAtEnd(bb);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	167
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	168 table.enterScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	169 foreach (i, v; funcDecl.funcArgs)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	170 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	171 llfunc.getParam(i).name = v.identifier.get;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	172 auto name = v.identifier.get;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	173 if(!cast(PointerType)llfunc.getParam(i).type)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	174 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	175 auto AI = b.buildAlloca(llfunc.getParam(i).type, name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	176 // Value va = b.buildLoad(val, name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	177 b.buildStore(llfunc.getParam(i), AI);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	178 table[name] = AI;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	179 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	180 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	181 table[name] = llfunc.getParam(i);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	182 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	183
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	184 foreach (stmt; funcDecl.statements)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	185 genStmt(stmt);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	186
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	187 // if the function didn't end with a return, we automatically
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	188 // add one (return 0 as default)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	189 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	190 if (ret_t is Type.Void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	191 b.buildRetVoid();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	192 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	193 b.buildRet(ConstantInt.GetS(ret_t, 0));
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	194
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	195 table.leaveScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	196 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	197
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	198 case DeclType.VarDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	199 auto varDecl = cast(VarDecl)decl;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	200 auto sym = varDecl.env.find(varDecl.identifier);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	201 Type t = llvm(sym.type);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	202 GlobalVariable g = m.addGlobal(t, sym.id.get);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	203 g.initializer = ConstantInt.GetS(t, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	204 table[varDecl.identifier.get] = g;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	205 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	206
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	207 case DeclType.StructDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	208 auto structDecl = cast(StructDecl)decl;
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	209 llvm(structDecl.type);
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	210 //m.addTypeName(structDecl.identifier.get, llvm(structDecl.type));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	211 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	212
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	213 default:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	214 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	215 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	216 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	217
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	218 void genDecl(Decl decl)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	219 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	220 switch(decl.declType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	221 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	222 case DeclType.VarDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	223 auto varDecl = cast(VarDecl)decl;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	224 auto name = varDecl.identifier.get;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	225 auto sym = varDecl.env.find(varDecl.identifier);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	226 auto AI = b.buildAlloca(llvm(sym.type), name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	227 table[name] = AI;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	228 if (varDecl.init)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	229 buildAssign(varDecl.identifier, varDecl.init);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	230 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	231
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	232 default:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	233 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	234 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	235
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	236 struct PE
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	237 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	238 static char[] NoImplicitConversion =
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	239 "Can't find an implicit conversion between %0 and %1";
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	240 static char[] VoidRetInNonVoidFunc =
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	241 "Only void functions can return without an expression";
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	242 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	243
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	244 void sextSmallerToLarger(ref Value left, ref Value right)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	245 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	246 if (left.type != right.type)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	247 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	248 // try to find a convertion - only works for iX
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	249 IntegerType l = cast(IntegerType) left.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	250 IntegerType r = cast(IntegerType) right.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	251 if (l is null \|\| r is null)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	252 throw error(__LINE__, PE.NoImplicitConversion)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	253 .arg(left.type.toString)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	254 .arg(right.type.toString);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	255
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	256 if (l.numBits() < r.numBits())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	257 left = b.buildSExt(left, r, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	258 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	259 right = b.buildSExt(right, l, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	260 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	261 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	262
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	263 Value genExpression(Exp exp)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	264 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	265 switch(exp.expType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	266 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	267 case ExpType.Binary:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	268 auto binaryExp = cast(BinaryExp)exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	269
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	270 auto left = genExpression(binaryExp.left);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	271 auto right = genExpression(binaryExp.right);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	272
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	273 // sextSmallerToLarger(left, right);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	274
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	275 OpBuilder op = opToLLVM[binaryExp.op];
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	276
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	277 return op(left, right, ".");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	278
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	279 case ExpType.IntegerLit:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	280 auto integetLit = cast(IntegerLit)exp;
67 3fdf20b08a81 Been working on the floating point parsing. Still a bit of work to do here. Anders Johnsen <skabet@gmail.com> parents: 66 diff changeset	281 auto val = integetLit.get;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	282 return ConstantInt.GetS(Type.Int32, Integer.parse(val));
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	283 case ExpType.Negate:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	284 auto negateExp = cast(NegateExp)exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	285 auto target = genExpression(negateExp.exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	286 return b.buildNeg(target, "neg");
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	287 case ExpType.Deref:
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	288 auto derefExp = cast(DerefExp)exp;
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	289 auto target = genExpression(derefExp.exp);
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	290 return b.buildLoad(target, "deref");
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	291 case ExpType.AssignExp:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	292 auto assignExp = cast(AssignExp)exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	293 return buildAssign(assignExp.identifier, assignExp.exp);
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	294 case ExpType.Index:
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	295 auto indexExp = cast(IndexExp)exp;
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	296 return b.buildLoad(getPointer(exp), ".");
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	297 case ExpType.CallExp:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	298 auto callExp = cast(CallExp)exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	299 auto func_sym = exp.env.find(cast(Identifier)callExp.exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	300 Value[] args;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	301 foreach (arg; callExp.args)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	302 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	303 Value v = genExpression(arg);
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	304 args ~= v;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	305
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	306 }
52 6decab6f45c4 Two new tests that uncovered a bug - we dont to type conversion when calling functions Anders Halager <halager@gmail.com> parents: 51 diff changeset	307 // BUG: doesn't do implicit type-conversion
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	308 if(callExp.sret)
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	309 return b.buildCall(m.getNamedFunction(func_sym.id.get), args, "");
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	310 return b.buildCall(m.getNamedFunction(func_sym.id.get), args, ".call");
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	311 case ExpType.CastExp:
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	312 auto castExp = cast(CastExp)exp;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	313 auto value = genExpression(castExp.exp);
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	314
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	315 if(!castExp.type.hasImplicitConversionTo(castExp.type))
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	316 assert(0, "Invalid cast");
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	317
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	318 Value v;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	319 if(castExp.exp.type.byteSize <= castExp.type.byteSize)
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	320 v = b.buildZExt(value, llvm(castExp.type), "cast");
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	321 else
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	322 v = b.buildTrunc(value, llvm(castExp.type), "cast");
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	323
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	324 return v;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	325
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	326 case ExpType.Identifier:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	327 auto identifier = cast(Identifier)exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	328 auto sym = exp.env.find(identifier);
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	329 if(sym.type.isStruct \|\| sym.type.isArray)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	330 return table.find(sym.id.get);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	331 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	332 return b.buildLoad(table.find(sym.id.get), sym.id.get);
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	333 case ExpType.MemberReference:
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	334 auto v = getPointer(exp);
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	335 // return v;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	336 return b.buildLoad(v, v.name);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	337 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	338 assert(0, "Reached end of switch in genExpression");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	339 return null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	340 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	341
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	342 void genStmt(Stmt stmt)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	343 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	344 switch(stmt.stmtType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	345 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	346 case StmtType.Compound:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	347 auto stmts = cast(CompoundStatement)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	348 foreach (s; stmts.statements)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	349 genStmt(s);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	350 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	351 case StmtType.Return:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	352 auto ret = cast(ReturnStmt)stmt;
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	353 DFunction type = stmt.env.parentFunction().type();
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	354 Type t = llvm(type.returnType);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	355 if (ret.exp is null)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	356 if (t is Type.Void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	357 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	358 b.buildRetVoid();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	359 return;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	360 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	361 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	362 throw error(__LINE__, PE.VoidRetInNonVoidFunc);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	363
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	364 Value v = genExpression(ret.exp);
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	365 /* if (v.type != t)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	366 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	367 IntegerType v_t = cast(IntegerType) v.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	368 IntegerType i_t = cast(IntegerType) t;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	369 if (v_t is null \|\| i_t is null)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	370 throw error(__LINE__, PE.NoImplicitConversion)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	371 .arg(v.type.toString)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	372 .arg(t.toString);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	373
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	374 if (v_t.numBits() < i_t.numBits())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	375 v = b.buildSExt(v, t, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	376 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	377 v = b.buildTrunc(v, t, ".cast");
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	378 }*/
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	379 b.buildRet(v);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	380 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	381 case StmtType.Decl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	382 auto declStmt = cast(DeclStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	383 genDecl(declStmt.decl);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	384 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	385 case StmtType.Exp:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	386 auto expStmt = cast(ExpStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	387 genExpression(expStmt.exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	388 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	389 case StmtType.If:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	390 auto ifStmt = cast(IfStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	391 Value cond = genExpression(ifStmt.cond);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	392 if (cond.type !is Type.Int1)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	393 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	394 Value False = ConstantInt.GetS(cond.type, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	395 cond = b.buildICmp(IntPredicate.NE, cond, False, ".cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	396 }
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	397 auto func_name = stmt.env.parentFunction().identifier.get;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	398 Function func = m.getNamedFunction(func_name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	399 bool has_else = (ifStmt.else_body !is null);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	400
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	401 auto thenBB = func.appendBasicBlock("then");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	402 auto elseBB = has_else? func.appendBasicBlock("else") : null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	403 auto mergeBB = func.appendBasicBlock("merge");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	404
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	405 b.buildCondBr(cond, thenBB, has_else? elseBB : mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	406 b.positionAtEnd(thenBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	407 genStmt(ifStmt.then_body);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	408 thenBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	409 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	410 b.buildBr(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	411
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	412 if (has_else)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	413 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	414 b.positionAtEnd(elseBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	415 genStmt(ifStmt.else_body);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	416 elseBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	417 if (elseBB.terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	418 b.buildBr(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	419 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	420
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	421 b.positionAtEnd(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	422 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	423 case StmtType.While:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	424 auto wStmt = cast(WhileStmt)stmt;
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	425 auto func_name = stmt.env.parentFunction().identifier.get;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	426 Function func = m.getNamedFunction(func_name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	427
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	428 auto condBB = func.appendBasicBlock("cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	429 auto bodyBB = func.appendBasicBlock("body");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	430 auto doneBB = func.appendBasicBlock("done");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	431
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	432 b.buildBr(condBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	433 b.positionAtEnd(condBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	434 Value cond = genExpression(wStmt.cond);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	435 if (cond.type !is Type.Int1)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	436 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	437 Value False = ConstantInt.GetS(cond.type, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	438 cond = b.buildICmp(IntPredicate.NE, cond, False, ".cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	439 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	440 b.buildCondBr(cond, bodyBB, doneBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	441
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	442 b.positionAtEnd(bodyBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	443 genStmt(wStmt.whileBody);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	444 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	445 b.buildBr(condBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	446
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	447 b.positionAtEnd(doneBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	448 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	449 case StmtType.Switch:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	450 auto sw = cast(SwitchStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	451 Value cond = genExpression(sw.cond);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	452
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	453 auto func_name = stmt.env.parentFunction().identifier.get;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	454 Function func = m.getNamedFunction(func_name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	455
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	456 BasicBlock oldBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	457 BasicBlock defBB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	458 BasicBlock endBB = func.appendBasicBlock("sw.end");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	459 if (sw.defaultBlock)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	460 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	461 defBB = Function.InsertBasicBlock(endBB, "sw.def");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	462 b.positionAtEnd(defBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	463 foreach (case_statement; sw.defaultBlock)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	464 genStmt(case_statement);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	465 if (!defBB.terminated())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	466 b.buildBr(endBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	467 b.positionAtEnd(oldBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	468 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	469 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	470 defBB = endBB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	471 auto SI = b.buildSwitch(cond, defBB, sw.cases.length);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	472 foreach (c; sw.cases)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	473 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	474 BasicBlock prevBB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	475 foreach (i, val; c.values)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	476 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	477 auto BB = Function.InsertBasicBlock(defBB, "sw.bb");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	478 SI.addCase(ConstantInt.GetS(cond.type, c.values_converted[i]), BB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	479
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	480 if (i + 1 == c.values.length)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	481 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	482 b.positionAtEnd(BB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	483 foreach (case_statement; c.stmts)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	484 genStmt(case_statement);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	485 if (!BB.terminated())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	486 b.buildBr(c.followedByDefault? defBB : endBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	487 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	488
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	489 if (prevBB !is null && !prevBB.terminated())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	490 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	491 b.positionAtEnd(prevBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	492 b.buildBr(BB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	493 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	494 prevBB = BB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	495 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	496 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	497 b.positionAtEnd(endBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	498 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	499 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	500 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	501
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	502 Value getPointer(Exp exp)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	503 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	504 switch(exp.expType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	505 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	506 case ExpType.Identifier:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	507 auto identifier = cast(Identifier)exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	508 auto sym = exp.env.find(identifier);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	509 return table.find(sym.id.get);
80 682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	510 case ExpType.Deref:
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	511 auto derefExp = cast(DerefExp)exp;
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	512 auto target = getPointer(derefExp.exp);
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	513 return b.buildLoad(target, "deref");
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	514 case ExpType.Index:
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	515 auto indexExp = cast(IndexExp)exp;
85 9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	516 auto type = indexExp.target.type;
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	517 auto index = genExpression(indexExp.index);
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	518 Value[2] gep_indices;
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	519 gep_indices[0] = ConstantInt.Get(IntegerType.Int32, 0, false);
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	520 gep_indices[1] = index;
85 9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	521 if (type.isArray())
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	522 {
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	523 auto array = getPointer(indexExp.target);
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	524 return b.buildGEP(array, gep_indices[0 .. 2], "index");
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	525 }
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	526 else if (type.isPointer())
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	527 {
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	528 auto array = genExpression(indexExp.target);
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	529 return b.buildGEP(array, gep_indices[1 .. 2], "index");
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	530 }
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	531 else assert(0, "Can only index pointers and arrays");
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	532 case ExpType.MemberReference:
79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	533 auto mem = cast(MemberReference)exp;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	534 switch(mem.target.expType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	535 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	536 case ExpType.Identifier:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	537 auto identifier = cast(Identifier)mem.target;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	538 auto child = mem.child;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	539 auto sym = exp.env.find(identifier);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	540 auto symChild = child.env.find(child);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	541 Value v = table.find(sym.id.get);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	542 DType t = sym.type;
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	543 auto st = t.asStruct;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	544
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	545 int i = st.indexOf(child.get);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	546
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	547 Value[] vals;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	548 vals ~= ConstantInt.Get(IntegerType.Int32, 0, false);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	549 vals ~= ConstantInt.Get(IntegerType.Int32, i, false);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	550
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	551 Value val = b.buildGEP(v, vals, sym.id.get~"."~child.get);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	552 return val;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	553
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	554 case ExpType.MemberReference:
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	555 auto v = getPointer(mem.target);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	556 auto child = mem.child;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	557 auto symChild = child.env.find(child);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	558 DType t = mem.target.type;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	559 auto st = t.asStruct;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	560
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	561 int i = st.indexOf(child.get);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	562
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	563 Value[] vals;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	564 vals ~= ConstantInt.Get(IntegerType.Int32, 0, false);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	565 vals ~= ConstantInt.Get(IntegerType.Int32, i, false);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	566
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	567 Value val = b.buildGEP(v, vals, "."~child.get);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	568 return val;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	569
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	570 default:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	571 Value val = genExpression(exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	572 auto AI = b.buildAlloca(val.type, ".s");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	573 return b.buildStore(val, AI);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	574 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	575 default:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	576 Value val = genExpression(exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	577 auto AI = b.buildAlloca(val.type, ".s");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	578 return b.buildStore(val, AI);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	579 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	580 assert(0, "Reached end of switch in getPointer");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	581 return null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	582 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	583
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	584 private Value buildAssign(Exp target, Exp exp)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	585 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	586 Value t = getPointer(target);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	587 Value v = genExpression(exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	588
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	589 auto a = cast(PointerType)t.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	590
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	591 assert(a, "Assing to type have to be of type PointerType");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	592
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	593 Type value_type = v.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	594 if (auto value_ptr = cast(PointerType)v.type)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	595 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	596 value_type = value_ptr.elementType;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	597
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	598 if (a.elementType is value_type && cast(StructType)value_type)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	599 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	600 // bitcast "from" to i8*
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	601 Value from = b.buildBitCast(v, BytePtr, ".copy_from");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	602 // bitcast "to" to i8*
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	603 Value to = b.buildBitCast(t, BytePtr, ".copy_to");
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	604 // call llvm.memcpy.i32( "to", "from", type_size, alignment (32 in clang) );
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	605 b.buildCall(llvm_memcpy, [to, from, ConstantInt.GetS(Type.Int32, 4), ConstantInt.GetS(Type.Int32, 32)], null);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	606 // return "to"
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	607 return t;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	608 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	609 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	610
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	611 if (value_type != a.elementType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	612 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	613 IntegerType v_t = cast(IntegerType) value_type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	614 IntegerType i_t = cast(IntegerType) a.elementType;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	615 if (v_t is null \|\| i_t is null)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	616 throw error(__LINE__, PE.NoImplicitConversion)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	617 .arg(a.elementType.toString)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	618 .arg(v.type.toString);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	619
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	620 if (v_t.numBits() < i_t.numBits())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	621 v = b.buildSExt(v, a.elementType, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	622 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	623 v = b.buildTrunc(v, a.elementType, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	624 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	625 return b.buildStore(v, t);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	626 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	627
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	628 Error error(uint line, char[] msg)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	629 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	630 return new Error(msg);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	631 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	632
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	633 /**
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	634 Get the LLVM Type corresponding to a DType.
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	635
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	636 Currently using the built-in associative array - not sure if it works
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	637 well when the hashes are so uniform.
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	638
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	639 Other possibilities would be to find a hash-function that works on
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	640 something as small as 4 bytes or to create a sparse array perhaps.
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	641 */
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	642 Type llvm(DType t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	643 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	644 if (auto llvm_t = t in type_map)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	645 return *llvm_t;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	646 return llvmCreateNew(t);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	647 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	648
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	649 // Create an LLVM type and insert it into the type map, and return the
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	650 // result
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	651 Type llvmCreateNew(DType t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	652 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	653 if (auto i = cast(DInteger)t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	654 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	655 Type res = IntegerType.Get(i.byteSize() * 8);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	656 type_map[t] = res;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	657 return res;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	658 }
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	659 else if (auto s = t.asStruct)
53 da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 52 diff changeset	660 {
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 57 diff changeset	661 SmallArray!(Type, 8) members;
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	662 DType[] array;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	663 array.length = s.members.length;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	664
53 da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 52 diff changeset	665 foreach(m; s.members)
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	666 array[m.index] = m.type;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	667
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	668 foreach(m; array)
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	669 members ~= llvm(m);
53 da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 52 diff changeset	670
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 57 diff changeset	671 Type res = StructType.Get(members.unsafe());
53 da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 52 diff changeset	672 type_map[t] = res;
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	673 m.addTypeName(s.name, res);
53 da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 52 diff changeset	674 return res;
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 52 diff changeset	675 }
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	676 else if (auto f = t.asFunction)
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	677 {
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	678 // We should never have a function returning structs, because of
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	679 // the simplify step
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	680 assert(f.returnType.isStruct() == false, "Can't return structs");
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	681 Type ret_t = llvm(f.returnType);
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	682
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	683 SmallArray!(Type, 8) params;
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	684 foreach(param; f.params)
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	685 if (param.isStruct)
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	686 params ~= PointerType.Get(llvm(param));
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	687 else if (param.isArray)
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	688 params ~= PointerType.Get(llvm(param));
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	689 else
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	690 params ~= llvm(param);
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	691
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	692 Type res = FunctionType.Get(ret_t, params.unsafe());
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	693 type_map[t] = res;
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	694 /* auto llfunc = m.addFunction(res, f.name);
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	695
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	696 foreach (i, param; f.params)
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	697 if (param.isStruct)
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	698 llfunc.addParamAttr(i, ParamAttr.ByVal);
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	699
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	700 if (f.firstParamIsReturnValue)
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	701 {
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	702 llfunc.removeParamAttr(0, ParamAttr.ByVal);
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	703 llfunc.addParamAttr(0, ParamAttr.StructRet);
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	704 }
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	705 */
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	706 return res;
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	707 }
77 13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	708 else if (auto f = t.asPointer)
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	709 {
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	710 Type res = PointerType.Get(llvm(f.pointerOf));
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	711 type_map[t] = res;
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	712 return res;
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	713 }
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	714 else if (auto f = t.asArray)
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	715 {
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	716 Type res = ArrayType.Get(llvm(f.arrayOf), f.size);
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	717 type_map[t] = res;
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	718 return res;
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	719 }
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	720 assert(0, "Only integers, structs and functions are supported");
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	721 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	722
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	723 // Might as well insert all the basic types from the start
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	724 void createBasicTypes()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	725 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	726 type_map[DType.Void] = Type.Void;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	727
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	728 type_map[DType.Bool] = Type.Int1;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	729 type_map[DType.Byte] = Type.Int8;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	730 type_map[DType.UByte] = Type.Int8;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	731 type_map[DType.Short] = Type.Int16;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	732 type_map[DType.UShort] = Type.Int16;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	733 type_map[DType.Int] = Type.Int32;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	734 type_map[DType.UInt] = Type.Int32;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	735 type_map[DType.Long] = Type.Int64;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	736 type_map[DType.ULong] = Type.Int64;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	737 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	738
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	739 private:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	740
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	741 // llvm stuff
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	742 Module m;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	743 Builder b;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	744 Function llvm_memcpy;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	745 Type BytePtr;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	746 Type[DType] type_map;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	747
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	748 FuncDecl[char[]] functions;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	749
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	750 SimpleSymbolTable table;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	751 alias Value delegate(Value, Value, char[]) OpBuilder;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	752 static OpBuilder[BinaryExp.Operator] opToLLVM;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	753 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	754
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	755 private class VisitFuncDecls : Visitor!(void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	756 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	757 void delegate(FuncDecl) dg;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	758 this(void delegate(FuncDecl funcDecl) dg)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	759 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	760 this.dg = dg;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	761 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	762
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	763 override void visit(Decl[] decls)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	764 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	765 foreach (decl; decls)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	766 if (auto f = cast(FuncDecl)decl)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	767 dg(f);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	768 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	769 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	770
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	771 private class SimpleSymbolTable
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	772 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	773 Value[char[]][] namedValues;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	774
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	775 void enterScope()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	776 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	777 namedValues ~= cast(Value[char[]])["__dollar":null];
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	778 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	779
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	780 void leaveScope()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	781 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	782 namedValues.length = namedValues.length - 1;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	783 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	784
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	785 Value put(Value val, char[] key)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	786 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	787 namedValues[$ - 1][key] = val;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	788 return val;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	789 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	790
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	791 Value find(char[] key)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	792 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	793 foreach_reverse (map; namedValues)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	794 if(auto val_ptr = key in map)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	795 return *val_ptr;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	796 return null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	797 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	798
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	799 alias find opIndex;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	800 alias put opIndexAssign;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	801 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	802

Mercurial > projects > dang

annotate gen/CodeGen.d @ 92:771ac63898e2 new_gen