Simple LLVM IR Generator in Rust

This challenge tasks you with building a rudimentary LLVM IR generator in Rust. The goal is to translate a simplified arithmetic expression language into LLVM Intermediate Representation (IR), allowing you to explore the fundamentals of compiler construction and code generation. This is a valuable exercise for understanding how high-level code is transformed into machine-executable instructions.

Problem Description

You will implement a function generate_llvm_ir that takes a string representing a simple arithmetic expression as input and returns a string containing the equivalent LLVM IR code. The expression language supports addition (+), subtraction (-), multiplication (*), division (/), integer literals (e.g., 10, -5), and a single variable x. The variable x is assumed to be an integer and will be passed as an argument to the generated function. The function should return the result of the expression as an integer.

The generated LLVM IR should:

Define a function named main that takes one integer argument x and returns an integer.
Evaluate the input expression using the value of x.
Return the result of the expression.
Use appropriate LLVM IR instructions for arithmetic operations.
Include necessary prologue and epilogue for the function.

Key Requirements:

The input expression will be syntactically valid (no need for parsing error handling).
The generated IR must be valid LLVM IR.
The generated IR should be reasonably efficient (avoid unnecessary instructions).
The code should be well-structured and readable.

Expected Behavior:

The generate_llvm_ir function should return a string containing the LLVM IR code that, when compiled and executed, would produce the correct result for the given expression and input value of x.

Edge Cases to Consider:

Division by zero (the problem does not require handling this; the LLVM runtime will handle it).
Negative numbers in the expression.
Expressions with only a single number (e.g., "10").
Expressions with multiple operations (e.g., "x + 5 * 2").

Examples

Example 1:

Input: "x + 5"
Output:

define i32 @main(i32 %x) {
  %add = add i32 %x, 5
  ret i32 %add
}

Explanation: The input expression "x + 5" is translated into an LLVM IR function that adds the value of x to 5 and returns the result.

Example 2:

Input: "10 * x - 2"
Output:

define i32 @main(i32 %x) {
  %mul = mul i32 10, %x
  %sub = sub i32 %mul, 2
  ret i32 %sub
}

Explanation: The input expression "10 * x - 2" is translated into an LLVM IR function that multiplies 10 by x, subtracts 2 from the result, and returns the final value.

Example 3:

Input: "x / 2 + 1"
Output:

define i32 @main(i32 %x) {
  %div = sdiv i32 %x, 2
  %add = add i32 %div, 1
  ret i32 %add
}

Explanation: The input expression "x / 2 + 1" is translated into an LLVM IR function that divides x by 2 (using signed division), adds 1 to the result, and returns the final value.

Constraints

The input expression string will be no longer than 256 characters.
The expression will only contain integers, the variable x, and the operators +, -, *, and /.
The generated LLVM IR should be compatible with a standard LLVM installation.
The generated IR should not include any external function calls beyond the basic arithmetic instructions.
Performance is not a primary concern; correctness and readability are prioritized.

Notes

You can use the llvm-ir crate or similar to help with generating the LLVM IR strings, but it's not strictly required. Manual string construction is acceptable.
Focus on generating the core logic of the expression evaluation. Error handling, optimization, and complex features are beyond the scope of this challenge.
Consider breaking down the problem into smaller, manageable functions (e.g., a function to generate the LLVM IR for a single operation).
Remember to include the function prologue and epilogue in your generated IR. The prologue should save any necessary registers, and the epilogue should restore them and return the result.
The sdiv instruction should be used for integer division.