Mercurial > projects > dang

annotate gen/CodeGen.d @ 107:189c049cbfcc new_gen

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Cleanup of codegen, better support for operators a few bugfixes
author Anders Halager <halager@gmail.com>
date Sun, 25 May 2008 14:40:14 +0200
parents fea8d61a2451
children 244142a21cbc 3a0cd42de9cc
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
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
58
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 57
diff changeset
14 import misc.Error,
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 57
diff changeset
15 basic.SmallArray;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
16
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
17 import lexer.Token;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
18
92
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot.
Anders Johnsen <skabet@gmail.com>
parents: 89
diff changeset
19 import sema.Scope,
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
20 sema.Visitor;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
21
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
22 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
23 Wrapper for Values representing rvalues (things you can only read from)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
24 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
25 private struct RValue
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
26 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
27 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
28 Returns true if this is a simple value, like an int or a pointer.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
29 This is basicly anything except a struct, which will contain a Value that
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
30 is a pointer to the struct.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
31 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
32 bool isSimple() { return simple; }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
33 /// Opposite of isSimple
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
34 bool isAggregate() { return !simple; }
94
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need.
Anders Johnsen <skabet@gmail.com>
parents: 93
diff changeset
35
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
36 Value value;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
37 private bool simple = true;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
38 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
39
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
40 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
41 Wrapper for Values representing lvalues (things you can write to)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
42 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
43 private struct LValue
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
44 {
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
45 Value getAddress() { return value; }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
46 private Value value;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
47 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
48
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
49 class CodeGen
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
50 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
51 public:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
52 this()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
53 {
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
54 b = new Builder;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
55 ZeroIndex = ConstantInt.GetU(Type.Int32, 0);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
56
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
57 table = new SimpleSymbolTable();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
58
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
59 createBasicTypes();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
60 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
61
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
62 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
63 Generate a new module.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
64 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
65 /*
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
66 Find all function decls and add the functions to the llvm module, so
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
67 they can be referenced.
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
68
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
69 Make sure all var-decls are located before functions, so we wont get
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
70 problems when referencing the global vars.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
71
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
72 Generate the actual llvm code needed for all decls
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
73
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
74 Optimize if requested
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
75
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
76 Write to filehandle (can be a file or stdout)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
77 */
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
78 void gen(DModule mod, uint handle, bool optimize, bool inline)
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
79 {
101
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
80 this.mod = mod;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
81 // create module
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
82 m = new .llvm.llvm.Module("main_module");
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
83 scope(exit) m.dispose();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
84
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
85 table.enterScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
86
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
87 BytePtr = PointerType.Get(Type.Int8);
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
88 auto temp = FunctionType.Get(
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
89 Type.Void,
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
90 [BytePtr, BytePtr, Type.Int32, Type.Int32]);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
91 llvm_memcpy = m.addFunction(temp, "llvm.memcpy.i32");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
92
68
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
93 auto registerFunc =
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
94 (FuncDecl fd)
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
95 {
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
96 Type[] param_types;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
97 foreach (i, p; fd.funcArgs)
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
98 {
86
29f486ccc203 Fixed a bug that made arrays as params fail big time
Anders Johnsen <skabet@gmail.com>
parents: 85
diff changeset
99 DType t = p.env.find(p.identifier).type;
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
100 if (auto st = t.asStruct())
68
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
101 {
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
102 Type pointer = PointerType.Get(llvm(st));
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
103 param_types ~= pointer;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
104 }
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
105 else if (auto ar = t.asArray())
86
29f486ccc203 Fixed a bug that made arrays as params fail big time
Anders Johnsen <skabet@gmail.com>
parents: 85
diff changeset
106 {
29f486ccc203 Fixed a bug that made arrays as params fail big time
Anders Johnsen <skabet@gmail.com>
parents: 85
diff changeset
107 Type pointer = PointerType.Get(llvm(ar));
29f486ccc203 Fixed a bug that made arrays as params fail big time
Anders Johnsen <skabet@gmail.com>
parents: 85
diff changeset
108 param_types ~= pointer;
29f486ccc203 Fixed a bug that made arrays as params fail big time
Anders Johnsen <skabet@gmail.com>
parents: 85
diff changeset
109 }
68
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
110 else
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
111 param_types ~= llvm(t);
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
112 }
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
113 auto ret_t = fd.env.find(fd.identifier).type;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
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);
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 94
diff changeset
119 auto llfunc = m.addFunction(func_t, fd.identifier.getMangled);
68
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
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
86
29f486ccc203 Fixed a bug that made arrays as params fail big time
Anders Johnsen <skabet@gmail.com>
parents: 85
diff changeset
126 DType t = p.env.find(p.identifier).type;
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
127 if (auto st = t.asStruct)
68
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
128 {
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
129 if (i == 0 && fd.sret)
68
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
130 continue;
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
131 llfunc.addParamAttr(i, ParamAttr.ByVal);
68
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
132 }
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
133 else if (auto ar = t.asArray)
86
29f486ccc203 Fixed a bug that made arrays as params fail big time
Anders Johnsen <skabet@gmail.com>
parents: 85
diff changeset
134 {
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
135 llfunc.addParamAttr(i, ParamAttr.ByVal);
86
29f486ccc203 Fixed a bug that made arrays as params fail big time
Anders Johnsen <skabet@gmail.com>
parents: 85
diff changeset
136 }
68
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
137 }
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
138 };
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
139 auto visitor = new VisitFuncDecls(registerFunc);
101
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
140 visitor.visit([mod]);
54
d84fec04d462 Move all root var-decls so they are generated before anything else
Anders Halager <halager@gmail.com>
parents: 53
diff changeset
141 // Before beginning we move all top level var-decls to the start
d84fec04d462 Move all root var-decls so they are generated before anything else
Anders Halager <halager@gmail.com>
parents: 53
diff changeset
142 // and then we generate the var-decls first
d84fec04d462 Move all root var-decls so they are generated before anything else
Anders Halager <halager@gmail.com>
parents: 53
diff changeset
143 // partition is NOT required to be stable, but that should not create
d84fec04d462 Move all root var-decls so they are generated before anything else
Anders Halager <halager@gmail.com>
parents: 53
diff changeset
144 // any problems.
94
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need.
Anders Johnsen <skabet@gmail.com>
parents: 93
diff changeset
145 partition(mod.decls, (Decl d) { return d.declType == DeclType.VarDecl; });
54
d84fec04d462 Move all root var-decls so they are generated before anything else
Anders Halager <halager@gmail.com>
parents: 53
diff changeset
146
94
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need.
Anders Johnsen <skabet@gmail.com>
parents: 93
diff changeset
147 foreach (decl; mod.decls)
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
148 genRootDecl(decl);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
149
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
150 table.leaveScope;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
151
92
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot.
Anders Johnsen <skabet@gmail.com>
parents: 89
diff changeset
152 // debug m.verify();
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
153
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
154 if(optimize)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
155 m.optimize(inline);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
156
89
a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source.
Anders Johnsen <skabet@gmail.com>
parents: 88
diff changeset
157 m.writeBitcodeToFileHandle(handle);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
158 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
159
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
160 private:
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
161 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
162 Generate a single top-level Decl
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
163 **/
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
164 void genRootDecl(Decl decl)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
165 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
166 switch(decl.declType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
167 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
168 case DeclType.FuncDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
169 FuncDecl funcDecl = cast(FuncDecl)decl;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
170
82
06dda301ea61 Can declare outside functions and call c-functions
Anders Johnsen <skabet@gmail.com>
parents: 81
diff changeset
171 // Empty function - declare;
06dda301ea61 Can declare outside functions and call c-functions
Anders Johnsen <skabet@gmail.com>
parents: 81
diff changeset
172 if(funcDecl.emptyFunction)
06dda301ea61 Can declare outside functions and call c-functions
Anders Johnsen <skabet@gmail.com>
parents: 81
diff changeset
173 return;
06dda301ea61 Can declare outside functions and call c-functions
Anders Johnsen <skabet@gmail.com>
parents: 81
diff changeset
174
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
175 llvm(funcDecl.type);
96
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules.
Anders Johnsen <skabet@gmail.com>
parents: 94
diff changeset
176 auto llfunc = m.getNamedFunction(funcDecl.identifier.getMangled);
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;
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
217 auto id = varDecl.env.find(varDecl.identifier);
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier.
Anders Johnsen <skabet@gmail.com>
parents: 92
diff changeset
218 Type t = llvm(id.type);
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier.
Anders Johnsen <skabet@gmail.com>
parents: 92
diff changeset
219 GlobalVariable g = m.addGlobal(t, id.get);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
220 g.initializer = ConstantInt.GetS(t, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
221 table[varDecl.identifier.get] = g;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
222 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
223
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
224 case DeclType.StructDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
225 auto structDecl = cast(StructDecl)decl;
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
226 llvm(structDecl.type);
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
227 //m.addTypeName(structDecl.identifier.get, llvm(structDecl.type));
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
228 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
229
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
230 default:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
231 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
232 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
233 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
234
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
235 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
236 Generate a single local Decl
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
237 **/
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
238 void genDecl(Decl decl)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
239 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
240 switch(decl.declType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
241 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
242 case DeclType.VarDecl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
243 auto varDecl = cast(VarDecl)decl;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
244 auto name = varDecl.identifier.get;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
245 auto sym = varDecl.env.find(varDecl.identifier);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
246 auto AI = b.buildAlloca(llvm(sym.type), name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
247 table[name] = AI;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
248 if (varDecl.init)
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
249 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
250 LValue dst = genLValue(varDecl.identifier);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
251 RValue src = genExpression(varDecl.init);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
252 storeThroughLValue(dst, src, sym.type);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
253 }
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
254 break;
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 default:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
257 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
258 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
259
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
260 // Remove - do it right (basic/Messages.d)
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
261 struct PE
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
262 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
263 static char[] NoImplicitConversion =
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
264 "Can't find an implicit conversion between %0 and %1";
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
265 static char[] VoidRetInNonVoidFunc =
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
266 "Only void functions can return without an expression";
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
267 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
268
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
269 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
270 Takes two iX and overwrite the smaller one, with a sign-extended version
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
271 so both values can be operated on without worrying about the exact types.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
272
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
273 Used when adding a int and a long or similar.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
274
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
275 Currently unused
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 void sextSmallerToLarger(ref Value left, ref Value right)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
278 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
279 if (left.type != right.type)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
280 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
281 // try to find a convertion - only works for iX
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
282 IntegerType l = cast(IntegerType) left.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
283 IntegerType r = cast(IntegerType) right.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
284 if (l is null || r is null)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
285 throw error(__LINE__, PE.NoImplicitConversion)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
286 .arg(left.type.toString)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
287 .arg(right.type.toString);
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 if (l.numBits() < r.numBits())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
290 left = b.buildSExt(left, r, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
291 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
292 right = b.buildSExt(right, l, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
293 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
294 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
295
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
296 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
297 Generate a single expression.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
298
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
299 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
300 returns an RValue.
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 RValue genExpression(Exp exp)
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
303 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
304 switch(exp.expType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
305 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
306 case ExpType.Binary:
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
307 return RValue(genBinExp(cast(BinaryExp)exp));
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
308 case ExpType.IntegerLit:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
309 auto integetLit = cast(IntegerLit)exp;
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
310 auto val = Integer.parse(integetLit.get);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
311 return RValue(ConstantInt.GetS(Type.Int32, val));
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
312 case ExpType.Negate:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
313 auto negateExp = cast(NegateExp)exp;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
314 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
315 return RValue(b.buildNeg(target.value, "neg"));
78
ad956143dcdc Parse and gen for dereferences
Anders Halager <halager@gmail.com>
parents: 74
diff changeset
316 case ExpType.Deref:
ad956143dcdc Parse and gen for dereferences
Anders Halager <halager@gmail.com>
parents: 74
diff changeset
317 auto derefExp = cast(DerefExp)exp;
ad956143dcdc Parse and gen for dereferences
Anders Halager <halager@gmail.com>
parents: 74
diff changeset
318 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
319 return RValue(b.buildLoad(target.value, "deref"));
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
320 case ExpType.AssignExp:
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
321 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
322 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
323 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
324 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
325 return src;
83
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 82
diff changeset
326 case ExpType.Index:
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 82
diff changeset
327 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
328 return loadLValue(genLValue(exp));
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
329 case ExpType.CallExp:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
330 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
331 // 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
332 // valid call - or foo(x)(y) for that matter.
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
333 auto id = exp.env.find(cast(Identifier)callExp.exp);
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
334 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
335 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
336 args[i] = genExpression(arg).value;
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
337 llvm(id.type);
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
338 auto f = m.getNamedFunction(id.getMangled);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
339 DFunction f_type = cast(DFunction)id.type;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
340 bool isVoid = f_type.returnType is DType.Void;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
341 // BUG: doesn't do implicit type-conversion on args
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
342 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
343 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
344 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
345 auto castExp = cast(CastExp)exp;
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
346 auto value = genExpression(castExp.exp).value;
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
347
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
348 if (!castExp.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
349 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
350
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
351 Value v;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
352 if(castExp.exp.type.byteSize <= castExp.type.byteSize)
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
353 v = b.buildZExt(value, llvm(castExp.type), "zext");
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
354 else
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
355 v = b.buildTrunc(value, llvm(castExp.type), "trunc");
68
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing...
Anders Johnsen <skabet@gmail.com>
parents: 67
diff changeset
356
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
357 return RValue(v);
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
358
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
359 case ExpType.Identifier:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
360 auto identifier = cast(Identifier)exp;
93
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier.
Anders Johnsen <skabet@gmail.com>
parents: 92
diff changeset
361 auto id = exp.env.find(identifier);
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
362 if(id.type.isStruct() || id.type.isArray())
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
363 return RValue(table.find(id.get));
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
364 else
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
365 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
366 case ExpType.MemberReference:
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
367 return loadLValue(genLValue(exp));
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
368 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
369 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
370 return RValue(null);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
371 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
372
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
373 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
374 Generate a binary expression.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
375
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
376 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
377 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
378 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
379 Value genBinExp(BinaryExp e)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
380 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
381 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
382 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
383 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
384 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
385
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
386 Value res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
387 // 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
388 // TODO: support floats
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
389 if (t_a.isInteger() && t_b.isInteger())
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
390 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
391 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
392 assert(op.isBuiltin(),
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
393 "integers should only use builtin ops");
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
394 alias BuiltinOperation BO;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
395 BO val = op.builtinOp();
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
396 // 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
397 switch (val) {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
398 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
399 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
400 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
401 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
402 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
403 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
404 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
405 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
406 case BO.FRem: res = b.buildFRem(left, right, "rem"); break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
407 default:
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
408 LLVMPred pred = predFromBI(val);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
409 IntPredicate ip = pred.intPred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
410 RealPredicate rp = pred.realPred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
411 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
412 if (pred.isReal)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
413 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
414 else
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
415 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
416 break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
417 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
418 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
419 else
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
420 /*
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
421 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
422 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
423 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
424 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
425 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
426 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
427 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
428 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
429 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
430 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
431 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
432 else error
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 assert(0, "Not integers?");
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
435
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
436 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
437 }
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 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
440 Generates one statement
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
441 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
442 // 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
443 void genStmt(Stmt stmt)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
444 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
445 switch(stmt.stmtType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
446 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
447 case StmtType.Compound:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
448 auto stmts = cast(CompoundStatement)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
449 foreach (s; stmts.statements)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
450 genStmt(s);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
451 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
452 case StmtType.Return:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
453 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
454 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
455 Type t = llvm(type.returnType);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
456 if (ret.exp is null)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
457 if (t is Type.Void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
458 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
459 b.buildRetVoid();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
460 return;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
461 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
462 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
463 throw error(__LINE__, PE.VoidRetInNonVoidFunc);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
464
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
465 RValue v = genExpression(ret.exp);
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 54
diff changeset
466 /* if (v.type != t)
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
467 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
468 IntegerType v_t = cast(IntegerType) v.type;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
469 IntegerType i_t = cast(IntegerType) t;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
470 if (v_t is null || i_t is null)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
471 throw error(__LINE__, PE.NoImplicitConversion)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
472 .arg(v.type.toString)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
473 .arg(t.toString);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
474
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
475 if (v_t.numBits() < i_t.numBits())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
476 v = b.buildSExt(v, t, ".cast");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
477 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
478 v = b.buildTrunc(v, t, ".cast");
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 54
diff changeset
479 }*/
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
480 b.buildRet(v.value);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
481 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
482 case StmtType.Decl:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
483 auto declStmt = cast(DeclStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
484 genDecl(declStmt.decl);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
485 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
486 case StmtType.Exp:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
487 auto expStmt = cast(ExpStmt)stmt;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
488 genExpression(expStmt.exp);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
489 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
490 case StmtType.If:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
491 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
492 Value cond = genExpression(ifStmt.cond).value;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
493 if (cond.type !is Type.Int1)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
494 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
495 Value False = ConstantInt.GetS(cond.type, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
496 cond = b.buildICmp(IntPredicate.NE, cond, False, ".cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
497 }
98
7f9240d4ddc1 Fixed tests - forgot some stuff in codegen.
Anders Johnsen <skabet@gmail.com>
parents: 96
diff changeset
498 auto func_name = stmt.env.parentFunction().identifier.getMangled;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
499 Function func = m.getNamedFunction(func_name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
500 bool has_else = (ifStmt.else_body !is null);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
501
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
502 auto thenBB = func.appendBasicBlock("then");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
503 auto elseBB = has_else? func.appendBasicBlock("else") : null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
504 auto mergeBB = func.appendBasicBlock("merge");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
505
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
506 b.buildCondBr(cond, thenBB, has_else? elseBB : mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
507 b.positionAtEnd(thenBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
508 genStmt(ifStmt.then_body);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
509 thenBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
510 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
511 b.buildBr(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
512
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
513 if (has_else)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
514 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
515 b.positionAtEnd(elseBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
516 genStmt(ifStmt.else_body);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
517 elseBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
518 if (elseBB.terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
519 b.buildBr(mergeBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
520 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
521
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
522 b.positionAtEnd(mergeBB);
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.While:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
525 auto wStmt = cast(WhileStmt)stmt;
56
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy...
Anders Johnsen <skabet@gmail.com>
parents: 55
diff changeset
526 auto func_name = stmt.env.parentFunction().identifier.get;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
527 Function func = m.getNamedFunction(func_name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
528
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
529 auto condBB = func.appendBasicBlock("cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
530 auto bodyBB = func.appendBasicBlock("body");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
531 auto doneBB = func.appendBasicBlock("done");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
532
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
533 b.buildBr(condBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
534 b.positionAtEnd(condBB);
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
535 Value cond = genExpression(wStmt.cond).value;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
536 if (cond.type !is Type.Int1)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
537 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
538 Value False = ConstantInt.GetS(cond.type, 0);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
539 cond = b.buildICmp(IntPredicate.NE, cond, False, ".cond");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
540 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
541 b.buildCondBr(cond, bodyBB, doneBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
542
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
543 b.positionAtEnd(bodyBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
544 genStmt(wStmt.whileBody);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
545 if (b.getInsertBlock().terminated() is false)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
546 b.buildBr(condBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
547
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
548 b.positionAtEnd(doneBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
549 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
550 case StmtType.Switch:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
551 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
552 Value cond = genExpression(sw.cond).value;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
553
56
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy...
Anders Johnsen <skabet@gmail.com>
parents: 55
diff changeset
554 auto func_name = stmt.env.parentFunction().identifier.get;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
555 Function func = m.getNamedFunction(func_name);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
556
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
557 BasicBlock oldBB = b.getInsertBlock();
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
558 BasicBlock defBB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
559 BasicBlock endBB = func.appendBasicBlock("sw.end");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
560 if (sw.defaultBlock)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
561 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
562 defBB = Function.InsertBasicBlock(endBB, "sw.def");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
563 b.positionAtEnd(defBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
564 foreach (case_statement; sw.defaultBlock)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
565 genStmt(case_statement);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
566 if (!defBB.terminated())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
567 b.buildBr(endBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
568 b.positionAtEnd(oldBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
569 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
570 else
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
571 defBB = endBB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
572 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
573 foreach (c; sw.cases)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
574 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
575 BasicBlock prevBB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
576 foreach (i, val; c.values)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
577 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
578 auto BB = Function.InsertBasicBlock(defBB, "sw.bb");
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
579 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
580
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
581 if (i + 1 == c.values.length)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
582 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
583 b.positionAtEnd(BB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
584 foreach (case_statement; c.stmts)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
585 genStmt(case_statement);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
586 if (!BB.terminated())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
587 b.buildBr(c.followedByDefault? defBB : endBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
588 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
589
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
590 if (prevBB !is null && !prevBB.terminated())
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
591 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
592 b.positionAtEnd(prevBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
593 b.buildBr(BB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
594 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
595 prevBB = BB;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
596 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
597 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
598 b.positionAtEnd(endBB);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
599 break;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
600 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
601 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
602
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
603 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
604 Given the address of something, load it into an alloc.
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
605 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
606 RValue loadLValue(LValue addr, char[] name = null)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
607 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
608 Value val = addr.getAddress();
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
609 if (name is null)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
610 name = val.name.length > 0? val.name : "load";
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
611
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
612 auto res = b.buildLoad(val, name);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
613 return RValue(res);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
614 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
615
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
616 /*
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
617 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
618 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
619 */
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
620 LValue genLValue(Exp exp)
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
621 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
622 switch(exp.expType)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
623 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
624 case ExpType.Identifier:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
625 auto identifier = cast(Identifier)exp;
93
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier.
Anders Johnsen <skabet@gmail.com>
parents: 92
diff changeset
626 auto id = exp.env.find(identifier);
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
627 return LValue(table.find(id.get));
80
682e20aa224f Pointers working now - big YAY
Anders Johnsen <skabet@gmail.com>
parents: 79
diff changeset
628 case ExpType.Deref:
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
629 // LValue(*x): x
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
630 // RValue(*x): load(x)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
631 // This way *x = *x + 1 will work
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
632 // TODO: Get's an i32** rather than i32* because it's alloc'd
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
633 // so there needs to be a load?
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
634 auto DE = cast(DerefExp)exp;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
635 return genLValue(DE.exp);
83
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 82
diff changeset
636 case ExpType.Index:
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 82
diff changeset
637 auto indexExp = cast(IndexExp)exp;
85
9375bd975730 Allow indexing of pointers also
Anders Halager <halager@gmail.com>
parents: 83
diff changeset
638 auto type = indexExp.target.type;
83
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 82
diff changeset
639 auto index = genExpression(indexExp.index);
9e90694f5da0 Parse array indexing, and allow reading from arrays
Anders Halager <halager@gmail.com>
parents: 82
diff changeset
640 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
641 gep_indices[0] = ZeroIndex;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
642 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
643 Value res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
644 auto target = genLValue(indexExp.target).getAddress();
85
9375bd975730 Allow indexing of pointers also
Anders Halager <halager@gmail.com>
parents: 83
diff changeset
645 if (type.isArray())
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
646 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
647 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
648 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
649 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
650 return LValue(res);
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 54
diff changeset
651 case ExpType.MemberReference:
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 54
diff changeset
652 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
653 switch (mem.target.expType)
51
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 case ExpType.Identifier:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
656 auto identifier = cast(Identifier)mem.target;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
657 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
658 auto id = exp.env.find(identifier);
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier.
Anders Johnsen <skabet@gmail.com>
parents: 92
diff changeset
659 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
660 DType t = id.type;
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
661 auto st = t.asStruct;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
662
55
79cb0afafabe Now structs are somewhat useable to use.
Anders Johnsen <skabet@gmail.com>
parents: 54
diff changeset
663 int i = st.indexOf(child.get);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
664
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
665 Value[2] vals;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
666 vals[0] = ZeroIndex;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
667 vals[1] = ConstantInt.GetU(IntegerType.Int32, i);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
668
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
669 Value val = b.buildGEP(v, vals, id.get~"."~child.get);
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
670 return LValue(val);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
671
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 70
diff changeset
672 case ExpType.MemberReference:
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
673 auto addr = genLValue(mem.target).getAddress();
72
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 70
diff changeset
674 auto child = mem.child;
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 70
diff changeset
675 auto symChild = child.env.find(child);
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 70
diff changeset
676 DType t = mem.target.type;
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 70
diff changeset
677 auto st = t.asStruct;
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 70
diff changeset
678
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 70
diff changeset
679 int i = st.indexOf(child.get);
628cb46ab13b First update on the way to Arrays! :)
Anders Johnsen <skabet@gmail.com>
parents: 70
diff changeset
680
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
681 Value[2] vals;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
682 vals[0] = ZeroIndex;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
683 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
684
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
685 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
686 return LValue(val);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
687 }
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
688 break;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
689 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
690 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
691 return LValue(null);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
692 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
693
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
694 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
695 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
696 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
697 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
698 {
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
699 Value to = dst.getAddress();
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
700 Value from = src.value;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
701
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
702 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
703 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
704
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
705 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
706 genMemcpy(to, from, t);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
707 else
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
708 b.buildStore(from, to);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
709 }
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
710
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
711 /**
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
712 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
713 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
714 **/
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
715 void genMemcpy(Value dst, Value src, DType t)
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
716 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
717 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
718 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
719 Value[4] args;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
720 args[0] = to;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
721 args[1] = from;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
722 args[2] = ConstantInt.GetS(Type.Int32, t.byteSize());
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
723 args[3] = ConstantInt.GetS(Type.Int32, 32);
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
724 b.buildCall(llvm_memcpy, args[], null);
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
725 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
726
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
727 Error error(uint line, char[] msg)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
728 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
729 return new Error(msg);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
730 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
731
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
732 /**
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
733 Get the LLVM Type corresponding to a DType.
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
734
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
735 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
736 well when the hashes are so uniform.
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
737
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
738 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
739 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
740 */
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
741 Type llvm(DType t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
742 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
743 if (auto llvm_t = t in type_map)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
744 return *llvm_t;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
745 return llvmCreateNew(t);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
746 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
747
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
748 // 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
749 // result
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
750 Type llvmCreateNew(DType t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
751 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
752 if (auto i = cast(DInteger)t)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
753 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
754 Type res = IntegerType.Get(i.byteSize() * 8);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
755 type_map[t] = res;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
756 return res;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
757 }
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
758 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
759 {
58
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 57
diff changeset
760 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
761 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
762 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
763
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
764 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
765 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
766
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
767 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
768 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
769
58
fc62c5296a1c Add types to our Exp
Anders Halager <halager@gmail.com>
parents: 57
diff changeset
770 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
771 type_map[t] = res;
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
772 m.addTypeName(s.name, res);
53
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals
Anders Johnsen <skabet@gmail.com>
parents: 52
diff changeset
773 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
774 }
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
775 else if (auto f = t.asFunction)
59
1d6f4ad38a91 Make most of the tests pass again
Anders Halager <halager@gmail.com>
parents: 58
diff changeset
776 {
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
777 // 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
778 // 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
779 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
780 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
781
59
1d6f4ad38a91 Make most of the tests pass again
Anders Halager <halager@gmail.com>
parents: 58
diff changeset
782 SmallArray!(Type, 8) params;
1d6f4ad38a91 Make most of the tests pass again
Anders Halager <halager@gmail.com>
parents: 58
diff changeset
783 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
784 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
785 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
786 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
787 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
788 else
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
789 params ~= llvm(param);
59
1d6f4ad38a91 Make most of the tests pass again
Anders Halager <halager@gmail.com>
parents: 58
diff changeset
790
1d6f4ad38a91 Make most of the tests pass again
Anders Halager <halager@gmail.com>
parents: 58
diff changeset
791 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
792 type_map[t] = res;
101
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
793 auto id = new Identifier(f.name);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
794 id.setType(f);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
795
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
796 auto f_t = m.getNamedFunction(id.getMangled);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
797 if(f_t is null)
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
798 {
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
799 auto llfunc = m.addFunction(res, id.getMangled);
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
800
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
801 foreach (i, param; f.params)
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
802 if (param.isStruct)
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
803 llfunc.addParamAttr(i, ParamAttr.ByVal);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
804
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
805 if (f.firstParamIsReturnValue)
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
806 {
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
807 llfunc.removeParamAttr(0, ParamAttr.ByVal);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
808 llfunc.addParamAttr(0, ParamAttr.StructRet);
fea8d61a2451 First step(the other first was a bad one) toward imports. You can now compile two files that use eachother - given that they both are in the command line. Right now it's only root sturcts and methods you can use(i guess...?)
Anders Johnsen <skabet@gmail.com>
parents: 98
diff changeset
809 }
64
91f10c34cd7b Fixed some bugs, removed the function gathering pass in codegen and types are
Anders Halager <halager@gmail.com>
parents: 63
diff changeset
810 }
59
1d6f4ad38a91 Make most of the tests pass again
Anders Halager <halager@gmail.com>
parents: 58
diff changeset
811 return res;
1d6f4ad38a91 Make most of the tests pass again
Anders Halager <halager@gmail.com>
parents: 58
diff changeset
812 }
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
813 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
814 {
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x;
Anders Johnsen <skabet@gmail.com>
parents: 74
diff changeset
815 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
816 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
817 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
818 }
81
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
819 else if (auto f = t.asArray)
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
820 {
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
821 Type res = ArrayType.Get(llvm(f.arrayOf), f.size);
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
822 type_map[t] = res;
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
823 return res;
110c7e1c4ca2 Now you can declare array
Anders Johnsen <skabet@gmail.com>
parents: 80
diff changeset
824 }
59
1d6f4ad38a91 Make most of the tests pass again
Anders Halager <halager@gmail.com>
parents: 58
diff changeset
825 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
826 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
827
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
828 // 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
829 void createBasicTypes()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
830 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
831 type_map[DType.Void] = Type.Void;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
832
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
833 type_map[DType.Bool] = Type.Int1;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
834 type_map[DType.Byte] = Type.Int8;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
835 type_map[DType.UByte] = Type.Int8;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
836 type_map[DType.Short] = Type.Int16;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
837 type_map[DType.UShort] = Type.Int16;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
838 type_map[DType.Int] = Type.Int32;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
839 type_map[DType.UInt] = Type.Int32;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
840 type_map[DType.Long] = Type.Int64;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
841 type_map[DType.ULong] = Type.Int64;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
842 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
843
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
844 private:
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
845
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
846 // llvm stuff
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
847 DModule mod;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
848 .llvm.llvm.Module m;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
849 Builder b;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
850 Function llvm_memcpy;
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
851 ConstantInt ZeroIndex;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
852 Type BytePtr;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
853 Type[DType] type_map;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
854
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
855 FuncDecl[char[]] functions;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
856
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
857 SimpleSymbolTable table;
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
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
860 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
861 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
862 alias BinaryExp.Operator O;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
863 Operator res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
864 switch (op) {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
865 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
866 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
867 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
868 case O.Div: res = Operator.Div; break;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
869
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
870 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
871 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
872 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
873 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
874 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
875 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
876 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
877 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
878 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
879
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
880 private struct LLVMPred
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
881 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
882 bool isValid = false;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
883 bool isReal;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
884 union {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
885 IntPredicate intPred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
886 RealPredicate realPred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
887 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
888
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
889 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
890 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
891 LLVMPred res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
892 res.isValid = true;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
893 res.isReal = false;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
894 res.intPred = p;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
895 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
896 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
897 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
898 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
899 LLVMPred res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
900 res.isValid = true;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
901 res.isReal = true;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
902 res.realPred = p;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
903 return res;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
904 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
905 }
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
906 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
907 {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
908 alias BuiltinOperation O;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
909 LLVMPred pred;
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
910 switch (op) {
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
911 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
912 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
913
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
914 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
915 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
916 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
917
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
918 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
919 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
920 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
921
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
922 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
923 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
924 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
925
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
926 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
927 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
928 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
929 };
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
930 return pred;
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
931 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
932
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
933 private class VisitFuncDecls : Visitor!(void)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
934 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
935 void delegate(FuncDecl) dg;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
936 this(void delegate(FuncDecl funcDecl) dg)
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 this.dg = dg;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
939 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
940
107
189c049cbfcc Cleanup of codegen, better support for operators a few bugfixes
Anders Halager <halager@gmail.com>
parents: 101
diff changeset
941 override void visitModule(DModule m)
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
942 {
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
943 foreach (decl; m.decls)
51
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
944 if (auto f = cast(FuncDecl)decl)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
945 dg(f);
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
946 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
947 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
948
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
949 private class SimpleSymbolTable
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 Value[char[]][] namedValues;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
952
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
953 void enterScope()
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 namedValues ~= cast(Value[char[]])["__dollar":null];
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
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
958 void leaveScope()
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
959 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
960 namedValues.length = namedValues.length - 1;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
961 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
962
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
963 Value put(Value val, char[] key)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
964 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
965 namedValues[$ - 1][key] = val;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
966 return val;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
967 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
968
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
969 Value find(char[] key)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
970 {
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
971 foreach_reverse (map; namedValues)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
972 if(auto val_ptr = key in map)
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
973 return *val_ptr;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
974 return null;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
975 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
976
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
977 alias find opIndex;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
978 alias put opIndexAssign;
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
979 }
c96cdcbdb9d6 Rearranged some stuff, and renamed LLVMGen -> CodeGen
Anders Halager <halager@gmail.com>
parents:
diff changeset
980