| blob | 9caae435e29e149c8017d1d51b106afe849e8ae8 |
4 <html>
5 <head>
11 </head>
13 <body>
17 <ul>
20 <ol>
27 </ol>
28 </li>
30 Support</li>
31 </ul>
34 <p>
37 </p>
38 </div>
40 <!-- *********************************************************************** -->
42 <!-- *********************************************************************** -->
49 LLVM IR. This will teach you a little bit about how LLVM does things, as well
50 as demonstrate how easy it is to use. It's much more work to build a lexer and
51 parser than it is to generate LLVM IR code. :)
52 </p>
57 </div>
59 <!-- *********************************************************************** -->
61 <!-- *********************************************************************** -->
65 <p>
66 In order to generate LLVM IR, we want some simple setup to get started. First
67 we define virtual code generation (codegen) methods in each AST class:</p>
70 <pre>
71 let rec codegen_expr = function
72 | Ast.Number n -> ...
73 | Ast.Variable name -> ...
74 </pre>
75 </div>
78 along with all the things it depends on, and they all return an LLVM Value
82 of SSA values is that their value is computed as the related instruction
83 executes, and it does not get a new value until (and if) the instruction
84 re-executes. In other words, there is no way to "change" an SSA value. For
85 more information, please read up on <a
89 <p>The
90 second thing we want is an "Error" exception like we used for the parser, which
91 will be used to report errors found during code generation (for example, use of
92 an undeclared parameter):</p>
95 <pre>
96 exception Error of string
98 let the_module = create_module "my cool jit"
99 let builder = builder ()
100 let named_values:(string, llvalue) Hashtbl.t = Hashtbl.create 10
101 </pre>
102 </div>
104 <p>The static variables will be used during code generation.
106 functions and global variables in a chunk of code. In many ways, it is the
107 top-level structure that the LLVM IR uses to contain code.</p>
110 generate LLVM instructions. Instances of the <a
112 class keep track of the current place to insert instructions and has methods to
113 create new instructions.</p>
116 in the current scope and what their LLVM representation is. (In other words, it
117 is a symbol table for the code). In this form of Kaleidoscope, the only things
118 that can be referenced are function parameters. As such, function parameters
119 will be in this map when generating code for their function body.</p>
121 <p>
122 With these basics in place, we can start talking about how to generate code for
125 that this has already been done, and we'll just use it to emit code.</p>
127 </div>
129 <!-- *********************************************************************** -->
131 <!-- *********************************************************************** -->
135 <p>Generating LLVM code for expression nodes is very straightforward: less
136 than 30 lines of commented code for all four of our expression nodes. First
137 we'll do numeric literals:</p>
140 <pre>
141 | Ast.Number n -> const_float double_type n
142 </pre>
143 </div>
145 <p>In the LLVM IR, numeric constants are represented with the
150 that constants are all uniqued together and shared. For this reason, the API
154 <pre>
155 | Ast.Variable name ->
156 (try Hashtbl.find named_values name with
158 </pre>
159 </div>
161 <p>References to variables are also quite simple using LLVM. In the simple
162 version of Kaleidoscope, we assume that the variable has already been emited
163 somewhere and its value is available. In practice, the only values that can be
165 simply checks to see that the specified name is in the map (if not, an unknown
166 variable is being referenced) and returns the value for it. In future chapters,
172 <pre>
173 | Ast.Binary (op, lhs, rhs) ->
174 let lhs_val = codegen_expr lhs in
175 let rhs_val = codegen_expr rhs in
176 begin
177 match op with
183 let i = build_fcmp Fcmp.Ult lhs_val rhs_val "cmptmp" builder in
184 build_uitofp i double_type "booltmp" builder
186 end
187 </pre>
188 </div>
190 <p>Binary operators start to get more interesting. The basic idea here is that
191 we recursively emit code for the left-hand side of the expression, then the
192 right-hand side, then we compute the result of the binary expression. In this
193 code, we do a simple switch on the opcode to create the right LLVM instruction.
194 </p>
196 <p>In the example above, the LLVM builder class is starting to show its value.
197 IRBuilder knows where to insert the newly created instruction, all you have to
200 provide a name for the generated instruction.</p>
202 <p>One nice thing about LLVM is that the name is just a hint. For instance, if
203 the code above emits multiple "addtmp" variables, LLVM will automatically
204 provide each one with an increasing, unique numeric suffix. Local value names
205 for instructions are purely optional, but it makes it much easier to read the
206 IR dumps.</p>
209 strict rules: for example, the Left and Right operators of
211 type, and the result type of the add must match the operand types. Because
212 all values in Kaleidoscope are doubles, this makes for very simple code for add,
213 sub and mul.</p>
217 (a one bit integer). The problem with this is that Kaleidoscope wants the value to be a 0.0 or 1.0 value. In order to get these semantics, we combine the fcmp instruction with
219 converts its input integer into a floating point value by treating the input
220 as an unsigned value. In contrast, if we used the <a
225 <pre>
226 | Ast.Call (callee, args) ->
227 (* Look up the name in the module table. *)
228 let callee =
229 match lookup_function callee the_module with
230 | Some callee -> callee
232 in
233 let params = params callee in
235 (* If argument mismatch error. *)
236 if Array.length params == Array.length args then () else
237 raise (Error "incorrect # arguments passed");
238 let args = Array.map codegen_expr args in
239 build_call callee args "calltmp" builder
240 </pre>
241 </div>
243 <p>Code generation for function calls is quite straightforward with LLVM. The
244 code above initially does a function name lookup in the LLVM Module's symbol
245 table. Recall that the LLVM Module is the container that holds all of the
246 functions we are JIT'ing. By giving each function the same name as what the
247 user specifies, we can use the LLVM symbol table to resolve function names for
248 us.</p>
250 <p>Once we have the function to call, we recursively codegen each argument that
252 instruction</a>. Note that LLVM uses the native C calling conventions by
253 default, allowing these calls to also call into standard library functions like
256 <p>This wraps up our handling of the four basic expressions that we have so far
257 in Kaleidoscope. Feel free to go in and add some more. For example, by
259 several other interesting instructions that are really easy to plug into our
260 basic framework.</p>
262 </div>
264 <!-- *********************************************************************** -->
266 <!-- *********************************************************************** -->
270 <p>Code generation for prototypes and functions must handle a number of
271 details, which make their code less beautiful than expression code
272 generation, but allows us to illustrate some important points. First, lets
273 talk about code generation for prototypes: they are used both for function
274 bodies and external function declarations. The code starts with:</p>
277 <pre>
278 let codegen_proto = function
279 | Ast.Prototype (name, args) ->
280 (* Make the function type: double(double,double) etc. *)
281 let doubles = Array.make (Array.length args) double_type in
282 let ft = function_type double_type doubles in
283 let f =
284 match lookup_function name the_module with
285 </pre>
286 </div>
288 <p>This code packs a lot of power into a few lines. Note first that this
291 really talks about the external interface for a function (not the value computed
292 by an expression), it makes sense for it to return the LLVM Function it
293 corresponds to when codegen'd.</p>
296 that should be used for a given Prototype. Since all function arguments in
297 Kaleidoscope are of type double, the first line creates a vector of "N" LLVM
299 function type that takes "N" doubles as arguments, returns one double as a
300 result, and that is not vararg (that uses the function
304 <p>The final line above checks if the function has already been defined in
308 <pre>
309 | None -> declare_function name ft the_module
310 </pre>
311 </div>
313 <p>This indicates the type and name to use, as well as which module to insert
314 into. By default we assume a function has
316 linkage</a>" means that the function may be defined outside the current module
317 and/or that it is callable by functions outside the module. The "<tt>name</tt>"
318 passed in is the name the user specified: this name is registered in
319 "<tt>Codegen.the_module</tt>"s symbol table, which is used by the function call
320 code above.</p>
322 <p>In Kaleidoscope, I choose to allow redefinitions of functions in two cases:
323 first, we want to allow 'extern'ing a function more than once, as long as the
324 prototypes for the externs match (since all arguments have the same type, we
325 just have to check that the number of arguments match). Second, we want to
326 allow 'extern'ing a function and then definining a body for it. This is useful
327 when defining mutually recursive functions.</p>
330 <pre>
331 (* If 'f' conflicted, there was already something named 'name'. If it
332 * has a body, don't allow redefinition or reextern. *)
333 | Some f ->
334 (* If 'f' already has a body, reject this. *)
335 if Array.length (basic_blocks f) == 0 then () else
336 raise (Error "redefinition of function");
338 (* If 'f' took a different number of arguments, reject. *)
339 if Array.length (params f) == Array.length args then () else
340 raise (Error "redefinition of function with different # args");
341 f
342 in
343 </pre>
344 </div>
346 <p>In order to verify the logic above, we first check to see if the pre-existing
347 function is "empty". In this case, empty means that it has no basic blocks in
348 it, which means it has no body. If it has no body, it is a forward
349 declaration. Since we don't allow anything after a full definition of the
350 function, the code rejects this case. If the previous reference to a function
351 was an 'extern', we simply verify that the number of arguments for that
352 definition and this one match up. If not, we emit an error.</p>
355 <pre>
356 (* Set names for all arguments. *)
357 Array.iteri (fun i a ->
358 let n = args.(i) in
359 set_value_name n a;
360 Hashtbl.add named_values n a;
361 ) (params f);
362 f
363 </pre>
364 </div>
366 <p>The last bit of code for prototypes loops over all of the arguments in the
367 function, setting the name of the LLVM Argument objects to match, and registering
370 object to the caller. Note that we don't check for conflicting
371 argument names here (e.g. "extern foo(a b a)"). Doing so would be very
372 straight-forward with the mechanics we have already used above.</p>
375 <pre>
376 let codegen_func = function
377 | Ast.Function (proto, body) ->
378 Hashtbl.clear named_values;
379 let the_function = codegen_proto proto in
380 </pre>
381 </div>
383 <p>Code generation for function definitions starts out simply enough: we just
384 codegen the prototype (Proto) and verify that it is ok. We then clear out the
386 from the last function we compiled. Code generation of the prototype ensures
387 that there is an LLVM Function object that is ready to go for us.</p>
390 <pre>
391 (* Create a new basic block to start insertion into. *)
392 let bb = append_block "entry" the_function in
393 position_at_end bb builder;
395 try
396 let ret_val = codegen_expr body in
397 </pre>
398 </div>
401 first line creates a new
404 tells the builder that new instructions should be inserted into the end of the
405 new basic block. Basic blocks in LLVM are an important part of functions that
406 define the <a
408 Since we don't have any control flow, our functions will only contain one
413 <pre>
414 let ret_val = codegen_expr body in
416 (* Finish off the function. *)
417 let _ = build_ret ret_val builder in
419 (* Validate the generated code, checking for consistency. *)
420 Llvm_analysis.assert_valid_function the_function;
422 the_function
423 </pre>
424 </div>
427 method for the root expression of the function. If no error happens, this emits
428 code to compute the expression into the entry block and returns the value that
429 was computed. Assuming no error, we then create an LLVM <a
431 Once the function is built, we call
433 function does a variety of consistency checks on the generated code, to
434 determine if our compiler is doing everything right. Using this is important:
435 it can catch a lot of bugs. Once the function is finished and validated, we
436 return it.</p>
439 <pre>
440 with e ->
441 delete_function the_function;
442 raise e
443 </pre>
444 </div>
446 <p>The only piece left here is handling of the error case. For simplicity, we
447 handle this by merely deleting the function we produced with the
449 function that they incorrectly typed in before: if we didn't delete it, it
450 would live in the symbol table, with a body, preventing future redefinition.</p>
453 can return a previously defined forward declaration, our code can actually delete
454 a forward declaration. There are a number of ways to fix this bug, see what you
455 can come up with! Here is a testcase:</p>
458 <pre>
459 extern foo(a b); # ok, defines foo.
460 def foo(a b) c; # error, 'c' is invalid.
462 </pre>
463 </div>
465 </div>
467 <!-- *********************************************************************** -->
469 Closing Thoughts</a></div>
470 <!-- *********************************************************************** -->
474 <p>
475 For now, code generation to LLVM doesn't really get us much, except that we can
476 look at the pretty IR calls. The sample code inserts calls to Codegen into the
477 "<tt>Toplevel.main_loop</tt>", and then dumps out the LLVM IR. This gives a
478 nice way to look at the LLVM IR for simple functions. For example:
479 </p>
482 <pre>
484 Read top-level expression:
485 define double @""() {
486 entry:
488 ret double %addtmp
489 }
490 </pre>
491 </div>
493 <p>Note how the parser turns the top-level expression into anonymous functions
495 support</a> in the next chapter. Also note that the code is very literally
496 transcribed, no optimizations are being performed. We will
498 in the next chapter.</p>
501 <pre>
503 Read function definition:
504 define double @foo(double %a, double %b) {
505 entry:
506 %multmp = mul double %a, %a
507 %multmp1 = mul double 2.000000e+00, %a
508 %multmp2 = mul double %multmp1, %b
509 %addtmp = add double %multmp, %multmp2
510 %multmp3 = mul double %b, %b
511 %addtmp4 = add double %addtmp, %multmp3
512 ret double %addtmp4
513 }
514 </pre>
515 </div>
517 <p>This shows some simple arithmetic. Notice the striking similarity to the
518 LLVM builder calls that we use to create the instructions.</p>
521 <pre>
523 Read function definition:
524 define double @bar(double %a) {
525 entry:
526 %calltmp = call double @foo( double %a, double 4.000000e+00 )
527 %calltmp1 = call double @bar( double 3.133700e+04 )
528 %addtmp = add double %calltmp, %calltmp1
529 ret double %addtmp
530 }
531 </pre>
532 </div>
534 <p>This shows some function calls. Note that this function will take a long
535 time to execute if you call it. In the future we'll add conditional control
536 flow to actually make recursion useful :).</p>
539 <pre>
541 Read extern:
542 declare double @cos(double)
545 Read top-level expression:
546 define double @""() {
547 entry:
548 %calltmp = call double @cos( double 1.234000e+00 )
549 ret double %calltmp
550 }
551 </pre>
552 </div>
558 <pre>
560 ; ModuleID = 'my cool jit'
562 define double @""() {
563 entry:
565 ret double %addtmp
566 }
568 define double @foo(double %a, double %b) {
569 entry:
570 %multmp = mul double %a, %a
571 %multmp1 = mul double 2.000000e+00, %a
572 %multmp2 = mul double %multmp1, %b
573 %addtmp = add double %multmp, %multmp2
574 %multmp3 = mul double %b, %b
575 %addtmp4 = add double %addtmp, %multmp3
576 ret double %addtmp4
577 }
579 define double @bar(double %a) {
580 entry:
581 %calltmp = call double @foo( double %a, double 4.000000e+00 )
582 %calltmp1 = call double @bar( double 3.133700e+04 )
583 %addtmp = add double %calltmp, %calltmp1
584 ret double %addtmp
585 }
587 declare double @cos(double)
589 define double @""() {
590 entry:
591 %calltmp = call double @cos( double 1.234000e+00 )
592 ret double %calltmp
593 }
594 </pre>
595 </div>
597 <p>When you quit the current demo, it dumps out the IR for the entire module
598 generated. Here you can see the big picture with all the functions referencing
599 each other.</p>
601 <p>This wraps up the third chapter of the Kaleidoscope tutorial. Up next, we'll
605 </div>
608 <!-- *********************************************************************** -->
610 <!-- *********************************************************************** -->
614 <p>
615 Here is the complete code listing for our running example, enhanced with the
616 LLVM code generator. Because this uses the LLVM libraries, we need to link
617 them in. To do this, we use the <a
619 our makefile/command line about which options to use:</p>
622 <pre>
623 # Compile
624 ocamlbuild toy.byte
625 # Run
626 ./toy.byte
627 </pre>
628 </div>
632 <dl>
635 <pre>
638 </pre>
639 </dd>
643 <pre>
644 open Ocamlbuild_plugin;;
646 ocaml_lib ~extern:true "llvm";;
647 ocaml_lib ~extern:true "llvm_analysis";;
650 </pre>
651 </dd>
655 <pre>
656 (*===----------------------------------------------------------------------===
657 * Lexer Tokens
658 *===----------------------------------------------------------------------===*)
660 (* The lexer returns these 'Kwd' if it is an unknown character, otherwise one of
661 * these others for known things. *)
662 type token =
663 (* commands *)
664 | Def | Extern
666 (* primary *)
667 | Ident of string | Number of float
669 (* unknown *)
670 | Kwd of char
671 </pre>
672 </dd>
676 <pre>
677 (*===----------------------------------------------------------------------===
678 * Lexer
679 *===----------------------------------------------------------------------===*)
681 let rec lex = parser
682 (* Skip any whitespace. *)
685 (* identifier: [a-zA-Z][a-zA-Z0-9] *)
687 let buffer = Buffer.create 1 in
688 Buffer.add_char buffer c;
689 lex_ident buffer stream
693 let buffer = Buffer.create 1 in
694 Buffer.add_char buffer c;
695 lex_number buffer stream
697 (* Comment until end of line. *)
699 lex_comment stream
701 (* Otherwise, just return the character as its ascii value. *)
705 (* end of stream. *)
708 and lex_number buffer = parser
710 Buffer.add_char buffer c;
711 lex_number buffer stream
715 and lex_ident buffer = parser
717 Buffer.add_char buffer c;
718 lex_ident buffer stream
720 match Buffer.contents buffer with
725 and lex_comment = parser
729 </pre>
730 </dd>
734 <pre>
735 (*===----------------------------------------------------------------------===
736 * Abstract Syntax Tree (aka Parse Tree)
737 *===----------------------------------------------------------------------===*)
739 (* expr - Base type for all expression nodes. *)
740 type expr =
741 (* variant for numeric literals like "1.0". *)
742 | Number of float
744 (* variant for referencing a variable, like "a". *)
745 | Variable of string
747 (* variant for a binary operator. *)
748 | Binary of char * expr * expr
750 (* variant for function calls. *)
751 | Call of string * expr array
753 (* proto - This type represents the "prototype" for a function, which captures
754 * its name, and its argument names (thus implicitly the number of arguments the
755 * function takes). *)
756 type proto = Prototype of string * string array
758 (* func - This type represents a function definition itself. *)
759 type func = Function of proto * expr
760 </pre>
761 </dd>
765 <pre>
766 (*===---------------------------------------------------------------------===
767 * Parser
768 *===---------------------------------------------------------------------===*)
770 (* binop_precedence - This holds the precedence for each binary operator that is
771 * defined *)
772 let binop_precedence:(char, int) Hashtbl.t = Hashtbl.create 10
774 (* precedence - Get the precedence of the pending binary operator token. *)
777 (* primary
778 * ::= identifier
779 * ::= numberexpr
780 * ::= parenexpr *)
781 let rec parse_primary = parser
782 (* numberexpr ::= number *)
785 (* parenexpr ::= '(' expression ')' *)
788 (* identifierexpr
789 * ::= identifier
790 * ::= identifier '(' argumentexpr ')' *)
792 let rec parse_args accumulator = parser
794 begin parser
797 end stream
799 in
800 let rec parse_ident id = parser
801 (* Call. *)
802 | [< 'Token.Kwd '(';
803 args=parse_args [];
805 Ast.Call (id, Array.of_list (List.rev args))
807 (* Simple variable ref. *)
809 in
810 parse_ident id stream
814 (* binoprhs
815 * ::= ('+' primary)* *)
816 and parse_bin_rhs expr_prec lhs stream =
817 match Stream.peek stream with
818 (* If this is a binop, find its precedence. *)
819 | Some (Token.Kwd c) when Hashtbl.mem binop_precedence c ->
820 let token_prec = precedence c in
822 (* If this is a binop that binds at least as tightly as the current binop,
823 * consume it, otherwise we are done. *)
824 if token_prec < expr_prec then lhs else begin
825 (* Eat the binop. *)
826 Stream.junk stream;
828 (* Parse the primary expression after the binary operator. *)
829 let rhs = parse_primary stream in
831 (* Okay, we know this is a binop. *)
832 let rhs =
833 match Stream.peek stream with
834 | Some (Token.Kwd c2) ->
835 (* If BinOp binds less tightly with rhs than the operator after
836 * rhs, let the pending operator take rhs as its lhs. *)
837 let next_prec = precedence c2 in
838 if token_prec < next_prec
839 then parse_bin_rhs (token_prec + 1) rhs stream
840 else rhs
841 | _ -> rhs
842 in
844 (* Merge lhs/rhs. *)
845 let lhs = Ast.Binary (c, lhs, rhs) in
846 parse_bin_rhs expr_prec lhs stream
847 end
848 | _ -> lhs
850 (* expression
851 * ::= primary binoprhs *)
852 and parse_expr = parser
855 (* prototype
856 * ::= id '(' id* ')' *)
857 let parse_prototype =
858 let rec parse_args accumulator = parser
861 in
863 parser
864 | [< 'Token.Ident id;
865 'Token.Kwd '(' ?? "expected '(' in prototype";
866 args=parse_args [];
868 (* success. *)
869 Ast.Prototype (id, Array.of_list (List.rev args))
872 raise (Stream.Error "expected function name in prototype")
874 (* definition ::= 'def' prototype expression *)
875 let parse_definition = parser
877 Ast.Function (p, e)
879 (* toplevelexpr ::= expression *)
880 let parse_toplevel = parser
882 (* Make an anonymous proto. *)
883 Ast.Function (Ast.Prototype ("", [||]), e)
885 (* external ::= 'extern' prototype *)
886 let parse_extern = parser
888 </pre>
889 </dd>
893 <pre>
894 (*===----------------------------------------------------------------------===
895 * Code Generation
896 *===----------------------------------------------------------------------===*)
898 open Llvm
900 exception Error of string
902 let the_module = create_module "my cool jit"
903 let builder = builder ()
904 let named_values:(string, llvalue) Hashtbl.t = Hashtbl.create 10
906 let rec codegen_expr = function
907 | Ast.Number n -> const_float double_type n
908 | Ast.Variable name ->
909 (try Hashtbl.find named_values name with
911 | Ast.Binary (op, lhs, rhs) ->
912 let lhs_val = codegen_expr lhs in
913 let rhs_val = codegen_expr rhs in
914 begin
915 match op with
921 let i = build_fcmp Fcmp.Ult lhs_val rhs_val "cmptmp" builder in
922 build_uitofp i double_type "booltmp" builder
924 end
925 | Ast.Call (callee, args) ->
926 (* Look up the name in the module table. *)
927 let callee =
928 match lookup_function callee the_module with
929 | Some callee -> callee
931 in
932 let params = params callee in
934 (* If argument mismatch error. *)
935 if Array.length params == Array.length args then () else
936 raise (Error "incorrect # arguments passed");
937 let args = Array.map codegen_expr args in
938 build_call callee args "calltmp" builder
940 let codegen_proto = function
941 | Ast.Prototype (name, args) ->
942 (* Make the function type: double(double,double) etc. *)
943 let doubles = Array.make (Array.length args) double_type in
944 let ft = function_type double_type doubles in
945 let f =
946 match lookup_function name the_module with
947 | None -> declare_function name ft the_module
949 (* If 'f' conflicted, there was already something named 'name'. If it
950 * has a body, don't allow redefinition or reextern. *)
951 | Some f ->
952 (* If 'f' already has a body, reject this. *)
953 if block_begin f <> At_end f then
954 raise (Error "redefinition of function");
956 (* If 'f' took a different number of arguments, reject. *)
957 if element_type (type_of f) <> ft then
958 raise (Error "redefinition of function with different # args");
959 f
960 in
962 (* Set names for all arguments. *)
963 Array.iteri (fun i a ->
964 let n = args.(i) in
965 set_value_name n a;
966 Hashtbl.add named_values n a;
967 ) (params f);
968 f
970 let codegen_func = function
971 | Ast.Function (proto, body) ->
972 Hashtbl.clear named_values;
973 let the_function = codegen_proto proto in
975 (* Create a new basic block to start insertion into. *)
976 let bb = append_block "entry" the_function in
977 position_at_end bb builder;
979 try
980 let ret_val = codegen_expr body in
982 (* Finish off the function. *)
983 let _ = build_ret ret_val builder in
985 (* Validate the generated code, checking for consistency. *)
986 Llvm_analysis.assert_valid_function the_function;
988 the_function
989 with e ->
990 delete_function the_function;
991 raise e
992 </pre>
993 </dd>
997 <pre>
998 (*===----------------------------------------------------------------------===
999 * Top-Level parsing and JIT Driver
1000 *===----------------------------------------------------------------------===*)
1002 open Llvm
1004 (* top ::= definition | external | expression | ';' *)
1005 let rec main_loop stream =
1006 match Stream.peek stream with
1007 | None -> ()
1009 (* ignore top-level semicolons. *)
1010 | Some (Token.Kwd ';') ->
1011 Stream.junk stream;
1012 main_loop stream
1014 | Some token ->
1015 begin
1016 try match token with
1017 | Token.Def ->
1018 let e = Parser.parse_definition stream in
1019 print_endline "parsed a function definition.";
1020 dump_value (Codegen.codegen_func e);
1021 | Token.Extern ->
1022 let e = Parser.parse_extern stream in
1023 print_endline "parsed an extern.";
1024 dump_value (Codegen.codegen_proto e);
1025 | _ ->
1026 (* Evaluate a top-level expression into an anonymous function. *)
1027 let e = Parser.parse_toplevel stream in
1028 print_endline "parsed a top-level expr";
1029 dump_value (Codegen.codegen_func e);
1030 with Stream.Error s | Codegen.Error s ->
1031 (* Skip token for error recovery. *)
1032 Stream.junk stream;
1033 print_endline s;
1034 end;
1035 print_string "ready> "; flush stdout;
1036 main_loop stream
1037 </pre>
1038 </dd>
1042 <pre>
1043 (*===----------------------------------------------------------------------===
1044 * Main driver code.
1045 *===----------------------------------------------------------------------===*)
1047 open Llvm
1049 let main () =
1050 (* Install standard binary operators.
1051 * 1 is the lowest precedence. *)
1053 Hashtbl.add Parser.binop_precedence '+' 20;
1054 Hashtbl.add Parser.binop_precedence '-' 20;
1055 Hashtbl.add Parser.binop_precedence '*' 40; (* highest. *)
1057 (* Prime the first token. *)
1058 print_string "ready> "; flush stdout;
1059 let stream = Lexer.lex (Stream.of_channel stdin) in
1061 (* Run the main "interpreter loop" now. *)
1062 Toplevel.main_loop stream;
1064 (* Print out all the generated code. *)
1065 dump_module Codegen.the_module
1066 ;;
1068 main ()
1069 </pre>
1070 </dd>
1071 </dl>
1074 </div>
1076 <!-- *********************************************************************** -->
1077 <hr>
1078 <address>
1088 </address>
1089 </body>
1090 </html>