Cairo Bytecode#
Cairo bytecode is a binary format used to represent Cairo programs. It consists of a series of field elements, each of which is an integer value. These elements are arranged in a specific order so that the Cairo Runner can execute them correctly.
In addition to the field elements, Cairo bytecode also includes two index values, prog_start and prog_end, which specify the starting and ending positions of the computation to be executed in the bytecode. This allows the Cairo Runner to correctly identify the code segment to be executed and load it into memory.
Cairo bytecode is generated by compiling Cairo source code. The compiler converts the source code into an equivalent bytecode representation and saves it in a file for later execution. This compilation process can be done using the cairo-compile command.
Relationship between Cairo Assembly Code and Bytecode#
Cairo assembly code is a human-readable text format used to represent the instruction sequence of Cairo programs. It can be written manually or generated by compiling Cairo source code. Unlike Cairo bytecode, Cairo assembly code is a text format that is easy to read and edit.
In practical development, programmers usually use Cairo source code to write programs and use the cairo-compile command to compile it into bytecode. However, in some cases, manually writing Cairo assembly code may be more convenient or suitable for specific tasks.
The relationship between Cairo assembly code and bytecode is that the cairo-compile command can convert Cairo source code into an equivalent bytecode representation and save it in a file for later execution. On the other hand, the cairo-disasm command can be used to convert bytecode back into human-readable assembly code format.
In summary, in practical development, programmers usually use Cairo source code to write programs and use the cairo-compile command to convert it into bytecode. However, in some cases, manually writing Cairo assembly code may be more convenient or suitable for specific tasks.
Cairo Memory Mechanism#
In Cairo, the memory mechanism is implemented through relocatable memory segments. A relocatable memory segment is a special type of memory region that can be dynamically allocated and deallocated during program execution, and can be shared between different programs.
Cairo Runner uses relocatable memory segments to manage the memory of a program. When the program needs to allocate new memory, Cairo Runner requests a new block of memory from the operating system and adds it to the relocatable memory segment. When a memory block is no longer needed by the program, Cairo Runner removes it from the relocatable memory segment and returns it to the operating system.
In addition, Cairo also supports a garbage collection mechanism to automatically manage unused memory. The garbage collector periodically scans all objects used by the program and marks those that are no longer referenced for deletion.
In summary, relocatable memory segments and the garbage collection mechanism are key components of Cairo's memory mechanism. These mechanisms allow Cairo to dynamically allocate and deallocate memory and automatically manage unused objects.
Execution Instruction Flow#
In Cairo, after executing the instruction pointed to by the PC, the Cairo Runner determines the operation to be executed and the next state based on the flags of the instruction. Specifically, the Cairo Runner performs the following steps:
- Read instruction: The Cairo Runner reads the instruction pointed to by the PC from memory.
- Decode instruction: The Cairo Runner decodes the instruction and determines the operation to be executed and the next state.
- Execute operation: Based on the decoded operation, the Cairo Runner performs the corresponding operation. For example, if the decoded operation is addition, the Cairo Runner adds the values in two registers and stores the result in another register.
- Update PC: Based on the decoded next state, the Cairo Runner updates the PC register to point to the next instruction to be executed. If the next state is a jump, the PC is set to the jump target address; otherwise, the PC is incremented to point to the next sequentially executed instruction.
- Repeat steps 1-4: Repeat the above steps until the program ends or an error occurs.
In summary, in Cairo, after executing the instruction pointed to by the PC, the Cairo Runner determines the operation to be executed and the next state based on the decoded flags, and executes each instruction in sequence.
Runner Instruction Decoding#
In Cairo, the process of decoding instructions by the Runner is as follows:
- Read instruction: The Runner reads the instruction pointed to by the PC from memory.
- Parse opcode: The Runner parses the opcode in the instruction to determine the type of operation to be executed.
- Parse registers: Based on the register numbers included in the instruction, the Runner determines the registers to be used.
- Parse immediate value: If the instruction includes an immediate value, the Runner parses it into the corresponding value.
- Execute operation: Based on the parsed operation type, registers, and immediate value, the Runner performs the corresponding operation.
- Update PC: Based on the decoded next state, the Runner updates the PC register to point to the next instruction to be executed. If the next state is a jump, the PC is set to the jump target address; otherwise, the PC is incremented to point to the next sequentially executed instruction.
In summary, in Cairo, the Runner decodes each instruction by parsing the opcode, registers, and immediate value included in the instruction, and performs the corresponding operation based on the decoded information.
Opcode#
In Cairo, an opcode is a binary code used in each instruction to represent the type of operation. Cairo's opcodes include the following:
- Addition instruction (ADD): Used to add the values in two registers.
- Subtraction instruction (SUB): Used to subtract the values in two registers.
- Multiplication instruction (MUL): Used to multiply the values in two registers.
- Division instruction (DIV): Used to divide the values in two registers.
- Assignment instruction (MOV): Used to copy the value from one register to another.
- Jump instruction (JMP): Used to jump to another part of the program to perform a specific operation.
- Conditional jump instruction (JCC): Used to jump to different parts of the program based on a condition. The condition can be equality, greater than, less than, etc.
- Function call instruction (CALL): Used to call a function defined in the program and pass arguments, then return to the calling point to continue execution.
- Return instruction (RET): Used to return from a function call and restore the calling point's state.
- Built-in function instruction (BUILTIN): Cairo provides some built-in functions such as string operations and mathematical functions. The built-in function instruction can call these functions to simplify code and improve efficiency.
- Exception handling instruction (EXCEPTION): When the program encounters an error or exceptional situation, Cairo can use exception handling mechanisms to catch and handle these exceptions. Exception handling instructions include throwing exceptions (THROW), catching exceptions (CATCH), and clearing exceptions (CLEAR), etc.
- Stack operation instruction (STACK): The stack is a data structure used to store temporary data during program execution.
Translation: