projects/dang: gen/CodeGen.d annotate

annotate gen/CodeGen.d @ 174:20ff3c31f600

Putting symbol on MemberRef -calls.

author	Anders Johnsen <skabet@gmail.com>
date	Thu, 24 Jul 2008 21:06:42 +0200
parents	50b98a06a200
children	c8e26556c24d

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
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	7 import llvm.llvm;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	8
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	9 import ast.Decl,
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	10 ast.Stmt,
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	11 ast.Exp,
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	12 ast.Module : DModule = Module;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	13
119 c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	14 import basic.SmallArray,
143 d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	15 basic.Attribute,
119 c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	16 basic.LiteralParsing;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	17
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	18 import lexer.Token;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	19
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	20 import sema.Scope,
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	21 sema.Visitor;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	22
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	23 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	24 Wrapper for Values representing rvalues (things you can only read from)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	25 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	26 private struct RValue
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	27 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	28 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	29 Returns true if this is a simple value, like an int or a pointer.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	30 This is basicly anything except a struct, which will contain a Value that
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	31 is a pointer to the struct.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	32 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	33 bool isSimple() { return simple; }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	34 /// Opposite of isSimple
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	35 bool isAggregate() { return !simple; }
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	36
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	37 Value value;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	38 private bool simple = true;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	39 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	40
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	41 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	42 Wrapper for Values representing lvalues (things you can write to)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	43 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	44 private struct LValue
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	45 {
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	46 Value getAddress() { return value; }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	47 private Value value;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	48 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	49
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	50 class CodeGen
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	51 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	52 public:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	53 this()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	54 {
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	55 b = new Builder;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	56 ZeroIndex = ConstantInt.GetU(Type.Int32, 0);
137 efbf51d85f4d No reason to explicitly add structs as llvm types Anders Halager <halager@gmail.com> parents: 136 diff changeset	57
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	58 table = new SimpleSymbolTable();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	59
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	60 createBasicTypes();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	61 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	62
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	63 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	64 Generate a new module.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	65 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	66 /*
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	67 Find all function decls and add the functions to the llvm module, so
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	68 they can be referenced.
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	69
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	70 Make sure all var-decls are located before functions, so we wont get
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	71 problems when referencing the global vars.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	72
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	73 Generate the actual llvm code needed for all decls
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	74
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	75 Optimize if requested
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	76
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	77 Write to filehandle (can be a file or stdout)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	78 */
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	79 void gen(DModule mod, uint handle, bool optimize, bool inline)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	80 {
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	81 this.mod = mod;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	82 // create module
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	83 m = new .llvm.llvm.Module("main_module");
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	84 scope(exit) m.dispose();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	85
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	86 table.enterScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	87
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	88 BytePtr = PointerType.Get(Type.Int8);
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	89 auto temp = FunctionType.Get(
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	90 Type.Void,
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	91 [BytePtr, BytePtr, Type.Int32, Type.Int32]);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	92 llvm_memcpy = m.addFunction(temp, "llvm.memcpy.i32");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	93
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	94 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	95 (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	96 {
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 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	98 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	99 {
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	100 DType t = p.identifier.type;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	101 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	102 {
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	103 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	104 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	105 }
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	106 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	107 {
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	108 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	109 param_types ~= pointer;
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	110 }
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	111 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	112 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	113 }
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	114 auto ret_t = fd.identifier.type;
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 67 diff changeset	115 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	116 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	117 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	118 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	119 auto func_t = FunctionType.Get(llvm(ret_t), param_types);
143 d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	120 auto llfunc = m.addFunction(func_t, symbolName(fd));
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	121
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	122 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	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 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	125 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	126
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	127 DType t = p.identifier.type;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	128 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	129 {
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	130 if (i == 0 && fd.sret)
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 continue;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	132 llfunc.addParamAttr(i, ParamAttr.ByVal);
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	133 }
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	134 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	135 {
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	136 llfunc.addParamAttr(i, ParamAttr.ByVal);
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	137 }
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	138 }
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	139 };
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 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	141 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	142 // 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	143 // 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	144 // 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	145 // 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	146 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	147
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 foreach (decl; mod.decls)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	149 genRootDecl(decl);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	150
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	151 table.leaveScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	152
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	153 // debug m.verify();
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	154
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	155 if(optimize)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	156 m.optimize(inline);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	157
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	158 m.writeBitcodeToFileHandle(handle);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	159 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	160
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	161 private:
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	162 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	163 Generate a single top-level Decl
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	164 **/
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	165 void genRootDecl(Decl decl)
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 switch(decl.declType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	168 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	169 case DeclType.FuncDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	170 FuncDecl funcDecl = cast(FuncDecl)decl;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	171
82 06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	172 // Empty function - declare;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	173 if(funcDecl.emptyFunction)
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	174 return;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	175
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	176 llvm(funcDecl.type);
143 d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	177 auto llfunc = m.getNamedFunction(symbolName(funcDecl));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	178 auto func_tp = cast(PointerType)llfunc.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	179 auto func_t = cast(FunctionType)func_tp.elementType();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	180 auto ret_t = func_t.returnType();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	181
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	182
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	183 auto bb = llfunc.appendBasicBlock("entry");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	184 b.positionAtEnd(bb);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	185
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	186 table.enterScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	187 foreach (i, v; funcDecl.funcArgs)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	188 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	189 llfunc.getParam(i).name = v.identifier.get;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	190 auto name = v.identifier.get;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	191 if (!cast(PointerType)llfunc.getParam(i).type)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	192 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	193 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	194 // Value va = b.buildLoad(val, name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	195 b.buildStore(llfunc.getParam(i), AI);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	196 table[name] = AI;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	197 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	198 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	199 table[name] = llfunc.getParam(i);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	200 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	201
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	202 foreach (stmt; funcDecl.statements)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	203 genStmt(stmt);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	204
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	205 // 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	206 // add one (return 0 as default)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	207 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	208 if (ret_t is Type.Void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	209 b.buildRetVoid();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	210 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	211 b.buildRet(ConstantInt.GetS(ret_t, 0));
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	212
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	213 table.leaveScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	214 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	215
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	216 case DeclType.VarDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	217 auto varDecl = cast(VarDecl)decl;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	218 auto id = varDecl.identifier;
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	219 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	220 GlobalVariable g = m.addGlobal(t, id.get);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	221 g.initializer = ConstantInt.GetS(t, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	222 table[varDecl.identifier.get] = g;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	223 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	224
173 50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	225 case DeclType.ClassDecl:
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	226 auto cdecl = cast(ClassDecl)decl;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	227 SmallArray!(Constant) functions;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	228 foreach (d; cdecl.decls)
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	229 {
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	230 auto func = cast(FuncDecl)d;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	231 if (func is null)
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	232 continue;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	233 genRootDecl(func);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	234 auto llvm_f = m.getNamedFunction(symbolName(func));
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	235 functions ~= Constant.GetBitCast(llvm_f, BytePtr);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	236 }
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	237 auto class_vtbl = ConstantArray.Get(BytePtr, functions.unsafe());
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	238 auto gv = m.addGlobal(class_vtbl, cdecl.identifier.get ~ "_vtable");
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	239 gv.linkage = Linkage.Weak;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	240 gv.globalConstant = true;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	241 break;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	242
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	243 default:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	244 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	245 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	246 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	247
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	248 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	249 Generate a single local Decl
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	250 **/
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	251 void genDecl(Decl decl)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	252 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	253 switch(decl.declType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	254 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	255 case DeclType.VarDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	256 auto varDecl = cast(VarDecl)decl;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	257 auto id = varDecl.identifier;
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	258 auto name = id.get;
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	259 auto AI = b.buildAlloca(llvm(id.type), name);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	260 table[name] = AI;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	261 if (varDecl.init)
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	262 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	263 LValue dst = genLValue(varDecl.identifier);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	264 RValue src = genExpression(varDecl.init);
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	265 storeThroughLValue(dst, src, id.type);
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	266 }
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	267 break;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	268
173 50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	269 case DeclType.FuncDecl,
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	270 DeclType.StructDecl,
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	271 DeclType.ClassDecl:
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	272 genRootDecl(decl);
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	273 break;
137 efbf51d85f4d No reason to explicitly add structs as llvm types Anders Halager <halager@gmail.com> parents: 136 diff changeset	274
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	275 default:
138 b61de188cd0d Removed some unused code Anders Halager <halager@gmail.com> parents: 137 diff changeset	276 break;
51 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
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	280 // Remove - do it right (basic/Messages.d)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	281 struct PE
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 static char[] NoImplicitConversion =
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	284 "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	285 static char[] VoidRetInNonVoidFunc =
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	286 "Only void functions can return without an expression";
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	287 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	288
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	289 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	290 Generate a single expression.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	291
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	292 This is the most general way of generating expressions and therefore
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	293 returns an RValue.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	294 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	295 RValue genExpression(Exp exp)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	296 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	297 switch(exp.expType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	298 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	299 case ExpType.Binary:
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	300 return RValue(genBinExp(cast(BinaryExp)exp));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	301 case ExpType.IntegerLit:
119 c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	302 auto integerLit = cast(IntegerLit)exp;
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	303 switch(integerLit.number.type)
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	304 {
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	305 case NumberType.Int:
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	306 return RValue(ConstantInt.GetS(Type.Int32, integerLit.number.integer));
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	307 case NumberType.Long:
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	308 return RValue(ConstantInt.GetS(Type.Int64, integerLit.number.integer));
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	309 case NumberType.ULong:
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	310 return RValue(ConstantInt.GetS(Type.Int64, integerLit.number.integer));
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	311 case NumberType.Float:
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	312 return RValue(ConstantReal.Get(Type.Float, integerLit.number.floating));
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	313 case NumberType.Double:
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	314 return RValue(ConstantReal.Get(Type.Double, integerLit.number.floating));
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	315 case NumberType.Real:
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	316 return RValue(ConstantReal.Get(Type.X86_FP80, integerLit.number.floating));
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	317 }
160 6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	318 case ExpType.StringExp:
6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	319 auto stringExp = cast(StringExp)exp;
6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	320 char[] data = cast(char[])stringExp.data;
6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	321 auto string_constant = ConstantArray.GetString(data, true);
6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	322 auto gv = m.addGlobal(string_constant, "string");
6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	323 gv.linkage = Linkage.Internal;
6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	324 gv.globalConstant = true;
6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	325 return RValue(gv);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	326 case ExpType.Negate:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	327 auto negateExp = cast(NegateExp)exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	328 auto target = genExpression(negateExp.exp);
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	329 return RValue(b.buildNeg(target.value, "neg"));
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	330 case ExpType.Deref:
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	331 auto derefExp = cast(DerefExp)exp;
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	332 auto target = genExpression(derefExp.exp);
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	333 return RValue(b.buildLoad(target.value, "deref"));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	334 case ExpType.AssignExp:
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	335 auto AE = cast(AssignExp)exp;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	336 LValue dst = genLValue(AE.identifier);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	337 RValue src = genExpression(AE.exp);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	338 storeThroughLValue(dst, src, AE.exp.type());
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	339 return src;
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	340 case ExpType.Index:
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	341 auto indexExp = cast(IndexExp)exp;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	342 return loadLValue(genLValue(exp));
166 9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	343 case ExpType.NewExp:
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	344 auto newExp = cast(NewExp)exp;
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	345 DClass type = newExp.newType.type().asClass();
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	346 auto llvm_type = cast(PointerType)llvm(type);
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	347 auto pointer = b.buildMalloc(llvm_type.elementType(), "new");
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	348 scope args = new Value[newExp.c_args.length];
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	349 foreach (i, arg; newExp.c_args)
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	350 args[i] = genExpression(arg).value;
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	351 auto f = m.getNamedFunction(newExp.callSym.getMangledFQN());
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	352 b.buildCall(f, args, "");
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	353 return RValue(pointer);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	354 case ExpType.CallExp:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	355 auto callExp = cast(CallExp)exp;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	356 // BUG: Might not be a simple identifier, a.foo(x) is also a
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	357 // valid call - or foo(x)(y) for that matter.
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	358
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	359 // if type of exp is DFunction - safe to call getSymbol and FQN
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	360 // if function ptr: do something else
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	361 // if delegate do a third thing
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	362 // if struct/class check for opCall
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	363 DType type = callExp.exp.type;
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	364 assert (type.isFunction(), "Can only call functions");
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	365 scope args = new Value[callExp.args.length];
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	366 foreach (i, arg; callExp.args)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	367 args[i] = genExpression(arg).value;
173 50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	368 DFunction ftype = type.asFunction();
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	369 Type llvm_ftype = llvm(ftype);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	370 Value f = null;
174 20ff3c31f600 Putting symbol on MemberRef -calls. Anders Johnsen <skabet@gmail.com> parents: 173 diff changeset	371 Stdout(callExp.callSym).newline;
171 f0385c044065 Make function overloads work in the codegen Anders Halager <halager@gmail.com> parents: 166 diff changeset	372 if (callExp.callSym is null)
f0385c044065 Make function overloads work in the codegen Anders Halager <halager@gmail.com> parents: 166 diff changeset	373 {
f0385c044065 Make function overloads work in the codegen Anders Halager <halager@gmail.com> parents: 166 diff changeset	374 // Do a virtual function call
173 50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	375 f = genLValue(callExp.exp).getAddress();
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	376 f = b.buildLoad(f, "func_pointer");
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	377 f = b.buildBitCast(
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	378 f,
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	379 PointerType.Get(llvm_ftype),
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	380 ftype.name);
171 f0385c044065 Make function overloads work in the codegen Anders Halager <halager@gmail.com> parents: 166 diff changeset	381 }
f0385c044065 Make function overloads work in the codegen Anders Halager <halager@gmail.com> parents: 166 diff changeset	382 else
f0385c044065 Make function overloads work in the codegen Anders Halager <halager@gmail.com> parents: 166 diff changeset	383 {
f0385c044065 Make function overloads work in the codegen Anders Halager <halager@gmail.com> parents: 166 diff changeset	384 auto sym = callExp.callSym;
f0385c044065 Make function overloads work in the codegen Anders Halager <halager@gmail.com> parents: 166 diff changeset	385 f = m.getNamedFunction(sym.getMangledFQN());
f0385c044065 Make function overloads work in the codegen Anders Halager <halager@gmail.com> parents: 166 diff changeset	386 }
173 50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	387 bool isVoid = ftype.returnType is DType.Void;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	388 auto r = b.buildCall(f, args, isVoid? "" : "call");
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	389 return RValue(r);
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	390 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	391 auto castExp = cast(CastExp)exp;
120 7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	392 exp = castExp.exp;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	393 auto value = genExpression(exp);
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	394
120 7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	395 if (!exp.type.hasImplicitConversionTo(castExp.type))
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	396 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	397
120 7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	398 return genTypeCast(value, exp.type, castExp.type);
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	399
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	400 case ExpType.Identifier:
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	401 auto id = cast(Identifier)exp;
160 6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	402 if (id.type.isStruct()
6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	403 \|\| id.type.isArray()
166 9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	404 \|\| id.type.isStaticArray()
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	405 \|\| id.type.isClass())
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	406 return RValue(table.find(id.get));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	407 else
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	408 return RValue(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	409 case ExpType.MemberReference:
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	410 return loadLValue(genLValue(exp));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	411 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	412 assert(0, "Reached end of switch in genExpression");
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	413 return RValue(null);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	414 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	415
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	416 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	417 Generate a binary expression.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	418
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	419 Currently only works for signed and unsigned integers, but is almost
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	420 ready for floats and should be expanded to everything else.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	421 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	422 Value genBinExp(BinaryExp e)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	423 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	424 auto left = genExpression(e.left).value;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	425 auto right = genExpression(e.right).value;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	426 DType t_a = e.left.type;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	427 DType t_b = e.right.type;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	428
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	429 Value res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	430 // TODO: do usual type promotions on a and b
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	431 // TODO: support floats
116 0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 113 diff changeset	432 if (t_a.isArithmetic() && t_b.isArithmetic())
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	433 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	434 Operation op = t_a.getOperationWith(op2op(e.op), t_b);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	435 assert(op.isBuiltin(),
120 7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	436 "numbers should only use builtin ops");
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	437 alias BuiltinOperation BO;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	438 BO val = op.builtinOp();
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	439 // map val to buildAdd or similar
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	440 switch (val) {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	441 case BO.Add: res = b.buildAdd(left, right, "add"); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	442 case BO.Sub: res = b.buildSub(left, right, "sub"); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	443 case BO.Mul: res = b.buildMul(left, right, "mul"); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	444 case BO.SDiv: res = b.buildSDiv(left, right, "div"); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	445 case BO.UDiv: res = b.buildUDiv(left, right, "div"); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	446 case BO.FDiv: res = b.buildFDiv(left, right, "div"); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	447 case BO.SRem: res = b.buildSRem(left, right, "rem"); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	448 case BO.URem: res = b.buildURem(left, right, "rem"); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	449 case BO.FRem: res = b.buildFRem(left, right, "rem"); break;
125 d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	450
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	451 case BO.Shl: res = b.buildShl(left, right, "shl"); break;
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	452 case BO.LShr: res = b.buildLShr(left, right, "lshr"); break;
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	453 case BO.AShr: res = b.buildAShr(left, right, "ashr"); break;
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	454
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	455 case BO.And: res = b.buildAnd(left, right, "and"); break;
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	456 case BO.Or: res = b.buildOr (left, right, "or"); break;
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	457 case BO.Xor: res = b.buildXor(left, right, "xor"); break;
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	458
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	459 default:
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	460 LLVMPred pred = predFromBI(val);
121 95dfe2f48dcf Allow == and != on reals Anders Halager <halager@gmail.com> parents: 120 diff changeset	461 if (t_a.isReal())
95dfe2f48dcf Allow == and != on reals Anders Halager <halager@gmail.com> parents: 120 diff changeset	462 if (val == BO.Eq)
95dfe2f48dcf Allow == and != on reals Anders Halager <halager@gmail.com> parents: 120 diff changeset	463 pred = LLVMPred.Real(RealPredicate.OEQ);
95dfe2f48dcf Allow == and != on reals Anders Halager <halager@gmail.com> parents: 120 diff changeset	464 else if (val == BO.Ne)
95dfe2f48dcf Allow == and != on reals Anders Halager <halager@gmail.com> parents: 120 diff changeset	465 pred = LLVMPred.Real(RealPredicate.ONE);
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	466 IntPredicate ip = pred.intPred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	467 RealPredicate rp = pred.realPred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	468 assert(pred.isValid, "Not a predicate");
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	469 if (pred.isReal)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	470 res = b.buildFCmp(rp, left, right, "cmp");
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	471 else
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	472 res = b.buildICmp(ip, left, right, "cmp");
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	473 break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	474 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	475 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	476 else
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	477 /*
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	478 if left has op for right's type:
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	479 a_op = left.op(right)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	480 if right has usable op_r:
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	481 b_op_r = right.op_r(left)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	482 if a_op or b_op_r is set, choose the best one
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	483 else if op is commutative
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	484 if left has usable op_r
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	485 a_op_r = left.op_r(right)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	486 if right has usable op
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	487 b_op = right.op(left)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	488 choose best one from a_op_r and b_op
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	489 else error
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	490 */
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	491 assert(0, "Not integers?");
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	492
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	493 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	494 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	495
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	496 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	497 Generates one statement
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	498 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	499 // This should be split into specific methods - one per Stmt type?
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	500 void genStmt(Stmt stmt)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	501 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	502 switch(stmt.stmtType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	503 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	504 case StmtType.Compound:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	505 auto stmts = cast(CompoundStatement)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	506 foreach (s; stmts.statements)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	507 genStmt(s);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	508 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	509 case StmtType.Return:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	510 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	511 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	512 Type t = llvm(type.returnType);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	513 if (ret.exp is null)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	514 if (t is Type.Void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	515 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	516 b.buildRetVoid();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	517 return;
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 else
114 3a0cd42de9cc Removed misc/Error.d and is now using the error system all way through. Anders Johnsen <skabet@gmail.com> parents: 107 diff changeset	520 assert(0, PE.VoidRetInNonVoidFunc);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	521
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	522 RValue v = genExpression(ret.exp);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	523 b.buildRet(v.value);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	524 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	525 case StmtType.Decl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	526 auto declStmt = cast(DeclStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	527 genDecl(declStmt.decl);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	528 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	529 case StmtType.Exp:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	530 auto expStmt = cast(ExpStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	531 genExpression(expStmt.exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	532 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	533 case StmtType.If:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	534 auto ifStmt = cast(IfStmt)stmt;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	535 Value cond = genExpression(ifStmt.cond).value;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	536 if (cond.type !is Type.Int1)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	537 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	538 Value False = ConstantInt.GetS(cond.type, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	539 cond = b.buildICmp(IntPredicate.NE, cond, False, ".cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	540 }
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	541 auto func_name = symbolName(stmt.env.parentFunction());
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	542 Function func = m.getNamedFunction(func_name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	543 bool has_else = (ifStmt.else_body !is null);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	544
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	545 auto thenBB = func.appendBasicBlock("then");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	546 auto elseBB = has_else? func.appendBasicBlock("else") : null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	547 auto mergeBB = func.appendBasicBlock("merge");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	548
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	549 b.buildCondBr(cond, thenBB, has_else? elseBB : mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	550 b.positionAtEnd(thenBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	551 genStmt(ifStmt.then_body);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	552 thenBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	553 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	554 b.buildBr(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	555
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	556 if (has_else)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	557 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	558 b.positionAtEnd(elseBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	559 genStmt(ifStmt.else_body);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	560 elseBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	561 if (elseBB.terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	562 b.buildBr(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	563 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	564
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	565 b.positionAtEnd(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	566 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	567 case StmtType.While:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	568 auto wStmt = cast(WhileStmt)stmt;
155 2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	569 genLoop(stmt.env, wStmt.cond, false, wStmt.whileBody);
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	570 break;
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	571 /+
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	572 case StmtType.DoWhile:
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	573 auto wStmt = cast(DoWhileStmt)stmt;
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	574 genLoop(stmt.env, wStmt.cond, true, wStmt.whileBody);
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	575 break;
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	576 +/
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	577 case StmtType.For:
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	578 auto fStmt = cast(ForStmt)stmt;
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	579 genStmt(fStmt.init);
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	580 scope inc = new ExpStmt(fStmt.incre);
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	581 genLoop(stmt.env, fStmt.cond, false, fStmt.forBody, inc);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	582 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	583 case StmtType.Switch:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	584 auto sw = cast(SwitchStmt)stmt;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	585 Value cond = genExpression(sw.cond).value;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	586
143 d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	587 auto fc = stmt.env.parentFunction();
d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	588 Function func = m.getNamedFunction(symbolName(fc));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	589
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	590 BasicBlock oldBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	591 BasicBlock defBB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	592 BasicBlock endBB = func.appendBasicBlock("sw.end");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	593 if (sw.defaultBlock)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	594 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	595 defBB = Function.InsertBasicBlock(endBB, "sw.def");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	596 b.positionAtEnd(defBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	597 foreach (case_statement; sw.defaultBlock)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	598 genStmt(case_statement);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	599 if (!defBB.terminated())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	600 b.buildBr(endBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	601 b.positionAtEnd(oldBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	602 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	603 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	604 defBB = endBB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	605 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	606 foreach (c; sw.cases)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	607 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	608 BasicBlock prevBB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	609 foreach (i, val; c.values)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	610 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	611 auto BB = Function.InsertBasicBlock(defBB, "sw.bb");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	612 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	613
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	614 if (i + 1 == c.values.length)
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 b.positionAtEnd(BB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	617 foreach (case_statement; c.stmts)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	618 genStmt(case_statement);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	619 if (!BB.terminated())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	620 b.buildBr(c.followedByDefault? defBB : endBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	621 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	622
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	623 if (prevBB !is null && !prevBB.terminated())
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 b.positionAtEnd(prevBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	626 b.buildBr(BB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	627 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	628 prevBB = BB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	629 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	630 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	631 b.positionAtEnd(endBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	632 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	633 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	634 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	635
155 2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	636 /**
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	637 Generate a loop.
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	638
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	639 Loops while cond is true, executing all statements in stmts every time.
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	640
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	641 If skipFirstCond is set, the condition is skipped the first time around,
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	642 like in a do-while loop.
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	643 **/
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	644 void genLoop(Scope env, Exp cond, bool skipFirstCond, Stmt[] stmts...)
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	645 {
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	646 auto fd = env.parentFunction();
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	647 Function func = m.getNamedFunction(symbolName(fd));
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	648
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	649 auto condBB = func.appendBasicBlock("cond");
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	650 auto bodyBB = func.appendBasicBlock("body");
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	651 auto doneBB = func.appendBasicBlock("done");
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	652
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	653 b.buildBr(skipFirstCond? bodyBB : condBB);
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	654 b.positionAtEnd(condBB);
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	655
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	656 Value cond_v = genExpression(cond).value;
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	657 if (cond_v.type !is Type.Int1)
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	658 {
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	659 Value False = ConstantInt.GetS(cond_v.type, 0);
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	660 cond_v = b.buildICmp(IntPredicate.NE, cond_v, False, ".cond");
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	661 }
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	662 b.buildCondBr(cond_v, bodyBB, doneBB);
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	663
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	664 b.positionAtEnd(bodyBB);
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	665 foreach (stmt; stmts)
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	666 genStmt(stmt);
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	667 if (b.getInsertBlock().terminated() is false)
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	668 b.buildBr(condBB);
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	669
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	670 b.positionAtEnd(doneBB);
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	671 }
2149f4a7b48d Codegen for statements Anders Halager <halager@gmail.com> parents: 143 diff changeset	672
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	673 /*
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	674 Get the address of an expression - allowing us to modify something in
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	675 memory or on the stack.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	676 */
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	677 LValue genLValue(Exp exp)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	678 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	679 switch(exp.expType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	680 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	681 case ExpType.Identifier:
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	682 auto id = cast(Identifier)exp;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	683 return LValue(table.find(id.get));
80 682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	684 case ExpType.Deref:
116 0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 113 diff changeset	685 // LValue(*x): load(x)
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 113 diff changeset	686 // RValue(*x): load(load(x))
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	687 // This way x = x + 1 will work
116 0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 113 diff changeset	688 // We need an ekstra load, because we get an i32** rather than
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 113 diff changeset	689 // i32* since stuff is alloc'd
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	690 auto DE = cast(DerefExp)exp;
113 244142a21cbc Fix derefs as lvalues Anders Halager <halager@gmail.com> parents: 107 diff changeset	691 return LValue(genExpression(DE.exp).value);
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	692 case ExpType.Index:
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	693 auto indexExp = cast(IndexExp)exp;
85 9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	694 auto type = indexExp.target.type;
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	695 auto index = genExpression(indexExp.index);
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	696 Value[2] gep_indices;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	697 gep_indices[0] = ZeroIndex;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	698 gep_indices[1] = index.value;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	699 Value res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	700 auto target = genLValue(indexExp.target).getAddress();
136 2be29b296081 Lots of changes: johnsen@johnsen-laptop parents: 129 diff changeset	701 if (type.isStaticArray())
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	702 res = b.buildGEP(target, gep_indices[0 .. 2], "index");
85 9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	703 else if (type.isPointer())
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	704 res = b.buildGEP(target, gep_indices[1 .. 2], "index");
85 9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	705 else assert(0, "Can only index pointers and arrays");
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	706 return LValue(res);
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	707 case ExpType.MemberReference:
79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	708 auto mem = cast(MemberReference)exp;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	709 switch (mem.target.expType)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	710 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	711 case ExpType.Identifier:
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	712 auto id = cast(Identifier)mem.target;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	713 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	714 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	715 DType t = id.type;
173 50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	716 if (auto st = t.asStruct)
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	717 {
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	718 int i = st.indexOf(child.get);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	719 if (i == -1)
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	720 {
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	721 auto fname = mem.getSymbol.getMangledFQN();
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	722 auto f = m.getNamedFunction(fname);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	723 return LValue(f);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	724 }
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	725
173 50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	726 Value[2] vals;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	727 vals[0] = ZeroIndex;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	728 vals[1] = ConstantInt.GetU(IntegerType.Int32, i);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	729
173 50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	730 Value val = b.buildGEP(v, vals, id.get~"."~child.get);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	731 return LValue(val);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	732 }
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	733 else if (auto ct = t.asClass)
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	734 {
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	735 int i = ct.indexOf(child.get);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	736 Value[2] vals;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	737 vals[0] = ZeroIndex;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	738 // A normal member
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	739 if (i != -1)
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	740 {
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	741 vals[1] = ConstantInt.GetU(IntegerType.Int32, i);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	742 Value val = b.buildGEP(v, vals, id.get~"."~child.get);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	743 return LValue(val);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	744 }
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	745 // A method
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	746 else
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	747 {
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	748 vals[1] = ZeroIndex;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	749 //vals[1] = ConstantInt.GetU(IntegerType.Int32, 1);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	750 auto vtbl_name = ct.name ~ "_vtable";
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	751 auto vtbl = m.getNamedGlobal(vtbl_name);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	752 v = vtbl;
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	753 }
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	754
173 50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	755 Value val = b.buildGEP(v, vals, id.get~"."~child.get);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	756 return LValue(val);
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	757 }
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	758 else
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	759 assert(0, "Can only access members in classes "
50b98a06a200 Start of support for virtual functions Anders Halager <halager@gmail.com> parents: 171 diff changeset	760 "and structs");
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	761
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	762 case ExpType.MemberReference:
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	763 auto addr = genLValue(mem.target).getAddress();
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	764 auto child = mem.child;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	765 DStruct t = mem.target.type.asStruct();
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	766
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	767 int i = t.indexOf(child.get);
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	768
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	769 Value[2] vals;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	770 vals[0] = ZeroIndex;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	771 vals[1] = ConstantInt.GetU(IntegerType.Int32, i);
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	772
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	773 Value val = b.buildGEP(addr, vals, "."~child.get);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	774 return LValue(val);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	775 }
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	776 break;
51 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 assert(0, "Reached end of switch in getPointer");
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	779 return LValue(null);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	780 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	781
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	782 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	783 Store into an lvalue from a rvalue. Both are assumed to have type t.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	784 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	785 void storeThroughLValue(LValue dst, RValue src, DType t)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	786 {
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	787 Value to = dst.getAddress();
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	788 Value from = src.value;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	789
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	790 auto a = cast(PointerType)to.type;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	791 assert(a !is null, "Can only store through pointers");
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	792
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	793 if (auto st = t.asStruct())
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	794 genMemcpy(to, from, t);
160 6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	795 else if (auto sa = t.asStaticArray())
6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	796 genMemcpy(to, from, t, sa.arrayOf.byteSize);
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	797 else
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	798 b.buildStore(from, to);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	799 }
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	800
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	801 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	802 Copy from src into dst. The values are assumed to have the same size,
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	803 and the amount of bytes to copy is taken from t.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	804 **/
160 6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	805 void genMemcpy(Value dst, Value src, DType t, int alignment = 16)
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	806 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	807 Value from = b.buildBitCast(src, BytePtr, ".copy_from");
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	808 Value to = b.buildBitCast(dst, BytePtr, ".copy_to");
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	809 Value[4] args;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	810 args[0] = to;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	811 args[1] = from;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	812 args[2] = ConstantInt.GetS(Type.Int32, t.byteSize());
160 6cb2f4201e2a Improved static arrays Anders Halager <halager@gmail.com> parents: 155 diff changeset	813 args[3] = ConstantInt.GetS(Type.Int32, alignment);
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	814 b.buildCall(llvm_memcpy, args[], null);
51 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
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	817 /**
120 7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	818 Generate the statements necessary to convert V, from type 'from' to type
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	819 'to'.
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	820 **/
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	821 RValue genTypeCast(RValue V, DType from, DType to)
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	822 {
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	823 Value delegate(Value, Type, char[]) extend, trunc;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	824 if(auto ito = to.asInteger())
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	825 {
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	826 extend = ito.unsigned? &b.buildZExt : &b.buildSExt;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	827 trunc = &b.buildTrunc;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	828 if(auto rfrom = from.isReal())
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	829 {
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	830 extend = ito.unsigned? &b.buildFPToUI : &b.buildFPToSI;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	831 trunc = extend;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	832 }
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	833 }
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	834 else if (auto rto = to.asReal())
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	835 {
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	836 extend = &b.buildFPExt;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	837 trunc = &b.buildFPTrunc;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	838 if(auto ifrom = from.isInteger())
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	839 {
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	840 extend = rto.unsigned? &b.buildUIToFP : &b.buildSIToFP;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	841 trunc = extend;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	842 }
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	843 }
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	844 else
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	845 assert(0, "implicit cast need implimentation");
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	846
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	847 Value res;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	848 if (from.byteSize() < to.byteSize())
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	849 res = extend(V.value, llvm(to), "ext");
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	850 else
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	851 res = trunc(V.value, llvm(to), "trunc");
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	852 return RValue(res);
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	853 }
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	854
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	855 /**
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	856 Given the address of something, load it into an alloc.
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	857 **/
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	858 RValue loadLValue(LValue addr, char[] name = null)
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	859 {
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	860 Value val = addr.getAddress();
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	861 if (name is null)
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	862 name = val.name.length > 0? val.name : "load";
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	863
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	864 auto res = b.buildLoad(val, name);
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	865 return RValue(res);
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	866 }
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	867
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	868 /// Get the mangled name of a function
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	869 char[] symbolName(FuncDecl f)
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	870 {
143 d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	871 if (f.att.getExtern == Extern.D)
d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	872 return f.sym.getMangledFQN();
d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	873 return f.sym.getName;
d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	874 }
d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	875
d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	876 char[] symbolName(Exp f)
d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	877 {
d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	878 if (f.getSymbol.decl.att.getExtern == Extern.D)
d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	879 return f.getSymbol.getMangledFQN();
d76cc5cad4fc Added partial support for switches. Anders Johnsen <skabet@gmail.com> parents: 138 diff changeset	880 return f.getSymbol.getName;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	881 }
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	882
120 7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	883 /**
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	884 Get the LLVM Type corresponding to a DType.
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	885
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	886 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	887 well when the hashes are so uniform.
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	888
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	889 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	890 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	891 */
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	892 Type llvm(DType t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	893 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	894 if (auto llvm_t = t in type_map)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	895 return *llvm_t;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	896 return llvmCreateNew(t);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	897 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	898
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	899 // 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	900 // result
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	901 Type llvmCreateNew(DType t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	902 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	903 if (auto i = cast(DInteger)t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	904 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	905 Type res = IntegerType.Get(i.byteSize() * 8);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	906 type_map[t] = res;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	907 return res;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	908 }
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	909 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	910 {
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 57 diff changeset	911 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	912 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	913 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	914
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	915 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	916 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	917
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	918 foreach (m; array)
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	919 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	920
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 57 diff changeset	921 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	922 type_map[t] = res;
166 9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	923 m.addTypeName("struct." ~ s.name, res);
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	924 return res;
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	925 }
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	926 else if (auto c = t.asClass)
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	927 {
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	928 SmallArray!(Type) members;
171 f0385c044065 Make function overloads work in the codegen Anders Halager <halager@gmail.com> parents: 166 diff changeset	929 if (c.members.length > 0)
166 9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	930 {
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	931 DType[] array;
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	932 array.length = c.members.length;
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	933
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	934 foreach (m; c.members)
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	935 array[m.index] = m.type;
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	936
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	937 foreach (m; array)
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	938 members ~= llvm(m);
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	939 }
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	940 else members ~= Type.Int32;
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	941
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	942 Type res = StructType.Get(members.unsafe());
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	943 res = PointerType.Get(res);
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	944 type_map[t] = res;
9cfa33517526 Codegen support for new expressions (very lame so far) Anders Halager <halager@gmail.com> parents: 160 diff changeset	945 m.addTypeName("class." ~ c.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	946 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	947 }
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	948 else if (auto f = t.asFunction)
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	949 {
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	950 // 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	951 // 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	952 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	953 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	954
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	955 SmallArray!(Type, 8) params;
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	956 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	957 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	958 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	959 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	960 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	961 else
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	962 params ~= llvm(param);
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	963
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	964 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	965 type_map[t] = res;
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	966 return res;
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	967 }
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	968 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	969 {
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	970 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	971 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	972 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	973 }
136 2be29b296081 Lots of changes: johnsen@johnsen-laptop parents: 129 diff changeset	974 else if (auto f = t.asStaticArray)
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	975 {
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	976 Type res = ArrayType.Get(llvm(f.arrayOf), f.size);
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	977 type_map[t] = res;
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	978 return res;
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	979 }
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	980 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	981 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	982
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	983 // 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	984 void createBasicTypes()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	985 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	986 type_map[DType.Void] = Type.Void;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	987
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	988 type_map[DType.Bool] = Type.Int1;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	989 type_map[DType.Byte] = Type.Int8;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	990 type_map[DType.UByte] = Type.Int8;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	991 type_map[DType.Short] = Type.Int16;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	992 type_map[DType.UShort] = Type.Int16;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	993 type_map[DType.Int] = Type.Int32;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	994 type_map[DType.UInt] = Type.Int32;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	995 type_map[DType.Long] = Type.Int64;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	996 type_map[DType.ULong] = Type.Int64;
118 54585ad7e426 Added the DType -> llvm type mapping for some more types Anders Halager <halager@gmail.com> parents: 117 diff changeset	997
54585ad7e426 Added the DType -> llvm type mapping for some more types Anders Halager <halager@gmail.com> parents: 117 diff changeset	998 type_map[DType.Float] = Type.Float;
54585ad7e426 Added the DType -> llvm type mapping for some more types Anders Halager <halager@gmail.com> parents: 117 diff changeset	999 type_map[DType.Double] = Type.Double;
54585ad7e426 Added the DType -> llvm type mapping for some more types Anders Halager <halager@gmail.com> parents: 117 diff changeset	1000 type_map[DType.Real] = Type.X86_FP80;
54585ad7e426 Added the DType -> llvm type mapping for some more types Anders Halager <halager@gmail.com> parents: 117 diff changeset	1001
54585ad7e426 Added the DType -> llvm type mapping for some more types Anders Halager <halager@gmail.com> parents: 117 diff changeset	1002 type_map[DType.Char] = Type.Int8;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	1003 type_map[DType.WChar] = Type.Int16;
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	1004 type_map[DType.DChar] = Type.Int32;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1005 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1006
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1007 private:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1008
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1009 // llvm stuff
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1010 DModule mod;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1011 .llvm.llvm.Module m;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1012 Builder b;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1013 Function llvm_memcpy;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1014 ConstantInt ZeroIndex;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1015 Type BytePtr;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1016 Type[DType] type_map;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1017
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1018 SimpleSymbolTable table;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1019 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1020
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1021 private Operator op2op(BinaryExp.Operator op)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1022 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1023 alias BinaryExp.Operator O;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1024 Operator res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1025 switch (op) {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1026 case O.Add: res = Operator.Add; break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1027 case O.Sub: res = Operator.Sub; break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1028 case O.Mul: res = Operator.Mul; break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1029 case O.Div: res = Operator.Div; break;
125 d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	1030 case O.LeftShift: res = Operator.Shl; break;
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	1031 case O.RightShift: res = Operator.AShr; break;
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	1032 case O.UnsignedRightShift: res = Operator.LShr; break;
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	1033
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	1034 case O.And: res = Operator.And; break;
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	1035 case O.Or: res = Operator.Or; break;
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	1036 case O.Xor: res = Operator.Xor; break;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1037
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1038 case O.Eq: res = Operator.Eq; break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1039 case O.Ne: res = Operator.Ne; break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1040 case O.Lt: res = Operator.Lt; break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1041 case O.Le: res = Operator.Le; break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1042 case O.Gt: res = Operator.Gt; break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1043 case O.Ge: res = Operator.Ge; break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1044 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1045 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1046 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1047
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1048 private struct LLVMPred
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1049 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1050 bool isValid = false;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1051 bool isReal;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1052 union {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1053 IntPredicate intPred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1054 RealPredicate realPred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1055 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1056
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1057 static LLVMPred Int(IntPredicate p)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1058 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1059 LLVMPred res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1060 res.isValid = true;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1061 res.isReal = false;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1062 res.intPred = p;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1063 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1064 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1065 static LLVMPred Real(RealPredicate p)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1066 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1067 LLVMPred res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1068 res.isValid = true;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1069 res.isReal = true;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1070 res.realPred = p;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1071 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1072 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1073 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1074 private LLVMPred predFromBI(BuiltinOperation op)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1075 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1076 alias BuiltinOperation O;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1077 LLVMPred pred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1078 switch (op) {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1079 case O.Eq: pred = LLVMPred.Int(IntPredicate.EQ); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1080 case O.Ne: pred = LLVMPred.Int(IntPredicate.NE); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1081
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1082 case O.SLt: pred = LLVMPred.Int(IntPredicate.SLT); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1083 case O.ULt: pred = LLVMPred.Int(IntPredicate.ULT); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1084 case O.FLt: pred = LLVMPred.Real(RealPredicate.OLT); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1085
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1086 case O.SLe: pred = LLVMPred.Int(IntPredicate.SLE); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1087 case O.ULe: pred = LLVMPred.Int(IntPredicate.ULE); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1088 case O.FLe: pred = LLVMPred.Real(RealPredicate.OLE); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1089
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1090 case O.SGt: pred = LLVMPred.Int(IntPredicate.SGT); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1091 case O.UGt: pred = LLVMPred.Int(IntPredicate.UGT); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1092 case O.FGt: pred = LLVMPred.Real(RealPredicate.OGT); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1093
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1094 case O.SGe: pred = LLVMPred.Int(IntPredicate.SGE); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1095 case O.UGe: pred = LLVMPred.Int(IntPredicate.UGE); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1096 case O.FGe: pred = LLVMPred.Real(RealPredicate.OGE); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1097 };
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1098 return pred;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1099 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1100
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1101 private class VisitFuncDecls : Visitor!(void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1102 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1103 void delegate(FuncDecl) dg;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1104 this(void delegate(FuncDecl funcDecl) dg)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1105 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1106 this.dg = dg;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1107 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1108
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	1109 override void visitFuncDecl(FuncDecl fd)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1110 {
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	1111 dg(fd);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1112 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1113 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1114
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1115 private class SimpleSymbolTable
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1116 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1117 Value[char[]][] namedValues;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1118
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1119 void enterScope()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1120 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1121 namedValues ~= cast(Value[char[]])["__dollar":null];
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1122 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1123
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1124 void leaveScope()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1125 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1126 namedValues.length = namedValues.length - 1;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1127 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1128
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1129 Value put(Value val, char[] key)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1130 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1131 namedValues[$ - 1][key] = val;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1132 return val;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1133 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1134
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1135 Value find(char[] key)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1136 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1137 foreach_reverse (map; namedValues)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1138 if(auto val_ptr = key in map)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1139 return *val_ptr;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1140 return null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1141 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1142
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1143 alias find opIndex;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1144 alias put opIndexAssign;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1145 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1146

Mercurial > projects > dang

annotate gen/CodeGen.d @ 174:20ff3c31f600