projects/dang: gen/CodeGen.d annotate

annotate gen/CodeGen.d @ 101:fea8d61a2451 new_gen

First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)

author	Anders Johnsen <skabet@gmail.com>
date	Wed, 07 May 2008 19:58:13 +0200
parents	7f9240d4ddc1
children	189c049cbfcc

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
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	7 import LLVM = llvm.llvm;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	8
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	9 import ast.Module,
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	10 ast.Decl,
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	11 ast.Stmt,
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	12 ast.Exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	13
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 57 diff changeset	14 import misc.Error,
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 57 diff changeset	15 basic.SmallArray;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	16
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	17 import lexer.Token;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	18
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	19 import sema.Scope,
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	20 sema.Visitor;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	21
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	22 alias LLVM.Value Value;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	23 alias LLVM.Type Type;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	24 alias LLVM.Function Function;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	25 alias LLVM.PointerType PointerType;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	26 alias LLVM.FunctionType FunctionType;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	27 alias LLVM.IntPredicate IntPredicate;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	28 alias LLVM.ParamAttr ParamAttr;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	29 alias LLVM.ConstantInt ConstantInt;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	30 alias LLVM.GlobalVariable GlobalVariable;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	31 alias LLVM.IntegerType IntegerType;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	32 alias LLVM.BasicBlock BasicBlock;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	33 alias LLVM.StructType StructType;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	34 alias LLVM.ArrayType ArrayType;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	35
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	36 private char[] genBuildCmp(char[] p)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	37 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	38 return `
66 c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	39 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	40 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	41 return b.buildICmp(IntPredicate.`~p~`, l, r, n);
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 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	44
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	45 class CodeGen
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	46 {
66 c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	47 private:
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	48 mixin(genBuildCmp("EQ"));
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	49 mixin(genBuildCmp("NE"));
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	50 mixin(genBuildCmp("SLT"));
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	51 mixin(genBuildCmp("SLE"));
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	52 mixin(genBuildCmp("SGT"));
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	53 mixin(genBuildCmp("SGE"));
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	54
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	55 public:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	56 this()
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 alias BinaryExp.Operator op;
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	59 b = new LLVM.Builder;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	60
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	61 opToLLVM = [
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	62 op.Add : &b.buildAdd,
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	63 op.Sub : &b.buildSub,
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	64 op.Mul : &b.buildMul,
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	65 op.Div : &b.buildSDiv,
66 c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	66 op.Eq : &buildEQ,
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	67 op.Ne : &buildNE,
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	68 op.Lt : &buildSLT,
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	69 op.Le : &buildSLE,
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	70 op.Gt : &buildSGT,
c62c32e92fde Fixed a bug - delegates are problematic Anders Halager <halager@gmail.com> parents: 65 diff changeset	71 op.Ge : &buildSGE
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	72 ];
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	73 table = new SimpleSymbolTable();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	74
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	75 createBasicTypes();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	76 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	77
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	78 ~this()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	79 {
101 fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	80 // b.dispose();
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	81 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	82
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	83 void gen(Module mod, uint handle, bool optimize, bool inline)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	84 {
101 fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	85 this.mod = mod;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	86 // create module
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	87 m = new LLVM.Module("main_module");
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	88 scope(exit) m.dispose();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	89
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	90 table.enterScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	91
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	92 BytePtr = PointerType.Get(Type.Int8);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	93 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	94 llvm_memcpy = m.addFunction(temp, "llvm.memcpy.i32");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	95
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	96 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	97 (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	98 {
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 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	100 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	101 {
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	102 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	103 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	104 {
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 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	106 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	107 }
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	108 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	109 {
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	110 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	111 param_types ~= pointer;
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	112 }
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	113 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	114 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	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 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	117 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	118 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	119 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	120 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	121 auto func_t = FunctionType.Get(llvm(ret_t), param_types);
96 438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules. Anders Johnsen <skabet@gmail.com> parents: 94 diff changeset	122 auto llfunc = m.addFunction(func_t, fd.identifier.getMangled);
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	123
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 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	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 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	127 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	128
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	129 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	130 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	131 {
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	132 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	133 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	134 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	135 }
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	136 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	137 {
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	138 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	139 }
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	140 }
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	141 };
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	142 auto visitor = new VisitFuncDecls(registerFunc);
101 fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	143 visitor.visit([mod]);
54 d84fec04d462 Move all root var-decls so they are generated before anything else Anders Halager <halager@gmail.com> parents: 53 diff changeset	144 // 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	145 // 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	146 // 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	147 // any problems.
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	148 partition(mod.decls, (Decl d) { return d.declType == DeclType.VarDecl; });
54 d84fec04d462 Move all root var-decls so they are generated before anything else Anders Halager <halager@gmail.com> parents: 53 diff changeset	149
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	150 foreach (decl; mod.decls)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	151 genRootDecl(decl);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	152
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	153 table.leaveScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	154
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	155 // debug m.verify();
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	156
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	157 if(optimize)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	158 m.optimize(inline);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	159
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	160 m.writeBitcodeToFileHandle(handle);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	161 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	162
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	163 void genRootDecl(Decl decl)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	164 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	165 switch(decl.declType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	166 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	167 case DeclType.FuncDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	168 FuncDecl funcDecl = cast(FuncDecl)decl;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	169
82 06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	170 // Empty function - declare;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	171 if(funcDecl.emptyFunction)
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	172 return;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	173
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	174 llvm(funcDecl.type);
96 438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules. Anders Johnsen <skabet@gmail.com> parents: 94 diff changeset	175 auto llfunc = m.getNamedFunction(funcDecl.identifier.getMangled);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	176 auto func_tp = cast(PointerType)llfunc.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	177 auto func_t = cast(FunctionType)func_tp.elementType();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	178 auto ret_t = func_t.returnType();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	179
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	180
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	181 auto bb = llfunc.appendBasicBlock("entry");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	182 b.positionAtEnd(bb);
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 table.enterScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	185 foreach (i, v; funcDecl.funcArgs)
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 llfunc.getParam(i).name = v.identifier.get;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	188 auto name = v.identifier.get;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	189 if(!cast(PointerType)llfunc.getParam(i).type)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	190 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	191 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	192 // Value va = b.buildLoad(val, name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	193 b.buildStore(llfunc.getParam(i), AI);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	194 table[name] = AI;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	195 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	196 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	197 table[name] = llfunc.getParam(i);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	198 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	199
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	200 foreach (stmt; funcDecl.statements)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	201 genStmt(stmt);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	202
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	203 // 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	204 // add one (return 0 as default)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	205 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	206 if (ret_t is Type.Void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	207 b.buildRetVoid();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	208 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	209 b.buildRet(ConstantInt.GetS(ret_t, 0));
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	210
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	211 table.leaveScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	212 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	213
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	214 case DeclType.VarDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	215 auto varDecl = cast(VarDecl)decl;
93 621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	216 auto id = varDecl.env.find(varDecl.identifier);
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	217 Type t = llvm(id.type);
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	218 GlobalVariable g = m.addGlobal(t, id.get);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	219 g.initializer = ConstantInt.GetS(t, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	220 table[varDecl.identifier.get] = g;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	221 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	222
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	223 case DeclType.StructDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	224 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	225 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	226 //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	227 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	228
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	229 default:
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 }
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 void genDecl(Decl decl)
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 switch(decl.declType)
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 case DeclType.VarDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	239 auto varDecl = cast(VarDecl)decl;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	240 auto name = varDecl.identifier.get;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	241 auto sym = varDecl.env.find(varDecl.identifier);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	242 auto AI = b.buildAlloca(llvm(sym.type), name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	243 table[name] = AI;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	244 if (varDecl.init)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	245 buildAssign(varDecl.identifier, varDecl.init);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	246 break;
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 default:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	249 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	250 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	251
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	252 struct PE
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	253 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	254 static char[] NoImplicitConversion =
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	255 "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	256 static char[] VoidRetInNonVoidFunc =
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	257 "Only void functions can return without an expression";
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	258 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	259
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	260 void sextSmallerToLarger(ref Value left, ref Value right)
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 if (left.type != right.type)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	263 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	264 // 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	265 IntegerType l = cast(IntegerType) left.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	266 IntegerType r = cast(IntegerType) right.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	267 if (l is null \|\| r is null)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	268 throw error(__LINE__, PE.NoImplicitConversion)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	269 .arg(left.type.toString)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	270 .arg(right.type.toString);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	271
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	272 if (l.numBits() < r.numBits())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	273 left = b.buildSExt(left, r, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	274 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	275 right = b.buildSExt(right, l, ".cast");
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 }
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 Value genExpression(Exp exp)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	280 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	281 switch(exp.expType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	282 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	283 case ExpType.Binary:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	284 auto binaryExp = cast(BinaryExp)exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	285
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	286 auto left = genExpression(binaryExp.left);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	287 auto right = genExpression(binaryExp.right);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	288
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	289 // sextSmallerToLarger(left, right);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	290
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	291 OpBuilder op = opToLLVM[binaryExp.op];
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	292
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	293 return op(left, right, ".");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	294
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	295 case ExpType.IntegerLit:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	296 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	297 auto val = integetLit.get;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	298 return ConstantInt.GetS(Type.Int32, Integer.parse(val));
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	299 case ExpType.Negate:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	300 auto negateExp = cast(NegateExp)exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	301 auto target = genExpression(negateExp.exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	302 return b.buildNeg(target, "neg");
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	303 case ExpType.Deref:
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	304 auto derefExp = cast(DerefExp)exp;
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	305 auto target = genExpression(derefExp.exp);
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	306 return b.buildLoad(target, "deref");
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	307 case ExpType.AssignExp:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	308 auto assignExp = cast(AssignExp)exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	309 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	310 case ExpType.Index:
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	311 auto indexExp = cast(IndexExp)exp;
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	312 return b.buildLoad(getPointer(exp), ".");
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	313 case ExpType.CallExp:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	314 auto callExp = cast(CallExp)exp;
93 621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	315 auto id = exp.env.find(cast(Identifier)callExp.exp);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	316 Value[] args;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	317 foreach (arg; callExp.args)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	318 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	319 Value v = genExpression(arg);
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	320 args ~= v;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	321
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	322 }
101 fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	323 llvm(id.type);
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	324 // 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	325 if(callExp.sret)
98 7f9240d4ddc1 Fixed tests - forgot some stuff in codegen. Anders Johnsen <skabet@gmail.com> parents: 96 diff changeset	326 return b.buildCall(m.getNamedFunction(id.getMangled), args, "");
7f9240d4ddc1 Fixed tests - forgot some stuff in codegen. Anders Johnsen <skabet@gmail.com> parents: 96 diff changeset	327 return b.buildCall(m.getNamedFunction(id.getMangled), 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	328 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	329 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	330 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	331
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	332 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	333 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	334
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	335 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	336 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	337 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	338 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	339 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	340
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	341 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	342
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	343 case ExpType.Identifier:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	344 auto identifier = cast(Identifier)exp;
93 621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	345 auto id = exp.env.find(identifier);
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	346 if(id.type.isStruct \|\| id.type.isArray)
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	347 return table.find(id.get);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	348 else
93 621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	349 return b.buildLoad(table.find(id.get), id.get);
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	350 case ExpType.MemberReference:
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	351 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	352 // 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	353 return b.buildLoad(v, v.name);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	354 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	355 assert(0, "Reached end of switch in genExpression");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	356 return null;
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
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	359 void genStmt(Stmt stmt)
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 switch(stmt.stmtType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	362 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	363 case StmtType.Compound:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	364 auto stmts = cast(CompoundStatement)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	365 foreach (s; stmts.statements)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	366 genStmt(s);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	367 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	368 case StmtType.Return:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	369 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	370 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	371 Type t = llvm(type.returnType);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	372 if (ret.exp is null)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	373 if (t is Type.Void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	374 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	375 b.buildRetVoid();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	376 return;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	377 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	378 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	379 throw error(__LINE__, PE.VoidRetInNonVoidFunc);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	380
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	381 Value v = genExpression(ret.exp);
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	382 /* if (v.type != t)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	383 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	384 IntegerType v_t = cast(IntegerType) v.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	385 IntegerType i_t = cast(IntegerType) t;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	386 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	387 throw error(__LINE__, PE.NoImplicitConversion)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	388 .arg(v.type.toString)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	389 .arg(t.toString);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	390
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	391 if (v_t.numBits() < i_t.numBits())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	392 v = b.buildSExt(v, t, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	393 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	394 v = b.buildTrunc(v, t, ".cast");
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	395 }*/
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	396 b.buildRet(v);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	397 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	398 case StmtType.Decl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	399 auto declStmt = cast(DeclStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	400 genDecl(declStmt.decl);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	401 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	402 case StmtType.Exp:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	403 auto expStmt = cast(ExpStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	404 genExpression(expStmt.exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	405 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	406 case StmtType.If:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	407 auto ifStmt = cast(IfStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	408 Value cond = genExpression(ifStmt.cond);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	409 if (cond.type !is Type.Int1)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	410 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	411 Value False = ConstantInt.GetS(cond.type, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	412 cond = b.buildICmp(IntPredicate.NE, cond, False, ".cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	413 }
98 7f9240d4ddc1 Fixed tests - forgot some stuff in codegen. Anders Johnsen <skabet@gmail.com> parents: 96 diff changeset	414 auto func_name = stmt.env.parentFunction().identifier.getMangled;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	415 Function func = m.getNamedFunction(func_name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	416 bool has_else = (ifStmt.else_body !is null);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	417
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	418 auto thenBB = func.appendBasicBlock("then");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	419 auto elseBB = has_else? func.appendBasicBlock("else") : null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	420 auto mergeBB = func.appendBasicBlock("merge");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	421
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	422 b.buildCondBr(cond, thenBB, has_else? elseBB : mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	423 b.positionAtEnd(thenBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	424 genStmt(ifStmt.then_body);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	425 thenBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	426 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	427 b.buildBr(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	428
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	429 if (has_else)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	430 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	431 b.positionAtEnd(elseBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	432 genStmt(ifStmt.else_body);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	433 elseBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	434 if (elseBB.terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	435 b.buildBr(mergeBB);
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
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	438 b.positionAtEnd(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	439 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	440 case StmtType.While:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	441 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	442 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	443 Function func = m.getNamedFunction(func_name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	444
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	445 auto condBB = func.appendBasicBlock("cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	446 auto bodyBB = func.appendBasicBlock("body");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	447 auto doneBB = func.appendBasicBlock("done");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	448
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	449 b.buildBr(condBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	450 b.positionAtEnd(condBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	451 Value cond = genExpression(wStmt.cond);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	452 if (cond.type !is Type.Int1)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	453 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	454 Value False = ConstantInt.GetS(cond.type, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	455 cond = b.buildICmp(IntPredicate.NE, cond, False, ".cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	456 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	457 b.buildCondBr(cond, bodyBB, doneBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	458
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	459 b.positionAtEnd(bodyBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	460 genStmt(wStmt.whileBody);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	461 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	462 b.buildBr(condBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	463
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	464 b.positionAtEnd(doneBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	465 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	466 case StmtType.Switch:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	467 auto sw = cast(SwitchStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	468 Value cond = genExpression(sw.cond);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	469
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	470 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	471 Function func = m.getNamedFunction(func_name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	472
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	473 BasicBlock oldBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	474 BasicBlock defBB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	475 BasicBlock endBB = func.appendBasicBlock("sw.end");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	476 if (sw.defaultBlock)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	477 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	478 defBB = Function.InsertBasicBlock(endBB, "sw.def");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	479 b.positionAtEnd(defBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	480 foreach (case_statement; sw.defaultBlock)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	481 genStmt(case_statement);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	482 if (!defBB.terminated())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	483 b.buildBr(endBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	484 b.positionAtEnd(oldBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	485 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	486 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	487 defBB = endBB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	488 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	489 foreach (c; sw.cases)
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 BasicBlock prevBB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	492 foreach (i, val; c.values)
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 auto BB = Function.InsertBasicBlock(defBB, "sw.bb");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	495 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	496
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	497 if (i + 1 == c.values.length)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	498 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	499 b.positionAtEnd(BB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	500 foreach (case_statement; c.stmts)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	501 genStmt(case_statement);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	502 if (!BB.terminated())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	503 b.buildBr(c.followedByDefault? defBB : endBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	504 }
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 if (prevBB !is null && !prevBB.terminated())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	507 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	508 b.positionAtEnd(prevBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	509 b.buildBr(BB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	510 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	511 prevBB = BB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	512 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	513 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	514 b.positionAtEnd(endBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	515 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	516 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	517 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	518
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	519 Value getPointer(Exp exp)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	520 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	521 switch(exp.expType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	522 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	523 case ExpType.Identifier:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	524 auto identifier = cast(Identifier)exp;
93 621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	525 auto id = exp.env.find(identifier);
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	526 return table.find(id.get);
80 682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	527 case ExpType.Deref:
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	528 auto derefExp = cast(DerefExp)exp;
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	529 auto target = getPointer(derefExp.exp);
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	530 return b.buildLoad(target, "deref");
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	531 case ExpType.Index:
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	532 auto indexExp = cast(IndexExp)exp;
85 9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	533 auto type = indexExp.target.type;
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	534 auto index = genExpression(indexExp.index);
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	535 Value[2] gep_indices;
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	536 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	537 gep_indices[1] = index;
85 9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	538 if (type.isArray())
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	539 {
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	540 auto array = getPointer(indexExp.target);
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	541 return b.buildGEP(array, gep_indices[0 .. 2], "index");
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	542 }
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	543 else if (type.isPointer())
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	544 {
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	545 auto array = genExpression(indexExp.target);
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	546 return b.buildGEP(array, gep_indices[1 .. 2], "index");
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	547 }
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	548 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	549 case ExpType.MemberReference:
79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	550 auto mem = cast(MemberReference)exp;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	551 switch(mem.target.expType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	552 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	553 case ExpType.Identifier:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	554 auto identifier = cast(Identifier)mem.target;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	555 auto child = mem.child;
93 621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	556 auto id = exp.env.find(identifier);
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	557 Value v = table.find(id.get);
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	558 DType t = id.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	559 auto st = t.asStruct;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	560
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	561 int i = st.indexOf(child.get);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	562
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	563 Value[] vals;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	564 vals ~= ConstantInt.Get(IntegerType.Int32, 0, false);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	565 vals ~= ConstantInt.Get(IntegerType.Int32, i, false);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	566
93 621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	567 Value val = b.buildGEP(v, vals, id.get~"."~child.get);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	568 return val;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	569
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	570 case ExpType.MemberReference:
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	571 auto v = getPointer(mem.target);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	572 auto child = mem.child;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	573 auto symChild = child.env.find(child);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	574 DType t = mem.target.type;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	575 auto st = t.asStruct;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	576
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	577 int i = st.indexOf(child.get);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	578
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	579 Value[] vals;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	580 vals ~= ConstantInt.Get(IntegerType.Int32, 0, false);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	581 vals ~= ConstantInt.Get(IntegerType.Int32, i, false);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	582
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	583 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	584 return val;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	585
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	586 default:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	587 Value val = genExpression(exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	588 auto AI = b.buildAlloca(val.type, ".s");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	589 return b.buildStore(val, AI);
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 default:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	592 Value val = genExpression(exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	593 auto AI = b.buildAlloca(val.type, ".s");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	594 return b.buildStore(val, AI);
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 assert(0, "Reached end of switch in getPointer");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	597 return null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	598 }
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 private Value buildAssign(Exp target, Exp exp)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	601 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	602 Value t = getPointer(target);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	603 Value v = genExpression(exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	604
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	605 auto a = cast(PointerType)t.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	606
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	607 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	608
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	609 Type value_type = v.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	610 if (auto value_ptr = cast(PointerType)v.type)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	611 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	612 value_type = value_ptr.elementType;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	613
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	614 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	615 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	616 // bitcast "from" to i8*
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	617 Value from = b.buildBitCast(v, BytePtr, ".copy_from");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	618 // bitcast "to" to i8*
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	619 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	620 // 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	621 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	622 // return "to"
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	623 return t;
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 }
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 if (value_type != a.elementType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	628 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	629 IntegerType v_t = cast(IntegerType) value_type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	630 IntegerType i_t = cast(IntegerType) a.elementType;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	631 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	632 throw error(__LINE__, PE.NoImplicitConversion)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	633 .arg(a.elementType.toString)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	634 .arg(v.type.toString);
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 if (v_t.numBits() < i_t.numBits())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	637 v = b.buildSExt(v, a.elementType, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	638 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	639 v = b.buildTrunc(v, a.elementType, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	640 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	641 return b.buildStore(v, t);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	642 }
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 Error error(uint line, char[] msg)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	645 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	646 return new Error(msg);
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 /**
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	650 Get the LLVM Type corresponding to a DType.
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	651
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	652 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	653 well when the hashes are so uniform.
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 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	656 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	657 */
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	658 Type llvm(DType t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	659 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	660 if (auto llvm_t = t in type_map)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	661 return *llvm_t;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	662 return llvmCreateNew(t);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	663 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	664
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	665 // 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	666 // result
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	667 Type llvmCreateNew(DType t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	668 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	669 if (auto i = cast(DInteger)t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	670 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	671 Type res = IntegerType.Get(i.byteSize() * 8);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	672 type_map[t] = res;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	673 return res;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	674 }
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	675 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	676 {
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 57 diff changeset	677 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	678 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	679 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	680
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	681 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	682 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	683
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	684 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	685 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	686
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 57 diff changeset	687 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	688 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	689 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	690 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	691 }
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	692 else if (auto f = t.asFunction)
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	693 {
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	694 // 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	695 // 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	696 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	697 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	698
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	699 SmallArray!(Type, 8) params;
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	700 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	701 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	702 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	703 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	704 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	705 else
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	706 params ~= llvm(param);
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	707
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	708 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	709 type_map[t] = res;
101 fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	710 auto id = new Identifier(f.name);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	711 id.setType(f);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	712
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	713 auto f_t = m.getNamedFunction(id.getMangled);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	714 if(f_t is null)
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	715 {
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	716 auto llfunc = m.addFunction(res, id.getMangled);
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	717
101 fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	718 foreach (i, param; f.params)
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	719 if (param.isStruct)
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	720 llfunc.addParamAttr(i, ParamAttr.ByVal);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	721
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	722 if (f.firstParamIsReturnValue)
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	723 {
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	724 llfunc.removeParamAttr(0, ParamAttr.ByVal);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	725 llfunc.addParamAttr(0, ParamAttr.StructRet);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	726 }
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	727 }
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	728 return res;
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	729 }
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	730 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	731 {
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	732 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	733 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	734 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	735 }
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	736 else if (auto f = t.asArray)
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	737 {
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	738 Type res = ArrayType.Get(llvm(f.arrayOf), f.size);
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	739 type_map[t] = res;
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	740 return res;
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	741 }
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	742 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	743 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	744
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	745 // 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	746 void createBasicTypes()
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 type_map[DType.Void] = Type.Void;
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 type_map[DType.Bool] = Type.Int1;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	751 type_map[DType.Byte] = Type.Int8;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	752 type_map[DType.UByte] = Type.Int8;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	753 type_map[DType.Short] = Type.Int16;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	754 type_map[DType.UShort] = Type.Int16;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	755 type_map[DType.Int] = Type.Int32;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	756 type_map[DType.UInt] = Type.Int32;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	757 type_map[DType.Long] = Type.Int64;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	758 type_map[DType.ULong] = Type.Int64;
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
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	761 private:
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 // llvm stuff
101 fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	764 Module mod;
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	765 LLVM.Module m;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	766 LLVM.Builder b;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	767 Function llvm_memcpy;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	768 Type BytePtr;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	769 Type[DType] type_map;
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 FuncDecl[char[]] functions;
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 SimpleSymbolTable table;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	774 alias Value delegate(Value, Value, char[]) OpBuilder;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	775 static OpBuilder[BinaryExp.Operator] opToLLVM;
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
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	778 private class VisitFuncDecls : Visitor!(void)
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 delegate(FuncDecl) dg;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	781 this(void delegate(FuncDecl funcDecl) dg)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	782 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	783 this.dg = dg;
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
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	786 override void visitModule(Module m)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	787 {
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	788 foreach (decl; m.decls)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	789 if (auto f = cast(FuncDecl)decl)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	790 dg(f);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	791 }
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
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	794 private class SimpleSymbolTable
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	795 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	796 Value[char[]][] namedValues;
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 void enterScope()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	799 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	800 namedValues ~= cast(Value[char[]])["__dollar":null];
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
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	803 void leaveScope()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	804 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	805 namedValues.length = namedValues.length - 1;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	806 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	807
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	808 Value put(Value val, char[] key)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	809 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	810 namedValues[$ - 1][key] = val;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	811 return val;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	812 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	813
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	814 Value find(char[] key)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	815 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	816 foreach_reverse (map; namedValues)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	817 if(auto val_ptr = key in map)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	818 return *val_ptr;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	819 return null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	820 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	821
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	822 alias find opIndex;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	823 alias put opIndexAssign;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	824 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	825

Mercurial > projects > dang

annotate gen/CodeGen.d @ 101:fea8d61a2451 new_gen