projects/dang: gen/CodeGen.d annotate

annotate gen/CodeGen.d @ 166:9cfa33517526

Codegen support for new expressions (very lame so far) Calls the correct constructor, but it doesn't get a this pointer Objects are simply malloced, no GC

author	Anders Halager <halager@gmail.com>
date	Tue, 22 Jul 2008 21:34:53 +0200
parents	6cb2f4201e2a
children	f0385c044065

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

Mercurial > projects > dang

annotate gen/CodeGen.d @ 166:9cfa33517526