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