projects/dang: gen/CodeGen.d annotate

annotate gen/CodeGen.d @ 192:fda35d57847e

Fixed String parsing, so that they get created with the right type in AST. Also added so that you can parse options to the test program, that will mirror them to Dang. Eg. ./tests/run --semantic-only will pass --semantic-only to Dang on each run.

author	Anders Johnsen <skabet@gmail.com>
date	Fri, 25 Jul 2008 15:00:54 +0200
parents	08b6ce45b456
children	4e1a7265d620

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

Mercurial > projects > dang

annotate gen/CodeGen.d @ 192:fda35d57847e