projects/dang: gen/CodeGen.d annotate

annotate gen/CodeGen.d @ 136:2be29b296081

Lots of changes: - Parsing classes and interfaces - Fixed some seg faults in sema - Supporting "private" to some extend - And a lot of other small fixes

author	johnsen@johnsen-laptop
date	Fri, 11 Jul 2008 21:47:57 +0200
parents	ed815b31479b
children	efbf51d85f4d

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,
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	15 basic.LiteralParsing;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	16
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	17 import lexer.Token;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	18
92 771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	19 import sema.Scope,
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	20 sema.Visitor;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	21
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	22 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	23 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	24 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	25 private struct RValue
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	26 {
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 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	29 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	30 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	31 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	32 bool isSimple() { return simple; }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	33 /// Opposite of isSimple
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	34 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	35
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	36 Value value;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	37 private bool simple = true;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	38 }
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 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	42 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	43 private struct LValue
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	44 {
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	45 Value getAddress() { return value; }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	46 private Value value;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	47 }
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 class CodeGen
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	50 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	51 public:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	52 this()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	53 {
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	54 b = new Builder;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	55 ZeroIndex = ConstantInt.GetU(Type.Int32, 0);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	56
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	57 table = new SimpleSymbolTable();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	58
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	59 createBasicTypes();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	60 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	61
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	62 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	63 Generate a new module.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	64 **/
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 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	67 they can be referenced.
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	68
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	69 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	70 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	71
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	72 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	73
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	74 Optimize if requested
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	75
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	76 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	77 */
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	78 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	79 {
101 fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	80 this.mod = mod;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	81 // create module
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	82 m = new .llvm.llvm.Module("main_module");
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	83 scope(exit) m.dispose();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	84
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	85 table.enterScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	86
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	87 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	88 auto temp = FunctionType.Get(
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	89 Type.Void,
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	90 [BytePtr, BytePtr, Type.Int32, Type.Int32]);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	91 llvm_memcpy = m.addFunction(temp, "llvm.memcpy.i32");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	92
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	93 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	94 (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	95 {
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 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	97 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	98 {
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	99 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	100 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	101 {
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 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	103 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	104 }
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	105 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	106 {
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	107 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	108 param_types ~= pointer;
29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	109 }
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	110 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	111 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	112 }
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	113 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	114 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	115 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	116 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	117 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	118 auto func_t = FunctionType.Get(llvm(ret_t), param_types);
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	119 auto llfunc = m.addFunction(func_t, fd.sym.getMangledFQN());
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	120
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 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	122 {
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 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	124 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	125
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	126 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	127 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	128 {
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	129 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	130 continue;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	131 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	132 }
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	133 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	134 {
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	135 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	136 }
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	137 }
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 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	140 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	141 // 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	142 // 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	143 // 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	144 // 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	145 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	146
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	147 foreach (decl; mod.decls)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	148 genRootDecl(decl);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	149
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	150 table.leaveScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	151
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	152 // debug m.verify();
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	153
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	154 if(optimize)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	155 m.optimize(inline);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	156
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	157 m.writeBitcodeToFileHandle(handle);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	158 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	159
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	160 private:
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	161 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	162 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	163 **/
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	164 void genRootDecl(Decl decl)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	165 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	166 switch(decl.declType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	167 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	168 case DeclType.FuncDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	169 FuncDecl funcDecl = cast(FuncDecl)decl;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	170
82 06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	171 // Empty function - declare;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	172 if(funcDecl.emptyFunction)
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	173 return;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	174
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	175 llvm(funcDecl.type);
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	176 auto llfunc = m.getNamedFunction(funcDecl.sym.getMangledFQN());
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	177 auto func_tp = cast(PointerType)llfunc.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	178 auto func_t = cast(FunctionType)func_tp.elementType();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	179 auto ret_t = func_t.returnType();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	180
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	181
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	182 auto bb = llfunc.appendBasicBlock("entry");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	183 b.positionAtEnd(bb);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	184
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	185 table.enterScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	186 foreach (i, v; funcDecl.funcArgs)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	187 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	188 llfunc.getParam(i).name = v.identifier.get;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	189 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	190 if (!cast(PointerType)llfunc.getParam(i).type)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	191 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	192 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	193 // Value va = b.buildLoad(val, name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	194 b.buildStore(llfunc.getParam(i), AI);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	195 table[name] = AI;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	196 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	197 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	198 table[name] = llfunc.getParam(i);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	199 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	200
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	201 foreach (stmt; funcDecl.statements)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	202 genStmt(stmt);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	203
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	204 // 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	205 // add one (return 0 as default)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	206 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	207 if (ret_t is Type.Void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	208 b.buildRetVoid();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	209 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	210 b.buildRet(ConstantInt.GetS(ret_t, 0));
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	211
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	212 table.leaveScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	213 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	214
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	215 case DeclType.VarDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	216 auto varDecl = cast(VarDecl)decl;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	217 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	218 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	219 GlobalVariable g = m.addGlobal(t, id.get);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	220 g.initializer = ConstantInt.GetS(t, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	221 table[varDecl.identifier.get] = g;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	222 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	223
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	224 case DeclType.StructDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	225 auto structDecl = cast(StructDecl)decl;
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	226 llvm(structDecl.type);
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	227 //m.addTypeName(structDecl.identifier.get, llvm(structDecl.type));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	228 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	229
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	230 default:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	231 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	232 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	233 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	234
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	235 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	236 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	237 **/
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	238 void genDecl(Decl decl)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	239 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	240 switch(decl.declType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	241 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	242 case DeclType.VarDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	243 auto varDecl = cast(VarDecl)decl;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	244 auto id = varDecl.identifier;
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	245 auto name = id.get;
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	246 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	247 table[name] = AI;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	248 if (varDecl.init)
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	249 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	250 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	251 RValue src = genExpression(varDecl.init);
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	252 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	253 }
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	254 break;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	255
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	256 case DeclType.FuncDecl:
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	257 genRootDecl(decl);
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	258 break;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	259
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	260 default:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	261 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	262 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	263
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	264 // Remove - do it right (basic/Messages.d)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	265 struct PE
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	266 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	267 static char[] NoImplicitConversion =
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	268 "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	269 static char[] VoidRetInNonVoidFunc =
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	270 "Only void functions can return without an expression";
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	271 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	272
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	273 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	274 Takes two iX and overwrite the smaller one, with a sign-extended version
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	275 so both values can be operated on without worrying about the exact types.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	276
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	277 Used when adding a int and a long or similar.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	278
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	279 Currently unused
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	280 **/
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	281 void sextSmallerToLarger(ref Value left, ref Value right)
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 if (left.type != right.type)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	284 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	285 // try to find a convertion - only works for iX
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	286 IntegerType l = cast(IntegerType) left.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	287 IntegerType r = cast(IntegerType) right.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	288 if (l is null \|\| r is null)
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	289 assert(0, PE.NoImplicitConversion);
3a0cd42de9cc Removed misc/Error.d and is now using the error system all way through. Anders Johnsen <skabet@gmail.com> parents: 107 diff changeset	290 /*
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	291 .arg(left.type.toString)
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	292 .arg(right.type.toString);*/
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	293
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	294 if (l.numBits() < r.numBits())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	295 left = b.buildSExt(left, r, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	296 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	297 right = b.buildSExt(right, l, ".cast");
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 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	300
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	301 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	302 Generate a single expression.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	303
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	304 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	305 returns an RValue.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	306 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	307 RValue genExpression(Exp exp)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	308 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	309 switch(exp.expType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	310 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	311 case ExpType.Binary:
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	312 return RValue(genBinExp(cast(BinaryExp)exp));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	313 case ExpType.IntegerLit:
119 c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	314 auto integerLit = cast(IntegerLit)exp;
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	315 switch(integerLit.number.type)
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	316 {
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	317 case NumberType.Int:
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	318 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	319 case NumberType.Long:
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	320 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	321 case NumberType.ULong:
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	322 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	323 case NumberType.Float:
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	324 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	325 case NumberType.Double:
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	326 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	327 case NumberType.Real:
c0b531362ca6 Non compileing commit. Work on floating points and casts Anders Johnsen <skabet@gmail.com> parents: 118 diff changeset	328 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	329 }
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	330 case ExpType.Negate:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	331 auto negateExp = cast(NegateExp)exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	332 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	333 return RValue(b.buildNeg(target.value, "neg"));
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	334 case ExpType.Deref:
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	335 auto derefExp = cast(DerefExp)exp;
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 74 diff changeset	336 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	337 return RValue(b.buildLoad(target.value, "deref"));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	338 case ExpType.AssignExp:
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	339 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	340 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	341 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	342 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	343 return src;
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	344 case ExpType.Index:
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	345 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	346 return loadLValue(genLValue(exp));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	347 case ExpType.CallExp:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	348 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	349 // 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	350 // valid call - or foo(x)(y) for that matter.
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	351
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	352 // 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	353 // if function ptr: do something else
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	354 // if delegate do a third thing
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	355 // if struct/class check for opCall
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	356 DType type = callExp.exp.type;
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	357 assert (type.isFunction(), "Can only call functions");
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	358 auto sym = callExp.exp.getSymbol();
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	359 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	360 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	361 args[i] = genExpression(arg).value;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	362 llvm(type);
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	363 auto f = m.getNamedFunction(sym.getMangledFQN());
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	364 DFunction f_type = type.asFunction();
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	365 bool isVoid = f_type.returnType is DType.Void;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	366 // BUG: doesn't do implicit type-conversion on args
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	367 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	368 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	369 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	370 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	371 exp = castExp.exp;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	372 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	373
120 7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	374 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	375 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	376
120 7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	377 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	378
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	379 case ExpType.Identifier:
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	380 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	381 if(id.type.isStruct() \|\| id.type.isArray())
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	382 return RValue(table.find(id.get));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	383 else
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	384 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	385 case ExpType.MemberReference:
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	386 return loadLValue(genLValue(exp));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	387 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	388 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	389 return RValue(null);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	390 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	391
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	392 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	393 Generate a binary expression.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	394
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	395 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	396 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	397 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	398 Value genBinExp(BinaryExp e)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	399 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	400 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	401 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	402 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	403 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	404
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	405 Value res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	406 // 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	407 // TODO: support floats
116 0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 113 diff changeset	408 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	409 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	410 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	411 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	412 "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	413 alias BuiltinOperation BO;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	414 BO val = op.builtinOp();
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	415 // 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	416 switch (val) {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	417 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	418 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	419 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	420 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	421 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	422 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	423 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	424 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	425 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	426
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	427 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	428 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	429 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	430
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	431 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	432 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	433 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	434
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	435 default:
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	436 LLVMPred pred = predFromBI(val);
121 95dfe2f48dcf Allow == and != on reals Anders Halager <halager@gmail.com> parents: 120 diff changeset	437 if (t_a.isReal())
95dfe2f48dcf Allow == and != on reals Anders Halager <halager@gmail.com> parents: 120 diff changeset	438 if (val == BO.Eq)
95dfe2f48dcf Allow == and != on reals Anders Halager <halager@gmail.com> parents: 120 diff changeset	439 pred = LLVMPred.Real(RealPredicate.OEQ);
95dfe2f48dcf Allow == and != on reals Anders Halager <halager@gmail.com> parents: 120 diff changeset	440 else if (val == BO.Ne)
95dfe2f48dcf Allow == and != on reals Anders Halager <halager@gmail.com> parents: 120 diff changeset	441 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	442 IntPredicate ip = pred.intPred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	443 RealPredicate rp = pred.realPred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	444 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	445 if (pred.isReal)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	446 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	447 else
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	448 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	449 break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	450 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	451 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	452 else
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	453 /*
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	454 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	455 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	456 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	457 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	458 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	459 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	460 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	461 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	462 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	463 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	464 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	465 else error
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	466 */
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	467 assert(0, "Not integers?");
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	468
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	469 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	470 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	471
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	472 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	473 Generates one statement
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 // 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	476 void genStmt(Stmt stmt)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	477 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	478 switch(stmt.stmtType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	479 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	480 case StmtType.Compound:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	481 auto stmts = cast(CompoundStatement)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	482 foreach (s; stmts.statements)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	483 genStmt(s);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	484 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	485 case StmtType.Return:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	486 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	487 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	488 Type t = llvm(type.returnType);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	489 if (ret.exp is null)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	490 if (t is Type.Void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	491 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	492 b.buildRetVoid();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	493 return;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	494 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	495 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	496 assert(0, PE.VoidRetInNonVoidFunc);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	497
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	498 RValue v = genExpression(ret.exp);
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	499 /* if (v.type != t)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	500 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	501 IntegerType v_t = cast(IntegerType) v.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	502 IntegerType i_t = cast(IntegerType) t;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	503 if (v_t is null \|\| i_t is null)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	504 throw error(__LINE__, PE.NoImplicitConversion)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	505 .arg(v.type.toString)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	506 .arg(t.toString);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	507
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	508 if (v_t.numBits() < i_t.numBits())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	509 v = b.buildSExt(v, t, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	510 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	511 v = b.buildTrunc(v, t, ".cast");
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	512 }*/
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	513 b.buildRet(v.value);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	514 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	515 case StmtType.Decl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	516 auto declStmt = cast(DeclStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	517 genDecl(declStmt.decl);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	518 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	519 case StmtType.Exp:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	520 auto expStmt = cast(ExpStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	521 genExpression(expStmt.exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	522 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	523 case StmtType.If:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	524 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	525 Value cond = genExpression(ifStmt.cond).value;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	526 if (cond.type !is Type.Int1)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	527 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	528 Value False = ConstantInt.GetS(cond.type, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	529 cond = b.buildICmp(IntPredicate.NE, cond, False, ".cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	530 }
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	531 auto func_name = symbolName(stmt.env.parentFunction());
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	532 Function func = m.getNamedFunction(func_name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	533 bool has_else = (ifStmt.else_body !is null);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	534
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	535 auto thenBB = func.appendBasicBlock("then");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	536 auto elseBB = has_else? func.appendBasicBlock("else") : null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	537 auto mergeBB = func.appendBasicBlock("merge");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	538
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	539 b.buildCondBr(cond, thenBB, has_else? elseBB : mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	540 b.positionAtEnd(thenBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	541 genStmt(ifStmt.then_body);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	542 thenBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	543 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	544 b.buildBr(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	545
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	546 if (has_else)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	547 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	548 b.positionAtEnd(elseBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	549 genStmt(ifStmt.else_body);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	550 elseBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	551 if (elseBB.terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	552 b.buildBr(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	553 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	554
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	555 b.positionAtEnd(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	556 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	557 case StmtType.While:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	558 auto wStmt = cast(WhileStmt)stmt;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	559 auto fd = stmt.env.parentFunction();
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	560 Function func = m.getNamedFunction(symbolName(fd));
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	561
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	562 auto condBB = func.appendBasicBlock("cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	563 auto bodyBB = func.appendBasicBlock("body");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	564 auto doneBB = func.appendBasicBlock("done");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	565
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	566 b.buildBr(condBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	567 b.positionAtEnd(condBB);
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	568 Value cond = genExpression(wStmt.cond).value;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	569 if (cond.type !is Type.Int1)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	570 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	571 Value False = ConstantInt.GetS(cond.type, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	572 cond = b.buildICmp(IntPredicate.NE, cond, False, ".cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	573 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	574 b.buildCondBr(cond, bodyBB, doneBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	575
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	576 b.positionAtEnd(bodyBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	577 genStmt(wStmt.whileBody);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	578 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	579 b.buildBr(condBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	580
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	581 b.positionAtEnd(doneBB);
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
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	587 auto func_name = stmt.env.parentFunction().identifier.get;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	588 Function func = m.getNamedFunction(func_name);
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
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	636 /*
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	637 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	638 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	639 */
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	640 LValue genLValue(Exp exp)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	641 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	642 switch(exp.expType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	643 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	644 case ExpType.Identifier:
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	645 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	646 return LValue(table.find(id.get));
80 682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	647 case ExpType.Deref:
116 0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 113 diff changeset	648 // LValue(*x): load(x)
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 113 diff changeset	649 // 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	650 // 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	651 // 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	652 // 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	653 auto DE = cast(DerefExp)exp;
113 244142a21cbc Fix derefs as lvalues Anders Halager <halager@gmail.com> parents: 107 diff changeset	654 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	655 case ExpType.Index:
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	656 auto indexExp = cast(IndexExp)exp;
85 9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	657 auto type = indexExp.target.type;
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	658 auto index = genExpression(indexExp.index);
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	659 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	660 gep_indices[0] = ZeroIndex;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	661 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	662 Value res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	663 auto target = genLValue(indexExp.target).getAddress();
136 2be29b296081 Lots of changes: johnsen@johnsen-laptop parents: 129 diff changeset	664 if (type.isStaticArray())
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	665 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	666 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	667 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	668 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	669 return LValue(res);
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	670 case ExpType.MemberReference:
79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	671 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	672 switch (mem.target.expType)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	673 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	674 case ExpType.Identifier:
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	675 auto id = cast(Identifier)mem.target;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	676 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	677 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	678 DType t = id.type;
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	679 auto st = t.asStruct;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	680
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 54 diff changeset	681 int i = st.indexOf(child.get);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	682
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	683 Value[2] vals;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	684 vals[0] = ZeroIndex;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	685 vals[1] = ConstantInt.GetU(IntegerType.Int32, i);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	686
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	687 Value val = b.buildGEP(v, vals, id.get~"."~child.get);
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	688 return LValue(val);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	689
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	690 case ExpType.MemberReference:
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	691 auto addr = genLValue(mem.target).getAddress();
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	692 auto child = mem.child;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	693 DStruct t = mem.target.type.asStruct();
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	694
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	695 int i = t.indexOf(child.get);
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 70 diff changeset	696
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	697 Value[2] vals;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	698 vals[0] = ZeroIndex;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	699 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	700
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	701 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	702 return LValue(val);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	703 }
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	704 break;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	705 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	706 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	707 return LValue(null);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	708 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	709
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	710 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	711 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	712 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	713 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	714 {
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	715 Value to = dst.getAddress();
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	716 Value from = src.value;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	717
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	718 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	719 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	720
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	721 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	722 genMemcpy(to, from, t);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	723 else
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	724 b.buildStore(from, to);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	725 }
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	726
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	727 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	728 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	729 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	730 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	731 void genMemcpy(Value dst, Value src, DType t)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	732 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	733 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	734 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	735 Value[4] args;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	736 args[0] = to;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	737 args[1] = from;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	738 args[2] = ConstantInt.GetS(Type.Int32, t.byteSize());
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	739 args[3] = ConstantInt.GetS(Type.Int32, 32);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	740 b.buildCall(llvm_memcpy, args[], null);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	741 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	742
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	743 /**
120 7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	744 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	745 'to'.
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	746 **/
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	747 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	748 {
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	749 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	750 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	751 {
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	752 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	753 trunc = &b.buildTrunc;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	754 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	755 {
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	756 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	757 trunc = extend;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	758 }
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	759 }
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	760 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	761 {
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	762 extend = &b.buildFPExt;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	763 trunc = &b.buildFPTrunc;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	764 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	765 {
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	766 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	767 trunc = extend;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	768 }
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	769 }
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	770 else
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	771 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	772
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	773 Value res;
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	774 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	775 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	776 else
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	777 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	778 return RValue(res);
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	779 }
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	780
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	781 /**
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	782 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	783 **/
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	784 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	785 {
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	786 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	787 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	788 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	789
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	790 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	791 return RValue(res);
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	792 }
7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	793
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	794 /// Get the mangled name of a function
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	795 char[] symbolName(FuncDecl f)
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	796 {
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	797 return f.sym.getMangledFQN();
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	798 }
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	799
120 7d0898f77685 Implement the cast expression - works for integers and real/float/double Anders Halager <halager@gmail.com> parents: 119 diff changeset	800 /**
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	801 Get the LLVM Type corresponding to a DType.
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	802
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	803 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	804 well when the hashes are so uniform.
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	805
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	806 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	807 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	808 */
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	809 Type llvm(DType t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	810 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	811 if (auto llvm_t = t in type_map)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	812 return *llvm_t;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	813 return llvmCreateNew(t);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	814 }
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 // 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	817 // result
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	818 Type llvmCreateNew(DType t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	819 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	820 if (auto i = cast(DInteger)t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	821 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	822 Type res = IntegerType.Get(i.byteSize() * 8);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	823 type_map[t] = res;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	824 return res;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	825 }
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	826 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	827 {
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 57 diff changeset	828 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	829 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	830 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	831
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	832 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	833 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	834
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	835 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	836 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	837
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 57 diff changeset	838 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	839 type_map[t] = res;
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	840 m.addTypeName(s.name, res);
53 da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 52 diff changeset	841 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	842 }
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	843 else if (auto f = t.asFunction)
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	844 {
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	845 // 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	846 // 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	847 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	848 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	849
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	850 SmallArray!(Type, 8) params;
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	851 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	852 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	853 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	854 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	855 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	856 else
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	857 params ~= llvm(param);
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	858
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	859 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	860 type_map[t] = res;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	861 /*
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	862 //TODO: create own DType -> FunctionType mapping without names
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	863 auto id = new Identifier(f.name);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	864 id.setType(f);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	865
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	866 auto f_name = symbolName(id);
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	867 auto f_t = m.getNamedFunction(f_name);
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	868 if(f_t is null)
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	869 {
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	870 Stdout("oh noes").newline;
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	871 auto llfunc = m.addFunction(res, f_name);
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	872
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	873 foreach (i, param; f.params)
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	874 if (param.isStruct)
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	875 llfunc.addParamAttr(i, ParamAttr.ByVal);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	876
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	877 if (f.firstParamIsReturnValue)
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	878 {
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	879 llfunc.removeParamAttr(0, ParamAttr.ByVal);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	880 llfunc.addParamAttr(0, ParamAttr.StructRet);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?) Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	881 }
64 91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are Anders Halager <halager@gmail.com> parents: 63 diff changeset	882 }
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	883 */
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	884 return res;
1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	885 }
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	886 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	887 {
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	888 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	889 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	890 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	891 }
136 2be29b296081 Lots of changes: johnsen@johnsen-laptop parents: 129 diff changeset	892 else if (auto f = t.asStaticArray)
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	893 {
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	894 Type res = ArrayType.Get(llvm(f.arrayOf), f.size);
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	895 type_map[t] = res;
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	896 return res;
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	897 }
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	898 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	899 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	900
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	901 // 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	902 void createBasicTypes()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	903 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	904 type_map[DType.Void] = Type.Void;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	905
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	906 type_map[DType.Bool] = Type.Int1;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	907 type_map[DType.Byte] = Type.Int8;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	908 type_map[DType.UByte] = Type.Int8;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	909 type_map[DType.Short] = Type.Int16;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	910 type_map[DType.UShort] = Type.Int16;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	911 type_map[DType.Int] = Type.Int32;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	912 type_map[DType.UInt] = Type.Int32;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	913 type_map[DType.Long] = Type.Int64;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	914 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	915
54585ad7e426 Added the DType -> llvm type mapping for some more types Anders Halager <halager@gmail.com> parents: 117 diff changeset	916 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	917 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	918 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	919
54585ad7e426 Added the DType -> llvm type mapping for some more types Anders Halager <halager@gmail.com> parents: 117 diff changeset	920 type_map[DType.Char] = Type.Int8;
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	921 type_map[DType.WChar] = Type.Int16;
ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	922 type_map[DType.DChar] = Type.Int32;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	923 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	924
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	925 private:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	926
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	927 // llvm stuff
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	928 DModule mod;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	929 .llvm.llvm.Module m;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	930 Builder b;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	931 Function llvm_memcpy;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	932 ConstantInt ZeroIndex;
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	933 Type BytePtr;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	934 Type[DType] type_map;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	935
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	936 SimpleSymbolTable table;
107 189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	937 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	938
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	939 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	940 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	941 alias BinaryExp.Operator O;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	942 Operator res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	943 switch (op) {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	944 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	945 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	946 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	947 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	948 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	949 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	950 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	951
d604152de1eb Support shifts and binary logical operators in codegen Anders Halager <halager@gmail.com> parents: 121 diff changeset	952 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	953 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	954 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	955
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	956 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	957 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	958 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	959 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	960 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	961 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	962 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	963 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	964 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	965
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	966 private struct LLVMPred
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	967 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	968 bool isValid = false;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	969 bool isReal;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	970 union {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	971 IntPredicate intPred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	972 RealPredicate realPred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	973 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	974
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	975 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	976 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	977 LLVMPred res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	978 res.isValid = true;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	979 res.isReal = false;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	980 res.intPred = p;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	981 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	982 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	983 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	984 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	985 LLVMPred res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	986 res.isValid = true;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	987 res.isReal = true;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	988 res.realPred = p;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	989 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	990 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	991 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	992 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	993 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	994 alias BuiltinOperation O;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	995 LLVMPred pred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	996 switch (op) {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	997 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	998 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	999
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1000 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	1001 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	1002 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	1003
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1004 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	1005 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	1006 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	1007
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1008 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	1009 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	1010 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	1011
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1012 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	1013 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	1014 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	1015 };
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes Anders Halager <halager@gmail.com> parents: 101 diff changeset	1016 return pred;
51 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
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1019 private class VisitFuncDecls : Visitor!(void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1020 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1021 void delegate(FuncDecl) dg;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1022 this(void delegate(FuncDecl funcDecl) dg)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1023 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1024 this.dg = dg;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1025 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1026
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	1027 override void visitFuncDecl(FuncDecl fd)
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1028 {
129 ed815b31479b Added a Symbol Anders Halager <halager@gmail.com> parents: 125 diff changeset	1029 dg(fd);
51 c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1030 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1031 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1032
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1033 private class SimpleSymbolTable
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1034 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1035 Value[char[]][] namedValues;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1036
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1037 void enterScope()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1038 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1039 namedValues ~= cast(Value[char[]])["__dollar":null];
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1040 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1041
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1042 void leaveScope()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1043 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1044 namedValues.length = namedValues.length - 1;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1045 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1046
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1047 Value put(Value val, char[] key)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1048 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1049 namedValues[$ - 1][key] = val;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1050 return val;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1051 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1052
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1053 Value find(char[] key)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1054 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1055 foreach_reverse (map; namedValues)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1056 if(auto val_ptr = key in map)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1057 return *val_ptr;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1058 return null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1059 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1060
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1061 alias find opIndex;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1062 alias put opIndexAssign;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1063 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen Anders Halager <halager@gmail.com> parents: diff changeset	1064

Mercurial > projects > dang

annotate gen/CodeGen.d @ 136:2be29b296081