| blob | 238fc53392d18124fe42a749a6f7e384a7f33cd9 |
4 <html>
5 <head>
11 </head>
13 <body>
17 <ul>
20 <ol>
26 </ol>
27 </li>
29 Flow</li>
30 </ul>
33 <p>
36 </p>
37 </div>
39 <!-- *********************************************************************** -->
41 <!-- *********************************************************************** -->
47 language and added support for generating LLVM IR. This chapter describes
48 two new techniques: adding optimizer support to your language, and adding JIT
49 compiler support. These additions will demonstrate how to get nice, efficient code
50 for the Kaleidoscope language.</p>
52 </div>
54 <!-- *********************************************************************** -->
56 Folding</a></div>
57 <!-- *********************************************************************** -->
62 folding optimisations below.<p>
64 <p>
65 Our demonstration for Chapter 3 is elegant and easy to extend. Unfortunately,
66 it does not produce wonderful code. For example, when compiling simple code,
67 we don't get obvious optimizations:</p>
70 <pre>
72 Read function definition:
73 define double @test(double %x) {
74 entry:
76 %addtmp1 = add double %addtmp, %x
77 ret double %addtmp1
78 }
79 </pre>
80 </div>
82 <p>This code is a very, very literal transcription of the AST built by parsing
83 the input. As such, this transcription lacks optimizations like constant folding
84 (we'd like to get "<tt>add x, 3.0</tt>" in the example above) as well as other
85 more important optimizations. Constant folding, in particular, is a very common
86 and very important optimization: so much so that many language implementors
87 implement constant folding support in their AST representation.</p>
89 <p>With LLVM, you don't need this support in the AST. Since all calls to build
90 LLVM IR go through the LLVM builder, it would be nice if the builder itself
91 checked to see if there was a constant folding opportunity when you call it.
92 If so, it could just do the constant fold and return the constant instead of
94 class does.
98 instructions implicitly constant folded without us having to do anything
99 about it. For example, the input above now compiles to:</p>
102 <pre>
104 Read function definition:
105 define double @test(double %x) {
106 entry:
107 %addtmp = add double 3.000000e+00, %x
108 ret double %addtmp
109 }
110 </pre>
111 </div>
113 <p>Well, that was easy :). In practice, we recommend always using
115 "syntactic overhead" for its use (you don't have to uglify your compiler with
116 constant checks everywhere) and it can dramatically reduce the amount of
117 LLVM IR that is generated in some cases (particular for languages with a macro
118 preprocessor or that use a lot of constants).</p>
121 that it does all of its analysis inline with the code as it is built. If you
122 take a slightly more complex example:</p>
125 <pre>
127 ready> Read function definition:
128 define double @test(double %x) {
129 entry:
130 %addtmp = add double 3.000000e+00, %x
131 %addtmp1 = add double %x, 3.000000e+00
132 %multmp = mul double %addtmp, %addtmp1
133 ret double %multmp
134 }
135 </pre>
136 </div>
138 <p>In this case, the LHS and RHS of the multiplication are the same value. We'd
139 really like to see this generate "<tt>tmp = x+3; result = tmp*tmp;</tt>" instead
142 <p>Unfortunately, no amount of local analysis will be able to detect and correct
143 this. This requires two transformations: reassociation of expressions (to
144 make the add's lexically identical) and Common Subexpression Elimination (CSE)
145 to delete the redundant add instruction. Fortunately, LLVM provides a broad
148 </div>
150 <!-- *********************************************************************** -->
152 Passes</a></div>
153 <!-- *********************************************************************** -->
157 <p>LLVM provides many optimization passes, which do many different sorts of
158 things and have different tradeoffs. Unlike other systems, LLVM doesn't hold
159 to the mistaken notion that one set of optimizations is right for all languages
160 and for all situations. LLVM allows a compiler implementor to make complete
161 decisions about what optimizations to use, in which order, and in what
162 situation.</p>
165 across as large of body of code as they can (often a whole file, but if run
166 at link time, this can be a substantial portion of the whole program). It also
167 supports and includes "per-function" passes which just operate on a single
168 function at a time, without looking at other functions. For more information
173 <p>For Kaleidoscope, we are currently generating functions on the fly, one at
174 a time, as the user types them in. We aren't shooting for the ultimate
175 optimization experience in this setting, but we also want to catch the easy and
176 quick stuff where possible. As such, we will choose to run a few per-function
177 optimizations as the user types the function in. If we wanted to make a "static
178 Kaleidoscope compiler", we would use exactly the code we have now, except that
179 we would defer running the optimizer until the entire file has been parsed.</p>
181 <p>In order to get per-function optimizations going, we need to set up a
183 organize the LLVM optimizations that we want to run. Once we have that, we can
184 add a set of optimizations to run. The code looks like this:</p>
187 <pre>
188 (* Create the JIT. *)
189 let the_module_provider = ModuleProvider.create Codegen.the_module in
190 let the_execution_engine = ExecutionEngine.create the_module_provider in
191 let the_fpm = PassManager.create_function the_module_provider in
193 (* Set up the optimizer pipeline. Start with registering info about how the
194 * target lays out data structures. *)
195 TargetData.add (ExecutionEngine.target_data the_execution_engine) the_fpm;
197 (* Do simple "peephole" optimizations and bit-twiddling optzn. *)
198 add_instruction_combining the_fpm;
200 (* reassociate expressions. *)
201 add_reassociation the_fpm;
203 (* Eliminate Common SubExpressions. *)
204 add_gvn the_fpm;
206 (* Simplify the control flow graph (deleting unreachable blocks, etc). *)
207 add_cfg_simplification the_fpm;
209 ignore (PassManager.initialize the_fpm);
211 (* Run the main "interpreter loop" now. *)
212 Toplevel.main_loop the_fpm the_execution_engine stream;
213 </pre>
214 </div>
219 provides certain flexibility that we're not going to take advantage of here,
220 so I won't dive into any details about it.</p>
225 series of "add" calls to add a bunch of LLVM passes. The first pass is
226 basically boilerplate, it adds a pass so that later optimizations know how the
227 data structures in the program are layed out. The
228 "<tt>the_execution_engine</tt>" variable is related to the JIT, which we will
229 get to in the next section.</p>
232 here are a pretty standard set of "cleanup" optimizations that are useful for
233 a wide variety of code. I won't delve into what they do but, believe me,
234 they are a good starting place :).</p>
237 We do this by running it after our newly created function is constructed (in
241 <pre>
242 let codegen_func the_fpm = function
243 ...
244 try
245 let ret_val = codegen_expr body in
247 (* Finish off the function. *)
248 let _ = build_ret ret_val builder in
250 (* Validate the generated code, checking for consistency. *)
251 Llvm_analysis.assert_valid_function the_function;
253 (* Optimize the function. *)
254 let _ = PassManager.run_function the_function the_fpm in
256 the_function
257 </pre>
258 </div>
261 optimizes and updates the LLVM Function* in place, improving (hopefully) its
262 body. With this in place, we can try our test above again:</p>
265 <pre>
267 ready> Read function definition:
268 define double @test(double %x) {
269 entry:
270 %addtmp = add double %x, 3.000000e+00
271 %multmp = mul double %addtmp, %addtmp
272 ret double %multmp
273 }
274 </pre>
275 </div>
277 <p>As expected, we now get our nicely optimized code, saving a floating point
278 add instruction from every execution of this function.</p>
280 <p>LLVM provides a wide variety of optimizations that can be used in certain
282 passes</a> is available, but it isn't very complete. Another good source of
285 experiment with passes from the command line, so you can see if they do
286 anything.</p>
288 <p>Now that we have reasonable code coming out of our front-end, lets talk about
289 executing it!</p>
291 </div>
293 <!-- *********************************************************************** -->
295 <!-- *********************************************************************** -->
299 <p>Code that is available in LLVM IR can have a wide variety of tools
300 applied to it. For example, you can run optimizations on it (as we did above),
301 you can dump it out in textual or binary forms, you can compile the code to an
302 assembly file (.s) for some target, or you can JIT compile it. The nice thing
303 about the LLVM IR representation is that it is the "common currency" between
304 many different parts of the compiler.
305 </p>
307 <p>In this section, we'll add JIT compiler support to our interpreter. The
308 basic idea that we want for Kaleidoscope is to have the user enter function
309 bodies as they do now, but immediately evaluate the top-level expressions they
310 type in. For example, if they type in "1 + 2;", we should evaluate and print
311 out 3. If they define a function, they should be able to call it from the
312 command line.</p>
314 <p>In order to do this, we first declare and initialize the JIT. This is done
318 <pre>
319 ...
320 let main () =
321 ...
322 <b>(* Create the JIT. *)
323 let the_module_provider = ModuleProvider.create Codegen.the_module in
324 let the_execution_engine = ExecutionEngine.create the_module_provider in</b>
325 ...
326 </pre>
327 </div>
330 compiler or the LLVM interpreter. LLVM will automatically pick a JIT compiler
331 for you if one is available for your platform, otherwise it will fall back to
332 the interpreter.</p>
335 is ready to be used. There are a variety of APIs that are useful, but the
336 simplest one is the "<tt>Llvm_executionengine.ExecutionEngine.run_function</tt>"
337 function. This method JIT compiles the specified LLVM Function and returns a
338 function pointer to the generated machine code. In our case, this means that we
339 can change the code that parses a top-level expression to look like this:</p>
342 <pre>
343 (* Evaluate a top-level expression into an anonymous function. *)
344 let e = Parser.parse_toplevel stream in
345 print_endline "parsed a top-level expr";
346 let the_function = Codegen.codegen_func the_fpm e in
347 dump_value the_function;
349 (* JIT the function, returning a function pointer. *)
350 let result = ExecutionEngine.run_function the_function [||]
351 the_execution_engine in
353 print_string "Evaluated to ";
354 print_float (GenericValue.as_float double_type result);
355 print_newline ();
356 </pre>
357 </div>
359 <p>Recall that we compile top-level expressions into a self-contained LLVM
360 function that takes no arguments and returns the computed double. Because the
361 LLVM JIT compiler matches the native platform ABI, this means that you can just
362 cast the result pointer to a function pointer of that type and call it directly.
363 This means, there is no difference between JIT compiled code and native machine
364 code that is statically linked into your application.</p>
369 <pre>
371 define double @""() {
372 entry:
373 ret double 9.000000e+00
374 }
377 </pre>
378 </div>
380 <p>Well this looks like it is basically working. The dump of the function
381 shows the "no argument function that always returns double" that we synthesize
382 for each top level expression that is typed in. This demonstrates very basic
383 functionality, but can we do more?</p>
386 <pre>
388 Read function definition:
389 define double @testfunc(double %x, double %y) {
390 entry:
391 %multmp = mul double %y, 2.000000e+00
392 %addtmp = add double %multmp, %x
393 ret double %addtmp
394 }
397 define double @""() {
398 entry:
400 ret double %calltmp
401 }
404 </pre>
405 </div>
407 <p>This illustrates that we can now call user code, but there is something a bit
408 subtle going on here. Note that we only invoke the JIT on the anonymous
412 <p>What actually happened here is that the anonymous function was JIT'd when
413 requested. When the Kaleidoscope app calls through the function pointer that is
414 returned, the anonymous function starts executing. It ends up making the call
415 to the "testfunc" function, and ends up in a stub that invokes the JIT, lazily,
416 on testfunc. Once the JIT finishes lazily compiling testfunc,
417 it returns and the code re-executes the call.</p>
419 <p>In summary, the JIT will lazily JIT code, on the fly, as it is needed. The
420 JIT provides a number of other more advanced interfaces for things like freeing
421 allocated machine code, rejit'ing functions to update them, etc. However, even
422 with this simple code, we get some surprisingly powerful capabilities - check
423 this out (I removed the dump of the anonymous functions, you should get the idea
424 by now :) :</p>
427 <pre>
429 Read extern:
430 declare double @sin(double)
433 Read extern:
434 declare double @cos(double)
440 Read function definition:
441 define double @foo(double %x) {
442 entry:
443 %calltmp = call double @sin( double %x )
444 %multmp = mul double %calltmp, %calltmp
445 %calltmp2 = call double @cos( double %x )
446 %multmp4 = mul double %calltmp2, %calltmp2
447 %addtmp = add double %multmp, %multmp4
448 ret double %addtmp
449 }
453 </pre>
454 </div>
456 <p>Whoa, how does the JIT know about sin and cos? The answer is surprisingly
457 simple: in this example, the JIT started execution of a function and got to a
458 function call. It realized that the function was not yet JIT compiled and
459 invoked the standard set of routines to resolve the function. In this case,
460 there is no body defined for the function, so the JIT ended up calling
462 "<tt>sin</tt>" is defined within the JIT's address space, it simply patches up
465 <p>The LLVM JIT provides a number of interfaces (look in the
467 get resolved. It allows you to establish explicit mappings between IR objects
468 and addresses (useful for LLVM global variables that you want to map to static
469 tables, for example), allows you to dynamically decide on the fly based on the
470 function name, and even allows you to have the JIT abort itself if any lazy
471 compilation is attempted.</p>
473 <p>One interesting application of this is that we can now extend the language
474 by writing arbitrary C code to implement operations. For example, if we add:
475 </p>
478 <pre>
479 /* putchard - putchar that takes a double and returns 0. */
480 extern "C"
481 double putchard(double X) {
482 putchar((char)X);
483 return 0;
484 }
485 </pre>
486 </div>
488 <p>Now we can produce simple output to the console by using things like:
489 "<tt>extern putchard(x); putchard(120);</tt>", which prints a lowercase 'x' on
490 the console (120 is the ASCII code for 'x'). Similar code could be used to
491 implement file I/O, console input, and many other capabilities in
492 Kaleidoscope.</p>
494 <p>This completes the JIT and optimizer chapter of the Kaleidoscope tutorial. At
495 this point, we can compile a non-Turing-complete programming language, optimize
496 and JIT compile it in a user-driven way. Next up we'll look into <a
500 </div>
502 <!-- *********************************************************************** -->
504 <!-- *********************************************************************** -->
508 <p>
509 Here is the complete code listing for our running example, enhanced with the
510 LLVM JIT and optimizer. To build this example, use:
511 </p>
514 <pre>
515 # Compile
516 ocamlbuild toy.byte
517 # Run
518 ./toy.byte
519 </pre>
520 </div>
524 <dl>
527 <pre>
532 </pre>
533 </dd>
537 <pre>
538 open Ocamlbuild_plugin;;
540 ocaml_lib ~extern:true "llvm";;
541 ocaml_lib ~extern:true "llvm_analysis";;
542 ocaml_lib ~extern:true "llvm_executionengine";;
543 ocaml_lib ~extern:true "llvm_target";;
544 ocaml_lib ~extern:true "llvm_scalar_opts";;
548 </pre>
549 </dd>
553 <pre>
554 (*===----------------------------------------------------------------------===
555 * Lexer Tokens
556 *===----------------------------------------------------------------------===*)
558 (* The lexer returns these 'Kwd' if it is an unknown character, otherwise one of
559 * these others for known things. *)
560 type token =
561 (* commands *)
562 | Def | Extern
564 (* primary *)
565 | Ident of string | Number of float
567 (* unknown *)
568 | Kwd of char
569 </pre>
570 </dd>
574 <pre>
575 (*===----------------------------------------------------------------------===
576 * Lexer
577 *===----------------------------------------------------------------------===*)
579 let rec lex = parser
580 (* Skip any whitespace. *)
583 (* identifier: [a-zA-Z][a-zA-Z0-9] *)
585 let buffer = Buffer.create 1 in
586 Buffer.add_char buffer c;
587 lex_ident buffer stream
591 let buffer = Buffer.create 1 in
592 Buffer.add_char buffer c;
593 lex_number buffer stream
595 (* Comment until end of line. *)
597 lex_comment stream
599 (* Otherwise, just return the character as its ascii value. *)
603 (* end of stream. *)
606 and lex_number buffer = parser
608 Buffer.add_char buffer c;
609 lex_number buffer stream
613 and lex_ident buffer = parser
615 Buffer.add_char buffer c;
616 lex_ident buffer stream
618 match Buffer.contents buffer with
623 and lex_comment = parser
627 </pre>
628 </dd>
632 <pre>
633 (*===----------------------------------------------------------------------===
634 * Abstract Syntax Tree (aka Parse Tree)
635 *===----------------------------------------------------------------------===*)
637 (* expr - Base type for all expression nodes. *)
638 type expr =
639 (* variant for numeric literals like "1.0". *)
640 | Number of float
642 (* variant for referencing a variable, like "a". *)
643 | Variable of string
645 (* variant for a binary operator. *)
646 | Binary of char * expr * expr
648 (* variant for function calls. *)
649 | Call of string * expr array
651 (* proto - This type represents the "prototype" for a function, which captures
652 * its name, and its argument names (thus implicitly the number of arguments the
653 * function takes). *)
654 type proto = Prototype of string * string array
656 (* func - This type represents a function definition itself. *)
657 type func = Function of proto * expr
658 </pre>
659 </dd>
663 <pre>
664 (*===---------------------------------------------------------------------===
665 * Parser
666 *===---------------------------------------------------------------------===*)
668 (* binop_precedence - This holds the precedence for each binary operator that is
669 * defined *)
670 let binop_precedence:(char, int) Hashtbl.t = Hashtbl.create 10
672 (* precedence - Get the precedence of the pending binary operator token. *)
675 (* primary
676 * ::= identifier
677 * ::= numberexpr
678 * ::= parenexpr *)
679 let rec parse_primary = parser
680 (* numberexpr ::= number *)
683 (* parenexpr ::= '(' expression ')' *)
686 (* identifierexpr
687 * ::= identifier
688 * ::= identifier '(' argumentexpr ')' *)
690 let rec parse_args accumulator = parser
692 begin parser
695 end stream
697 in
698 let rec parse_ident id = parser
699 (* Call. *)
700 | [< 'Token.Kwd '(';
701 args=parse_args [];
703 Ast.Call (id, Array.of_list (List.rev args))
705 (* Simple variable ref. *)
707 in
708 parse_ident id stream
712 (* binoprhs
713 * ::= ('+' primary)* *)
714 and parse_bin_rhs expr_prec lhs stream =
715 match Stream.peek stream with
716 (* If this is a binop, find its precedence. *)
717 | Some (Token.Kwd c) when Hashtbl.mem binop_precedence c ->
718 let token_prec = precedence c in
720 (* If this is a binop that binds at least as tightly as the current binop,
721 * consume it, otherwise we are done. *)
722 if token_prec < expr_prec then lhs else begin
723 (* Eat the binop. *)
724 Stream.junk stream;
726 (* Parse the primary expression after the binary operator. *)
727 let rhs = parse_primary stream in
729 (* Okay, we know this is a binop. *)
730 let rhs =
731 match Stream.peek stream with
732 | Some (Token.Kwd c2) ->
733 (* If BinOp binds less tightly with rhs than the operator after
734 * rhs, let the pending operator take rhs as its lhs. *)
735 let next_prec = precedence c2 in
736 if token_prec < next_prec
737 then parse_bin_rhs (token_prec + 1) rhs stream
738 else rhs
739 | _ -> rhs
740 in
742 (* Merge lhs/rhs. *)
743 let lhs = Ast.Binary (c, lhs, rhs) in
744 parse_bin_rhs expr_prec lhs stream
745 end
746 | _ -> lhs
748 (* expression
749 * ::= primary binoprhs *)
750 and parse_expr = parser
753 (* prototype
754 * ::= id '(' id* ')' *)
755 let parse_prototype =
756 let rec parse_args accumulator = parser
759 in
761 parser
762 | [< 'Token.Ident id;
763 'Token.Kwd '(' ?? "expected '(' in prototype";
764 args=parse_args [];
766 (* success. *)
767 Ast.Prototype (id, Array.of_list (List.rev args))
770 raise (Stream.Error "expected function name in prototype")
772 (* definition ::= 'def' prototype expression *)
773 let parse_definition = parser
775 Ast.Function (p, e)
777 (* toplevelexpr ::= expression *)
778 let parse_toplevel = parser
780 (* Make an anonymous proto. *)
781 Ast.Function (Ast.Prototype ("", [||]), e)
783 (* external ::= 'extern' prototype *)
784 let parse_extern = parser
786 </pre>
787 </dd>
791 <pre>
792 (*===----------------------------------------------------------------------===
793 * Code Generation
794 *===----------------------------------------------------------------------===*)
796 open Llvm
798 exception Error of string
800 let context = global_context ()
801 let the_module = create_module context "my cool jit"
802 let builder = builder context
803 let named_values:(string, llvalue) Hashtbl.t = Hashtbl.create 10
805 let rec codegen_expr = function
806 | Ast.Number n -> const_float double_type n
807 | Ast.Variable name ->
808 (try Hashtbl.find named_values name with
810 | Ast.Binary (op, lhs, rhs) ->
811 let lhs_val = codegen_expr lhs in
812 let rhs_val = codegen_expr rhs in
813 begin
814 match op with
820 let i = build_fcmp Fcmp.Ult lhs_val rhs_val "cmptmp" builder in
821 build_uitofp i double_type "booltmp" builder
823 end
824 | Ast.Call (callee, args) ->
825 (* Look up the name in the module table. *)
826 let callee =
827 match lookup_function callee the_module with
828 | Some callee -> callee
830 in
831 let params = params callee in
833 (* If argument mismatch error. *)
834 if Array.length params == Array.length args then () else
835 raise (Error "incorrect # arguments passed");
836 let args = Array.map codegen_expr args in
837 build_call callee args "calltmp" builder
839 let codegen_proto = function
840 | Ast.Prototype (name, args) ->
841 (* Make the function type: double(double,double) etc. *)
842 let doubles = Array.make (Array.length args) double_type in
843 let ft = function_type double_type doubles in
844 let f =
845 match lookup_function name the_module with
846 | None -> declare_function name ft the_module
848 (* If 'f' conflicted, there was already something named 'name'. If it
849 * has a body, don't allow redefinition or reextern. *)
850 | Some f ->
851 (* If 'f' already has a body, reject this. *)
852 if block_begin f <> At_end f then
853 raise (Error "redefinition of function");
855 (* If 'f' took a different number of arguments, reject. *)
856 if element_type (type_of f) <> ft then
857 raise (Error "redefinition of function with different # args");
858 f
859 in
861 (* Set names for all arguments. *)
862 Array.iteri (fun i a ->
863 let n = args.(i) in
864 set_value_name n a;
865 Hashtbl.add named_values n a;
866 ) (params f);
867 f
869 let codegen_func the_fpm = function
870 | Ast.Function (proto, body) ->
871 Hashtbl.clear named_values;
872 let the_function = codegen_proto proto in
874 (* Create a new basic block to start insertion into. *)
875 let bb = append_block "entry" the_function in
876 position_at_end bb builder;
878 try
879 let ret_val = codegen_expr body in
881 (* Finish off the function. *)
882 let _ = build_ret ret_val builder in
884 (* Validate the generated code, checking for consistency. *)
885 Llvm_analysis.assert_valid_function the_function;
887 (* Optimize the function. *)
888 let _ = PassManager.run_function the_function the_fpm in
890 the_function
891 with e ->
892 delete_function the_function;
893 raise e
894 </pre>
895 </dd>
899 <pre>
900 (*===----------------------------------------------------------------------===
901 * Top-Level parsing and JIT Driver
902 *===----------------------------------------------------------------------===*)
904 open Llvm
905 open Llvm_executionengine
907 (* top ::= definition | external | expression | ';' *)
908 let rec main_loop the_fpm the_execution_engine stream =
909 match Stream.peek stream with
910 | None -> ()
912 (* ignore top-level semicolons. *)
913 | Some (Token.Kwd ';') ->
914 Stream.junk stream;
915 main_loop the_fpm the_execution_engine stream
917 | Some token ->
918 begin
919 try match token with
920 | Token.Def ->
921 let e = Parser.parse_definition stream in
922 print_endline "parsed a function definition.";
923 dump_value (Codegen.codegen_func the_fpm e);
924 | Token.Extern ->
925 let e = Parser.parse_extern stream in
926 print_endline "parsed an extern.";
927 dump_value (Codegen.codegen_proto e);
928 | _ ->
929 (* Evaluate a top-level expression into an anonymous function. *)
930 let e = Parser.parse_toplevel stream in
931 print_endline "parsed a top-level expr";
932 let the_function = Codegen.codegen_func the_fpm e in
933 dump_value the_function;
935 (* JIT the function, returning a function pointer. *)
936 let result = ExecutionEngine.run_function the_function [||]
937 the_execution_engine in
939 print_string "Evaluated to ";
940 print_float (GenericValue.as_float double_type result);
941 print_newline ();
942 with Stream.Error s | Codegen.Error s ->
943 (* Skip token for error recovery. *)
944 Stream.junk stream;
945 print_endline s;
946 end;
947 print_string "ready> "; flush stdout;
948 main_loop the_fpm the_execution_engine stream
949 </pre>
950 </dd>
954 <pre>
955 (*===----------------------------------------------------------------------===
956 * Main driver code.
957 *===----------------------------------------------------------------------===*)
959 open Llvm
960 open Llvm_executionengine
961 open Llvm_target
962 open Llvm_scalar_opts
964 let main () =
965 ignore (initialize_native_target ());
967 (* Install standard binary operators.
968 * 1 is the lowest precedence. *)
970 Hashtbl.add Parser.binop_precedence '+' 20;
971 Hashtbl.add Parser.binop_precedence '-' 20;
972 Hashtbl.add Parser.binop_precedence '*' 40; (* highest. *)
974 (* Prime the first token. *)
975 print_string "ready> "; flush stdout;
976 let stream = Lexer.lex (Stream.of_channel stdin) in
978 (* Create the JIT. *)
979 let the_module_provider = ModuleProvider.create Codegen.the_module in
980 let the_execution_engine = ExecutionEngine.create the_module_provider in
981 let the_fpm = PassManager.create_function the_module_provider in
983 (* Set up the optimizer pipeline. Start with registering info about how the
984 * target lays out data structures. *)
985 TargetData.add (ExecutionEngine.target_data the_execution_engine) the_fpm;
987 (* Do simple "peephole" optimizations and bit-twiddling optzn. *)
988 add_instruction_combining the_fpm;
990 (* reassociate expressions. *)
991 add_reassociation the_fpm;
993 (* Eliminate Common SubExpressions. *)
994 add_gvn the_fpm;
996 (* Simplify the control flow graph (deleting unreachable blocks, etc). *)
997 add_cfg_simplification the_fpm;
999 ignore (PassManager.initialize the_fpm);
1001 (* Run the main "interpreter loop" now. *)
1002 Toplevel.main_loop the_fpm the_execution_engine stream;
1004 (* Print out all the generated code. *)
1005 dump_module Codegen.the_module
1006 ;;
1008 main ()
1009 </pre>
1010 </dd>
1014 <pre>
1017 /* putchard - putchar that takes a double and returns 0. */
1018 extern double putchard(double X) {
1019 putchar((char)X);
1020 return 0;
1021 }
1022 </pre>
1023 </dd>
1024 </dl>
1027 </div>
1029 <!-- *********************************************************************** -->
1030 <hr>
1031 <address>
1041 </address>
1042 </body>
1043 </html>