| ======================================== | |
| Kaleidoscope: Code generation to LLVM IR | |
| ======================================== | |
| .. contents:: | |
| :local: | |
| Chapter 3 Introduction | |
| ====================== | |
| Welcome to Chapter 3 of the "`Implementing a language with | |
| LLVM <index.html>`_" tutorial. This chapter shows you how to transform | |
| the `Abstract Syntax Tree <OCamlLangImpl2.html>`_, built in Chapter 2, | |
| into LLVM IR. This will teach you a little bit about how LLVM does | |
| things, as well as demonstrate how easy it is to use. It's much more | |
| work to build a lexer and parser than it is to generate LLVM IR code. :) | |
| **Please note**: the code in this chapter and later require LLVM 2.3 or | |
| LLVM SVN to work. LLVM 2.2 and before will not work with it. | |
| Code Generation Setup | |
| ===================== | |
| In order to generate LLVM IR, we want some simple setup to get started. | |
| First we define virtual code generation (codegen) methods in each AST | |
| class: | |
| .. code-block:: ocaml | |
| let rec codegen_expr = function | |
| | Ast.Number n -> ... | |
| | Ast.Variable name -> ... | |
| The ``Codegen.codegen_expr`` function says to emit IR for that AST node | |
| along with all the things it depends on, and they all return an LLVM | |
| Value object. "Value" is the class used to represent a "`Static Single | |
| Assignment | |
| (SSA) <http://en.wikipedia.org/wiki/Static_single_assignment_form>`_ | |
| register" or "SSA value" in LLVM. The most distinct aspect of SSA values | |
| is that their value is computed as the related instruction executes, and | |
| it does not get a new value until (and if) the instruction re-executes. | |
| In other words, there is no way to "change" an SSA value. For more | |
| information, please read up on `Static Single | |
| Assignment <http://en.wikipedia.org/wiki/Static_single_assignment_form>`_ | |
| - the concepts are really quite natural once you grok them. | |
| The second thing we want is an "Error" exception like we used for the | |
| parser, which will be used to report errors found during code generation | |
| (for example, use of an undeclared parameter): | |
| .. code-block:: ocaml | |
| exception Error of string | |
| let context = global_context () | |
| let the_module = create_module context "my cool jit" | |
| let builder = builder context | |
| let named_values:(string, llvalue) Hashtbl.t = Hashtbl.create 10 | |
| let double_type = double_type context | |
| The static variables will be used during code generation. | |
| ``Codgen.the_module`` is the LLVM construct that contains all of the | |
| functions and global variables in a chunk of code. In many ways, it is | |
| the top-level structure that the LLVM IR uses to contain code. | |
| The ``Codegen.builder`` object is a helper object that makes it easy to | |
| generate LLVM instructions. Instances of the | |
| `IRBuilder <http://llvm.org/doxygen/IRBuilder_8h-source.html>`_ | |
| class keep track of the current place to insert instructions and has | |
| methods to create new instructions. | |
| The ``Codegen.named_values`` map keeps track of which values are defined | |
| in the current scope and what their LLVM representation is. (In other | |
| words, it is a symbol table for the code). In this form of Kaleidoscope, | |
| the only things that can be referenced are function parameters. As such, | |
| function parameters will be in this map when generating code for their | |
| function body. | |
| With these basics in place, we can start talking about how to generate | |
| code for each expression. Note that this assumes that the | |
| ``Codgen.builder`` has been set up to generate code *into* something. | |
| For now, we'll assume that this has already been done, and we'll just | |
| use it to emit code. | |
| Expression Code Generation | |
| ========================== | |
| Generating LLVM code for expression nodes is very straightforward: less | |
| than 30 lines of commented code for all four of our expression nodes. | |
| First we'll do numeric literals: | |
| .. code-block:: ocaml | |
| | Ast.Number n -> const_float double_type n | |
| In the LLVM IR, numeric constants are represented with the | |
| ``ConstantFP`` class, which holds the numeric value in an ``APFloat`` | |
| internally (``APFloat`` has the capability of holding floating point | |
| constants of Arbitrary Precision). This code basically just creates | |
| and returns a ``ConstantFP``. Note that in the LLVM IR that constants | |
| are all uniqued together and shared. For this reason, the API uses "the | |
| foo::get(..)" idiom instead of "new foo(..)" or "foo::Create(..)". | |
| .. code-block:: ocaml | |
| | Ast.Variable name -> | |
| (try Hashtbl.find named_values name with | |
| | Not_found -> raise (Error "unknown variable name")) | |
| References to variables are also quite simple using LLVM. In the simple | |
| version of Kaleidoscope, we assume that the variable has already been | |
| emitted somewhere and its value is available. In practice, the only | |
| values that can be in the ``Codegen.named_values`` map are function | |
| arguments. This code simply checks to see that the specified name is in | |
| the map (if not, an unknown variable is being referenced) and returns | |
| the value for it. In future chapters, we'll add support for `loop | |
| induction variables <LangImpl5.html#for-loop-expression>`_ in the symbol table, and for | |
| `local variables <LangImpl7.html#user-defined-local-variables>`_. | |
| .. code-block:: ocaml | |
| | Ast.Binary (op, lhs, rhs) -> | |
| let lhs_val = codegen_expr lhs in | |
| let rhs_val = codegen_expr rhs in | |
| begin | |
| match op with | |
| | '+' -> build_fadd lhs_val rhs_val "addtmp" builder | |
| | '-' -> build_fsub lhs_val rhs_val "subtmp" builder | |
| | '*' -> build_fmul lhs_val rhs_val "multmp" builder | |
| | '<' -> | |
| (* Convert bool 0/1 to double 0.0 or 1.0 *) | |
| let i = build_fcmp Fcmp.Ult lhs_val rhs_val "cmptmp" builder in | |
| build_uitofp i double_type "booltmp" builder | |
| | _ -> raise (Error "invalid binary operator") | |
| end | |
| Binary operators start to get more interesting. The basic idea here is | |
| that we recursively emit code for the left-hand side of the expression, | |
| then the right-hand side, then we compute the result of the binary | |
| expression. In this code, we do a simple switch on the opcode to create | |
| the right LLVM instruction. | |
| In the example above, the LLVM builder class is starting to show its | |
| value. IRBuilder knows where to insert the newly created instruction, | |
| all you have to do is specify what instruction to create (e.g. with | |
| ``Llvm.create_add``), which operands to use (``lhs`` and ``rhs`` here) | |
| and optionally provide a name for the generated instruction. | |
| One nice thing about LLVM is that the name is just a hint. For instance, | |
| if the code above emits multiple "addtmp" variables, LLVM will | |
| automatically provide each one with an increasing, unique numeric | |
| suffix. Local value names for instructions are purely optional, but it | |
| makes it much easier to read the IR dumps. | |
| `LLVM instructions <../LangRef.html#instruction-reference>`_ are constrained by strict | |
| rules: for example, the Left and Right operators of an `add | |
| instruction <../LangRef.html#add-instruction>`_ must have the same type, and the | |
| result type of the add must match the operand types. Because all values | |
| in Kaleidoscope are doubles, this makes for very simple code for add, | |
| sub and mul. | |
| On the other hand, LLVM specifies that the `fcmp | |
| instruction <../LangRef.html#fcmp-instruction>`_ always returns an 'i1' value (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 a `uitofp | |
| instruction <../LangRef.html#uitofp-to-instruction>`_. This instruction converts its | |
| input integer into a floating point value by treating the input as an | |
| unsigned value. In contrast, if we used the `sitofp | |
| instruction <../LangRef.html#sitofp-to-instruction>`_, the Kaleidoscope '<' operator | |
| would return 0.0 and -1.0, depending on the input value. | |
| .. code-block:: ocaml | |
| | Ast.Call (callee, args) -> | |
| (* Look up the name in the module table. *) | |
| let callee = | |
| match lookup_function callee the_module with | |
| | Some callee -> callee | |
| | None -> raise (Error "unknown function referenced") | |
| in | |
| let params = params callee in | |
| (* If argument mismatch error. *) | |
| if Array.length params == Array.length args then () else | |
| raise (Error "incorrect # arguments passed"); | |
| let args = Array.map codegen_expr args in | |
| build_call callee args "calltmp" builder | |
| Code generation for function calls is quite straightforward with LLVM. | |
| The code above initially does a function name lookup in the LLVM | |
| Module's symbol table. Recall that the LLVM Module is the container that | |
| holds all of the functions we are JIT'ing. By giving each function the | |
| same name as what the user specifies, we can use the LLVM symbol table | |
| to resolve function names for us. | |
| Once we have the function to call, we recursively codegen each argument | |
| that is to be passed in, and create an LLVM `call | |
| instruction <../LangRef.html#call-instruction>`_. Note that LLVM uses the native C | |
| calling conventions by default, allowing these calls to also call into | |
| standard library functions like "sin" and "cos", with no additional | |
| effort. | |
| This wraps up our handling of the four basic expressions that we have so | |
| far in Kaleidoscope. Feel free to go in and add some more. For example, | |
| by browsing the `LLVM language reference <../LangRef.html>`_ you'll find | |
| several other interesting instructions that are really easy to plug into | |
| our basic framework. | |
| Function Code Generation | |
| ======================== | |
| Code generation for prototypes and functions must handle a number of | |
| details, which make their code less beautiful than expression code | |
| generation, but allows us to illustrate some important points. First, | |
| lets talk about code generation for prototypes: they are used both for | |
| function bodies and external function declarations. The code starts | |
| with: | |
| .. code-block:: ocaml | |
| let codegen_proto = function | |
| | Ast.Prototype (name, args) -> | |
| (* Make the function type: double(double,double) etc. *) | |
| let doubles = Array.make (Array.length args) double_type in | |
| let ft = function_type double_type doubles in | |
| let f = | |
| match lookup_function name the_module with | |
| This code packs a lot of power into a few lines. Note first that this | |
| function returns a "Function\*" instead of a "Value\*" (although at the | |
| moment they both are modeled by ``llvalue`` in ocaml). Because a | |
| "prototype" really talks about the external interface for a function | |
| (not the value computed by an expression), it makes sense for it to | |
| return the LLVM Function it corresponds to when codegen'd. | |
| The call to ``Llvm.function_type`` creates the ``Llvm.llvalue`` that | |
| should be used for a given Prototype. Since all function arguments in | |
| Kaleidoscope are of type double, the first line creates a vector of "N" | |
| LLVM double types. It then uses the ``Llvm.function_type`` method to | |
| create a function type that takes "N" doubles as arguments, returns one | |
| double as a result, and that is not vararg (that uses the function | |
| ``Llvm.var_arg_function_type``). Note that Types in LLVM are uniqued | |
| just like ``Constant``'s are, so you don't "new" a type, you "get" it. | |
| The final line above checks if the function has already been defined in | |
| ``Codegen.the_module``. If not, we will create it. | |
| .. code-block:: ocaml | |
| | None -> declare_function name ft the_module | |
| This indicates the type and name to use, as well as which module to | |
| insert into. By default we assume a function has | |
| ``Llvm.Linkage.ExternalLinkage``. "`external | |
| linkage <../LangRef.html#linkage>`_" means that the function may be defined | |
| outside the current module and/or that it is callable by functions | |
| outside the module. The "``name``" passed in is the name the user | |
| specified: this name is registered in "``Codegen.the_module``"s symbol | |
| table, which is used by the function call code above. | |
| In Kaleidoscope, I choose to allow redefinitions of functions in two | |
| cases: first, we want to allow 'extern'ing a function more than once, as | |
| long as the prototypes for the externs match (since all arguments have | |
| the same type, we just have to check that the number of arguments | |
| match). Second, we want to allow 'extern'ing a function and then | |
| defining a body for it. This is useful when defining mutually recursive | |
| functions. | |
| .. code-block:: ocaml | |
| (* If 'f' conflicted, there was already something named 'name'. If it | |
| * has a body, don't allow redefinition or reextern. *) | |
| | Some f -> | |
| (* If 'f' already has a body, reject this. *) | |
| if Array.length (basic_blocks f) == 0 then () else | |
| raise (Error "redefinition of function"); | |
| (* If 'f' took a different number of arguments, reject. *) | |
| if Array.length (params f) == Array.length args then () else | |
| raise (Error "redefinition of function with different # args"); | |
| f | |
| in | |
| In order to verify the logic above, we first check to see if the | |
| pre-existing function is "empty". In this case, empty means that it has | |
| no basic blocks in it, which means it has no body. If it has no body, it | |
| is a forward declaration. Since we don't allow anything after a full | |
| definition of the function, the code rejects this case. If the previous | |
| reference to a function was an 'extern', we simply verify that the | |
| number of arguments for that definition and this one match up. If not, | |
| we emit an error. | |
| .. code-block:: ocaml | |
| (* Set names for all arguments. *) | |
| Array.iteri (fun i a -> | |
| let n = args.(i) in | |
| set_value_name n a; | |
| Hashtbl.add named_values n a; | |
| ) (params f); | |
| f | |
| The last bit of code for prototypes loops over all of the arguments in | |
| the function, setting the name of the LLVM Argument objects to match, | |
| and registering the arguments in the ``Codegen.named_values`` map for | |
| future use by the ``Ast.Variable`` variant. Once this is set up, it | |
| returns the Function object to the caller. Note that we don't check for | |
| conflicting argument names here (e.g. "extern foo(a b a)"). Doing so | |
| would be very straight-forward with the mechanics we have already used | |
| above. | |
| .. code-block:: ocaml | |
| let codegen_func = function | |
| | Ast.Function (proto, body) -> | |
| Hashtbl.clear named_values; | |
| let the_function = codegen_proto proto in | |
| Code generation for function definitions starts out simply enough: we | |
| just codegen the prototype (Proto) and verify that it is ok. We then | |
| clear out the ``Codegen.named_values`` map to make sure that there isn't | |
| anything in it from the last function we compiled. Code generation of | |
| the prototype ensures that there is an LLVM Function object that is | |
| ready to go for us. | |
| .. code-block:: ocaml | |
| (* Create a new basic block to start insertion into. *) | |
| let bb = append_block context "entry" the_function in | |
| position_at_end bb builder; | |
| try | |
| let ret_val = codegen_expr body in | |
| Now we get to the point where the ``Codegen.builder`` is set up. The | |
| first line creates a new `basic | |
| block <http://en.wikipedia.org/wiki/Basic_block>`_ (named "entry"), | |
| which is inserted into ``the_function``. The second line then tells the | |
| builder that new instructions should be inserted into the end of the new | |
| basic block. Basic blocks in LLVM are an important part of functions | |
| that define the `Control Flow | |
| Graph <http://en.wikipedia.org/wiki/Control_flow_graph>`_. Since we | |
| don't have any control flow, our functions will only contain one block | |
| at this point. We'll fix this in `Chapter 5 <OCamlLangImpl5.html>`_ :). | |
| .. code-block:: ocaml | |
| let ret_val = codegen_expr body in | |
| (* Finish off the function. *) | |
| let _ = build_ret ret_val builder in | |
| (* Validate the generated code, checking for consistency. *) | |
| Llvm_analysis.assert_valid_function the_function; | |
| the_function | |
| Once the insertion point is set up, we call the ``Codegen.codegen_func`` | |
| method for the root expression of the function. If no error happens, | |
| this emits code to compute the expression into the entry block and | |
| returns the value that was computed. Assuming no error, we then create | |
| an LLVM `ret instruction <../LangRef.html#ret-instruction>`_, which completes the | |
| function. Once the function is built, we call | |
| ``Llvm_analysis.assert_valid_function``, which is provided by LLVM. This | |
| function does a variety of consistency checks on the generated code, to | |
| determine if our compiler is doing everything right. Using this is | |
| important: it can catch a lot of bugs. Once the function is finished and | |
| validated, we return it. | |
| .. code-block:: ocaml | |
| with e -> | |
| delete_function the_function; | |
| raise e | |
| The only piece left here is handling of the error case. For simplicity, | |
| we handle this by merely deleting the function we produced with the | |
| ``Llvm.delete_function`` method. This allows the user to redefine a | |
| function that they incorrectly typed in before: if we didn't delete it, | |
| it would live in the symbol table, with a body, preventing future | |
| redefinition. | |
| This code does have a bug, though. Since the ``Codegen.codegen_proto`` | |
| can return a previously defined forward declaration, our code can | |
| actually delete a forward declaration. There are a number of ways to fix | |
| this bug, see what you can come up with! Here is a testcase: | |
| :: | |
| extern foo(a b); # ok, defines foo. | |
| def foo(a b) c; # error, 'c' is invalid. | |
| def bar() foo(1, 2); # error, unknown function "foo" | |
| Driver Changes and Closing Thoughts | |
| =================================== | |
| For now, code generation to LLVM doesn't really get us much, except that | |
| we can look at the pretty IR calls. The sample code inserts calls to | |
| Codegen into the "``Toplevel.main_loop``", and then dumps out the LLVM | |
| IR. This gives a nice way to look at the LLVM IR for simple functions. | |
| For example: | |
| :: | |
| ready> 4+5; | |
| Read top-level expression: | |
| define double @""() { | |
| entry: | |
| %addtmp = fadd double 4.000000e+00, 5.000000e+00 | |
| ret double %addtmp | |
| } | |
| Note how the parser turns the top-level expression into anonymous | |
| functions for us. This will be handy when we add `JIT | |
| support <OCamlLangImpl4.html#adding-a-jit-compiler>`_ in the next chapter. Also note that | |
| the code is very literally transcribed, no optimizations are being | |
| performed. We will `add | |
| optimizations <OCamlLangImpl4.html#trivial-constant-folding>`_ explicitly in the | |
| next chapter. | |
| :: | |
| ready> def foo(a b) a*a + 2*a*b + b*b; | |
| Read function definition: | |
| define double @foo(double %a, double %b) { | |
| entry: | |
| %multmp = fmul double %a, %a | |
| %multmp1 = fmul double 2.000000e+00, %a | |
| %multmp2 = fmul double %multmp1, %b | |
| %addtmp = fadd double %multmp, %multmp2 | |
| %multmp3 = fmul double %b, %b | |
| %addtmp4 = fadd double %addtmp, %multmp3 | |
| ret double %addtmp4 | |
| } | |
| This shows some simple arithmetic. Notice the striking similarity to the | |
| LLVM builder calls that we use to create the instructions. | |
| :: | |
| ready> def bar(a) foo(a, 4.0) + bar(31337); | |
| Read function definition: | |
| define double @bar(double %a) { | |
| entry: | |
| %calltmp = call double @foo(double %a, double 4.000000e+00) | |
| %calltmp1 = call double @bar(double 3.133700e+04) | |
| %addtmp = fadd double %calltmp, %calltmp1 | |
| ret double %addtmp | |
| } | |
| This shows some function calls. Note that this function will take a long | |
| time to execute if you call it. In the future we'll add conditional | |
| control flow to actually make recursion useful :). | |
| :: | |
| ready> extern cos(x); | |
| Read extern: | |
| declare double @cos(double) | |
| ready> cos(1.234); | |
| Read top-level expression: | |
| define double @""() { | |
| entry: | |
| %calltmp = call double @cos(double 1.234000e+00) | |
| ret double %calltmp | |
| } | |
| This shows an extern for the libm "cos" function, and a call to it. | |
| :: | |
| ready> ^D | |
| ; ModuleID = 'my cool jit' | |
| define double @""() { | |
| entry: | |
| %addtmp = fadd double 4.000000e+00, 5.000000e+00 | |
| ret double %addtmp | |
| } | |
| define double @foo(double %a, double %b) { | |
| entry: | |
| %multmp = fmul double %a, %a | |
| %multmp1 = fmul double 2.000000e+00, %a | |
| %multmp2 = fmul double %multmp1, %b | |
| %addtmp = fadd double %multmp, %multmp2 | |
| %multmp3 = fmul double %b, %b | |
| %addtmp4 = fadd double %addtmp, %multmp3 | |
| ret double %addtmp4 | |
| } | |
| define double @bar(double %a) { | |
| entry: | |
| %calltmp = call double @foo(double %a, double 4.000000e+00) | |
| %calltmp1 = call double @bar(double 3.133700e+04) | |
| %addtmp = fadd double %calltmp, %calltmp1 | |
| ret double %addtmp | |
| } | |
| declare double @cos(double) | |
| define double @""() { | |
| entry: | |
| %calltmp = call double @cos(double 1.234000e+00) | |
| ret double %calltmp | |
| } | |
| When you quit the current demo, it dumps out the IR for the entire | |
| module generated. Here you can see the big picture with all the | |
| functions referencing each other. | |
| This wraps up the third chapter of the Kaleidoscope tutorial. Up next, | |
| we'll describe how to `add JIT codegen and optimizer | |
| support <OCamlLangImpl4.html>`_ to this so we can actually start running | |
| code! | |
| Full Code Listing | |
| ================= | |
| Here is the complete code listing for our running example, enhanced with | |
| the LLVM code generator. Because this uses the LLVM libraries, we need | |
| to link them in. To do this, we use the | |
| `llvm-config <http://llvm.org/cmds/llvm-config.html>`_ tool to inform | |
| our makefile/command line about which options to use: | |
| .. code-block:: bash | |
| # Compile | |
| ocamlbuild toy.byte | |
| # Run | |
| ./toy.byte | |
| Here is the code: | |
| \_tags: | |
| :: | |
| <{lexer,parser}.ml>: use_camlp4, pp(camlp4of) | |
| <*.{byte,native}>: g++, use_llvm, use_llvm_analysis | |
| myocamlbuild.ml: | |
| .. code-block:: ocaml | |
| open Ocamlbuild_plugin;; | |
| ocaml_lib ~extern:true "llvm";; | |
| ocaml_lib ~extern:true "llvm_analysis";; | |
| flag ["link"; "ocaml"; "g++"] (S[A"-cc"; A"g++"]);; | |
| token.ml: | |
| .. code-block:: ocaml | |
| (*===----------------------------------------------------------------------=== | |
| * Lexer Tokens | |
| *===----------------------------------------------------------------------===*) | |
| (* The lexer returns these 'Kwd' if it is an unknown character, otherwise one of | |
| * these others for known things. *) | |
| type token = | |
| (* commands *) | |
| | Def | Extern | |
| (* primary *) | |
| | Ident of string | Number of float | |
| (* unknown *) | |
| | Kwd of char | |
| lexer.ml: | |
| .. code-block:: ocaml | |
| (*===----------------------------------------------------------------------=== | |
| * Lexer | |
| *===----------------------------------------------------------------------===*) | |
| let rec lex = parser | |
| (* Skip any whitespace. *) | |
| | [< ' (' ' | '\n' | '\r' | '\t'); stream >] -> lex stream | |
| (* identifier: [a-zA-Z][a-zA-Z0-9] *) | |
| | [< ' ('A' .. 'Z' | 'a' .. 'z' as c); stream >] -> | |
| let buffer = Buffer.create 1 in | |
| Buffer.add_char buffer c; | |
| lex_ident buffer stream | |
| (* number: [0-9.]+ *) | |
| | [< ' ('0' .. '9' as c); stream >] -> | |
| let buffer = Buffer.create 1 in | |
| Buffer.add_char buffer c; | |
| lex_number buffer stream | |
| (* Comment until end of line. *) | |
| | [< ' ('#'); stream >] -> | |
| lex_comment stream | |
| (* Otherwise, just return the character as its ascii value. *) | |
| | [< 'c; stream >] -> | |
| [< 'Token.Kwd c; lex stream >] | |
| (* end of stream. *) | |
| | [< >] -> [< >] | |
| and lex_number buffer = parser | |
| | [< ' ('0' .. '9' | '.' as c); stream >] -> | |
| Buffer.add_char buffer c; | |
| lex_number buffer stream | |
| | [< stream=lex >] -> | |
| [< 'Token.Number (float_of_string (Buffer.contents buffer)); stream >] | |
| and lex_ident buffer = parser | |
| | [< ' ('A' .. 'Z' | 'a' .. 'z' | '0' .. '9' as c); stream >] -> | |
| Buffer.add_char buffer c; | |
| lex_ident buffer stream | |
| | [< stream=lex >] -> | |
| match Buffer.contents buffer with | |
| | "def" -> [< 'Token.Def; stream >] | |
| | "extern" -> [< 'Token.Extern; stream >] | |
| | id -> [< 'Token.Ident id; stream >] | |
| and lex_comment = parser | |
| | [< ' ('\n'); stream=lex >] -> stream | |
| | [< 'c; e=lex_comment >] -> e | |
| | [< >] -> [< >] | |
| ast.ml: | |
| .. code-block:: ocaml | |
| (*===----------------------------------------------------------------------=== | |
| * Abstract Syntax Tree (aka Parse Tree) | |
| *===----------------------------------------------------------------------===*) | |
| (* expr - Base type for all expression nodes. *) | |
| type expr = | |
| (* variant for numeric literals like "1.0". *) | |
| | Number of float | |
| (* variant for referencing a variable, like "a". *) | |
| | Variable of string | |
| (* variant for a binary operator. *) | |
| | Binary of char * expr * expr | |
| (* variant for function calls. *) | |
| | Call of string * expr array | |
| (* proto - This type represents the "prototype" for a function, which captures | |
| * its name, and its argument names (thus implicitly the number of arguments the | |
| * function takes). *) | |
| type proto = Prototype of string * string array | |
| (* func - This type represents a function definition itself. *) | |
| type func = Function of proto * expr | |
| parser.ml: | |
| .. code-block:: ocaml | |
| (*===---------------------------------------------------------------------=== | |
| * Parser | |
| *===---------------------------------------------------------------------===*) | |
| (* binop_precedence - This holds the precedence for each binary operator that is | |
| * defined *) | |
| let binop_precedence:(char, int) Hashtbl.t = Hashtbl.create 10 | |
| (* precedence - Get the precedence of the pending binary operator token. *) | |
| let precedence c = try Hashtbl.find binop_precedence c with Not_found -> -1 | |
| (* primary | |
| * ::= identifier | |
| * ::= numberexpr | |
| * ::= parenexpr *) | |
| let rec parse_primary = parser | |
| (* numberexpr ::= number *) | |
| | [< 'Token.Number n >] -> Ast.Number n | |
| (* parenexpr ::= '(' expression ')' *) | |
| | [< 'Token.Kwd '('; e=parse_expr; 'Token.Kwd ')' ?? "expected ')'" >] -> e | |
| (* identifierexpr | |
| * ::= identifier | |
| * ::= identifier '(' argumentexpr ')' *) | |
| | [< 'Token.Ident id; stream >] -> | |
| let rec parse_args accumulator = parser | |
| | [< e=parse_expr; stream >] -> | |
| begin parser | |
| | [< 'Token.Kwd ','; e=parse_args (e :: accumulator) >] -> e | |
| | [< >] -> e :: accumulator | |
| end stream | |
| | [< >] -> accumulator | |
| in | |
| let rec parse_ident id = parser | |
| (* Call. *) | |
| | [< 'Token.Kwd '('; | |
| args=parse_args []; | |
| 'Token.Kwd ')' ?? "expected ')'">] -> | |
| Ast.Call (id, Array.of_list (List.rev args)) | |
| (* Simple variable ref. *) | |
| | [< >] -> Ast.Variable id | |
| in | |
| parse_ident id stream | |
| | [< >] -> raise (Stream.Error "unknown token when expecting an expression.") | |
| (* binoprhs | |
| * ::= ('+' primary)* *) | |
| and parse_bin_rhs expr_prec lhs stream = | |
| match Stream.peek stream with | |
| (* If this is a binop, find its precedence. *) | |
| | Some (Token.Kwd c) when Hashtbl.mem binop_precedence c -> | |
| let token_prec = precedence c in | |
| (* If this is a binop that binds at least as tightly as the current binop, | |
| * consume it, otherwise we are done. *) | |
| if token_prec < expr_prec then lhs else begin | |
| (* Eat the binop. *) | |
| Stream.junk stream; | |
| (* Parse the primary expression after the binary operator. *) | |
| let rhs = parse_primary stream in | |
| (* Okay, we know this is a binop. *) | |
| let rhs = | |
| match Stream.peek stream with | |
| | Some (Token.Kwd c2) -> | |
| (* If BinOp binds less tightly with rhs than the operator after | |
| * rhs, let the pending operator take rhs as its lhs. *) | |
| let next_prec = precedence c2 in | |
| if token_prec < next_prec | |
| then parse_bin_rhs (token_prec + 1) rhs stream | |
| else rhs | |
| | _ -> rhs | |
| in | |
| (* Merge lhs/rhs. *) | |
| let lhs = Ast.Binary (c, lhs, rhs) in | |
| parse_bin_rhs expr_prec lhs stream | |
| end | |
| | _ -> lhs | |
| (* expression | |
| * ::= primary binoprhs *) | |
| and parse_expr = parser | |
| | [< lhs=parse_primary; stream >] -> parse_bin_rhs 0 lhs stream | |
| (* prototype | |
| * ::= id '(' id* ')' *) | |
| let parse_prototype = | |
| let rec parse_args accumulator = parser | |
| | [< 'Token.Ident id; e=parse_args (id::accumulator) >] -> e | |
| | [< >] -> accumulator | |
| in | |
| parser | |
| | [< 'Token.Ident id; | |
| 'Token.Kwd '(' ?? "expected '(' in prototype"; | |
| args=parse_args []; | |
| 'Token.Kwd ')' ?? "expected ')' in prototype" >] -> | |
| (* success. *) | |
| Ast.Prototype (id, Array.of_list (List.rev args)) | |
| | [< >] -> | |
| raise (Stream.Error "expected function name in prototype") | |
| (* definition ::= 'def' prototype expression *) | |
| let parse_definition = parser | |
| | [< 'Token.Def; p=parse_prototype; e=parse_expr >] -> | |
| Ast.Function (p, e) | |
| (* toplevelexpr ::= expression *) | |
| let parse_toplevel = parser | |
| | [< e=parse_expr >] -> | |
| (* Make an anonymous proto. *) | |
| Ast.Function (Ast.Prototype ("", [||]), e) | |
| (* external ::= 'extern' prototype *) | |
| let parse_extern = parser | |
| | [< 'Token.Extern; e=parse_prototype >] -> e | |
| codegen.ml: | |
| .. code-block:: ocaml | |
| (*===----------------------------------------------------------------------=== | |
| * Code Generation | |
| *===----------------------------------------------------------------------===*) | |
| open Llvm | |
| exception Error of string | |
| let context = global_context () | |
| let the_module = create_module context "my cool jit" | |
| let builder = builder context | |
| let named_values:(string, llvalue) Hashtbl.t = Hashtbl.create 10 | |
| let double_type = double_type context | |
| let rec codegen_expr = function | |
| | Ast.Number n -> const_float double_type n | |
| | Ast.Variable name -> | |
| (try Hashtbl.find named_values name with | |
| | Not_found -> raise (Error "unknown variable name")) | |
| | Ast.Binary (op, lhs, rhs) -> | |
| let lhs_val = codegen_expr lhs in | |
| let rhs_val = codegen_expr rhs in | |
| begin | |
| match op with | |
| | '+' -> build_add lhs_val rhs_val "addtmp" builder | |
| | '-' -> build_sub lhs_val rhs_val "subtmp" builder | |
| | '*' -> build_mul lhs_val rhs_val "multmp" builder | |
| | '<' -> | |
| (* Convert bool 0/1 to double 0.0 or 1.0 *) | |
| let i = build_fcmp Fcmp.Ult lhs_val rhs_val "cmptmp" builder in | |
| build_uitofp i double_type "booltmp" builder | |
| | _ -> raise (Error "invalid binary operator") | |
| end | |
| | Ast.Call (callee, args) -> | |
| (* Look up the name in the module table. *) | |
| let callee = | |
| match lookup_function callee the_module with | |
| | Some callee -> callee | |
| | None -> raise (Error "unknown function referenced") | |
| in | |
| let params = params callee in | |
| (* If argument mismatch error. *) | |
| if Array.length params == Array.length args then () else | |
| raise (Error "incorrect # arguments passed"); | |
| let args = Array.map codegen_expr args in | |
| build_call callee args "calltmp" builder | |
| let codegen_proto = function | |
| | Ast.Prototype (name, args) -> | |
| (* Make the function type: double(double,double) etc. *) | |
| let doubles = Array.make (Array.length args) double_type in | |
| let ft = function_type double_type doubles in | |
| let f = | |
| match lookup_function name the_module with | |
| | None -> declare_function name ft the_module | |
| (* If 'f' conflicted, there was already something named 'name'. If it | |
| * has a body, don't allow redefinition or reextern. *) | |
| | Some f -> | |
| (* If 'f' already has a body, reject this. *) | |
| if block_begin f <> At_end f then | |
| raise (Error "redefinition of function"); | |
| (* If 'f' took a different number of arguments, reject. *) | |
| if element_type (type_of f) <> ft then | |
| raise (Error "redefinition of function with different # args"); | |
| f | |
| in | |
| (* Set names for all arguments. *) | |
| Array.iteri (fun i a -> | |
| let n = args.(i) in | |
| set_value_name n a; | |
| Hashtbl.add named_values n a; | |
| ) (params f); | |
| f | |
| let codegen_func = function | |
| | Ast.Function (proto, body) -> | |
| Hashtbl.clear named_values; | |
| let the_function = codegen_proto proto in | |
| (* Create a new basic block to start insertion into. *) | |
| let bb = append_block context "entry" the_function in | |
| position_at_end bb builder; | |
| try | |
| let ret_val = codegen_expr body in | |
| (* Finish off the function. *) | |
| let _ = build_ret ret_val builder in | |
| (* Validate the generated code, checking for consistency. *) | |
| Llvm_analysis.assert_valid_function the_function; | |
| the_function | |
| with e -> | |
| delete_function the_function; | |
| raise e | |
| toplevel.ml: | |
| .. code-block:: ocaml | |
| (*===----------------------------------------------------------------------=== | |
| * Top-Level parsing and JIT Driver | |
| *===----------------------------------------------------------------------===*) | |
| open Llvm | |
| (* top ::= definition | external | expression | ';' *) | |
| let rec main_loop stream = | |
| match Stream.peek stream with | |
| | None -> () | |
| (* ignore top-level semicolons. *) | |
| | Some (Token.Kwd ';') -> | |
| Stream.junk stream; | |
| main_loop stream | |
| | Some token -> | |
| begin | |
| try match token with | |
| | Token.Def -> | |
| let e = Parser.parse_definition stream in | |
| print_endline "parsed a function definition."; | |
| dump_value (Codegen.codegen_func e); | |
| | Token.Extern -> | |
| let e = Parser.parse_extern stream in | |
| print_endline "parsed an extern."; | |
| dump_value (Codegen.codegen_proto e); | |
| | _ -> | |
| (* Evaluate a top-level expression into an anonymous function. *) | |
| let e = Parser.parse_toplevel stream in | |
| print_endline "parsed a top-level expr"; | |
| dump_value (Codegen.codegen_func e); | |
| with Stream.Error s | Codegen.Error s -> | |
| (* Skip token for error recovery. *) | |
| Stream.junk stream; | |
| print_endline s; | |
| end; | |
| print_string "ready> "; flush stdout; | |
| main_loop stream | |
| toy.ml: | |
| .. code-block:: ocaml | |
| (*===----------------------------------------------------------------------=== | |
| * Main driver code. | |
| *===----------------------------------------------------------------------===*) | |
| open Llvm | |
| let main () = | |
| (* Install standard binary operators. | |
| * 1 is the lowest precedence. *) | |
| Hashtbl.add Parser.binop_precedence '<' 10; | |
| Hashtbl.add Parser.binop_precedence '+' 20; | |
| Hashtbl.add Parser.binop_precedence '-' 20; | |
| Hashtbl.add Parser.binop_precedence '*' 40; (* highest. *) | |
| (* Prime the first token. *) | |
| print_string "ready> "; flush stdout; | |
| let stream = Lexer.lex (Stream.of_channel stdin) in | |
| (* Run the main "interpreter loop" now. *) | |
| Toplevel.main_loop stream; | |
| (* Print out all the generated code. *) | |
| dump_module Codegen.the_module | |
| ;; | |
| main () | |
| `Next: Adding JIT and Optimizer Support <OCamlLangImpl4.html>`_ | |