ZK World language compiler front end
Last updated
Last updated
This section will introduce the key components and functions of the ZK World language compiler front end. We will discuss in detail the process of lexical analysis, syntax parsing, abstract syntax tree (AST) generation, semantic analysis and LLVM intermediate representation (IR) generation.
The processing flow of the front end of the compiler is shown in Figure 13:
Lexical analysis is the first stage in the front end of the compiler. At this stage, the goal is to decompose the source code into a series of tokens. The ZK World language dictionary will handle the following elements:
strings (such as strings, numbers, and booleans) Sand Scab's Reviews Delimiters (such as parentheses and commas) Additionally, the dictionary program will eliminate whitespace and comments to ensure a clean token flow for the next stage.
Parsing is the process of converting the tokens generated during the lexical analysis phase into an Abstract Syntax Tree (AST). The ZK World language compiler will implement a top-down parser, such as a recursive descent parser, to support the grammar of the ZK World language. This section also discusses the implementation of error handling and recovery mechanisms to ensure that the parser handles syntax errors gracefully and provides useful error messages to the user.
The semantic analysis phase of the ZK World compiler is an extensive process that ensures program correctness and consistency. As mentioned earlier, this phase consists of several subtasks. Here, we delve deeper into each subtask, providing a more detailed and comprehensive explanation of the process.
The compiler analyzes the program's scope and context to accurately resolve symbols. It distinguishes between local and global variables, function declarations and type definitions. A symbol table containing information. For each symbol, it will be updated as the compiler walks the AST. Along the way, the compiler also checks for naming conflicts and multiple declarations to ensure that the program follows ZK World's scoping rules.
During the semantic analysis phase, we identify all list function names invoked by the user. We will also build the prototype code and verify that the parameters of the calls in the prototype code match the parameter types and numbers. If there is a match, we will record them for easy handling of the IR build-free function in the subsequent LLVM IR build phase.
The compiler ensures that every operation and expression in a program involves operands of compatible types. At this stage, the compiler also infers the type of the expression if necessary, and enforces type constraints on function calls, assignments, and arithmetic operations.
In addition to checking for unreachable code and infinite loops, the control flow analysis process also verifies: All code paths in a function that should return a value must end with a return statement. Break and continue statements appear only within loops. Variables are declared before they are used.
In this step, the compiler will perform the following tasks:
Arithmetic and bitwise operations are performed on constant expressions at compile time to ensure that the generated code is more efficient.
Detect potential errors, such as array indexing out of bounds, by evaluating expressions containing constants.
Folds constant expressions, such as mathematical operations or string concatenation, reducing code size and improving execution efficiency.
The final step of the semantic analysis phase includes several validation checks, including:
Verifies that a variable is initialized before use.
Make sure variables, functions and types are only declared once within a given scope.
Checks that all required function parameters are supplied and that no redundant parameters are supplied.
Verify that the return statement is used correctly in the function.
The semantic analysis phase is critical to the robustness and correctness of the ZK World compiler. By performing these comprehensive checks, the compiler can guarantee that the generated code follows the semantic rules of the language and is free of bugs that could cause unexpected behavior during execution. semantically validated AST, the ZK World Compiler will enter the next stage of the compilation process, ensuring that the source code is efficiently converted into executable code customized for ZK WorldVM.
The LLVM IR generation phase is a critical step in the ZK World compiler, as it converts the Abstract Syntax Tree (AST) obtained from semantic analysis into an LLVM Intermediate Representation (IR). This stage leverages the Inkwell framework, a powerful and user-friendly library that simplifies the process of generating LLVM IR code in Rust.
Initializes the Inkwell context by creating a new context object Sets target information such as target triplet, data layout, and target-specific optimization level by querying target machine properties This information helps generate correct LLVM IR code customized for the target architecture.
The pseudocode is shown in the figure below:
//Create a new LLVM context
Make Context=Context:: Create ();
Make the module=up and down_ Mo (name)
Let the builder=context be ()
Before generating LLVM IR for user-defined functions, the compiler will first generate LLVM IR for previously called lib functions, oracle functions, and built-in functions. These functions have fixed logic that will not be changed by ZK World contract developers
The pseudocode is shown in the figure below:
Please value (bin)
Please value (bin)
For each library function in nsc, a l l e d_ l i b _ f u n c t i o n s： .
If the library function=="u32 sqrt":
Define function u32_ Sqrt (value: i64) ->i64:
Root=prophet_ u3 2 _ Sqrt (value)
builtin_ range_ Check (root)
Root_ Square=root * root
Built in_ Asert (square root, value)
Return Root
Otherwise, if the lib function=="u32 _ xxx":
//Do nothing
other
//Do nothing
The AST is traversed using a depth-first approach, focusing on visiting functional nodes as they represent the main building blocks of ZK World programs. For each function node encountered, generate its corresponding LLVM IR.
The pseudocode is shown in the figure below:
fntraverss_ Ast (Node:&AstNode){
If AstNode:: function (func)=Node{
（& func）；
}
For children (){
Crossing method (for children);}
}
Each expression encountered in the function body is processed and a corresponding LLVM IR instruction is generated. This includes handling arithmetic operations, logical operations, and control flow constructs such as if-else expressions. For each type of expression, the appropriate function is called to generate LLVM IR code. For example, for binary expressions, use methods such as build_add, build_mul, or build_andFor function calls to generate appropriate arithmetic or logical operations, and use the build_call method to generate call instructions.
The pseudocode is shown in the figure below:
（>: and expression, builder: and builder) ->LLVMValue{
Matching Extender{
Expression: b (operation, operation)=>and>_ >(>,>, builder) in b,
Expression: If expression (cond, then expr, else expr)=>
(Connect, then _ e x p r, then _ else_expr, generator),
// ... Other expressions
}
}
Typemaps are a key function that needs to be implemented in order to convert ZK World types to their corresponding LLVM types. This mapping function should handle all ZK World types, including basic types (such as u32, u64 and u256) and complex types (such as structures and arrays). It is worth noting that the ZK World language is based on field types at its core, and the field order of various integer types based on it is 0x FFFFFFFF 00000001. To fully represent a field element, we use the method context to create an integer type. i64_type() . For complex types such as structures and arrays, you can use methods such as context to create custom LLVM types. struct_type() and context. array_type().
The pseudocode is shown in the figure below:
(>Type: and ῏ Type) ->LLVMType{
Match ZK World_ type {
Object type:: Field=>Background 64_ Type ()
U32=>Background 32_ （）， .
U64=>Background 64_ （）， .
. . Object type: U256=>Context type_ Type (context type 64_type(), 4),
Structure type: Structure (name)=>Context structure type (and structure [name]. Field: Array (elem type, size)=>Context ray_ type( .
m a p _ o l a _ t y p e _ t o _ l l vm _ Type (elem type), * size),
// ... Other types
}}
