1. Introduction of LLM4Decompile

LLM4Decompile aims to decompile x86 assembly instructions into C. The newly released V2 series are trained with a larger dataset (2B tokens) and a maximum token length of 4,096, with remarkable performance (up to 100% improvement) compared to the previous model.

• Github Repository: LLM4Decompile

2. Evaluation Results

3. How to Use

1. Install Ollama: Follow the instructions on the Ollama website.
2. Pull a model: ollama pull MHKetbi/llm4decompile-22b-v2.
3. Install the Ollama Python library: pip install ollama
4. Save the script: Save the code as a Python file (e.g., decompiler.py).
5. Create an input file: Create a file named my_assembly_file_O0.pseudo (replace my_assembly_file with your desired filename) containing the assembly code of the function you want to decompile.
6. Run the script: python decompiler.py my_assembly_file

import ollama
import sys

MODEL_NAME = 'MHKetbi/llm4decompile-22b-v2'


def decompile_with_ollama(asm_func, max_tokens=2048):
    """
    Decompiles an assembly function using Ollama.

    Args:
        asm_func: The assembly function as a string.
        max_tokens: The maximum number of tokens to generate.

    Returns:
        The decompiled C code as a string, or None if an error occurred.
    """
    try:
        # Construct a prompt for the Ollama model.  This is *crucial* for good results.
        # We're using a system prompt and a user prompt.  The system prompt sets the context.
        # The user prompt provides the input and asks for the output.
        messages = [
            {
                'role': 'system',
                'content': 'You are a helpful assistant that decompiles assembly code to C code.  '
                           'Provide only the C code, without any extra explanation or comments. '
                           'Do not include markdown formatting. Do not wrap the output in ```.'
            },
            {
                'role': 'user',
                'content': f'Decompile the following assembly code to C:\n\n{asm_func}'
            }
        ]

        response = ollama.chat(model=MODEL_NAME, messages=messages, stream=False)

        # Check if the response is valid and contains the decompiled code.
        if response and response.get('message') and response['message'].get('content'):
            c_func_decompile = response['message']['content'].strip()
            return c_func_decompile
        else:
            print("Error: Ollama did not return a valid response.", file=sys.stderr)
            return None

    except ollama.ResponseError as e:
        print(f"Error during Ollama request: {e}", file=sys.stderr)
        return None
    except Exception as e:
        print(f"An unexpected error occurred: {e}", file=sys.stderr)
        return None


def decompile_with_ollama_streaming(asm_func, max_tokens=2048):
    """
    Decompiles an assembly function using Ollama with streaming.

    Args:
        asm_func: The assembly function as a string.
        max_tokens:  (Not directly used in streaming, but kept for consistency).

    Returns:
        The decompiled C code as a string, or None if an error occurred.
    """
    try:
        messages = [
            {
                'role': 'system',
                'content': 'You are a helpful assistant that decompiles assembly code to C code.  '
                           'Provide only the C code, without any extra explanation or comments. '
                           'Do not include markdown formatting. Do not wrap the output in ```.'
            },
            {
                'role': 'user',
                'content': f'Decompile the following assembly code to C:\n\n{asm_func}'
            }
        ]

        stream = ollama.chat(model=MODEL_NAME, messages=messages, stream=True)

        c_func_decompile = ""
        for chunk in stream:
            if chunk and chunk.get('message') and chunk['message'].get('content'):
                c_func_decompile += chunk['message']['content']

        return c_func_decompile.strip()

    except ollama.ResponseError as e:
        print(f"Error during Ollama request: {e}", file=sys.stderr)
        return None
    except Exception as e:
        print(f"An unexpected error occurred: {e}", file=sys.stderr)
        return None



def main():
    if len(sys.argv) != 2:
        print("Usage: python script.py <filename>")
        sys.exit(1)

    file_name = sys.argv[1]
    opt = ['O0']  #  Keep this for consistency with the original script's file naming.

    try:
        with open(f'{file_name}_{opt[0]}.pseudo', 'r') as f:
            asm_func = f.read()
    except FileNotFoundError:
        print(f"Error: File '{file_name}_{opt[0]}.pseudo' not found.", file=sys.stderr)
        sys.exit(1)

    # Choose either streaming or non-streaming version
    # c_func_decompile = decompile_with_ollama(asm_func)
    c_func_decompile = decompile_with_ollama_streaming(asm_func)


    if c_func_decompile:
        try:
            with open(f'{file_name}_{opt[0]}.pseudo', 'r') as f:  # original file
                func = f.read()

            print(f'pseudo function:\n{func}')
            print(f'refined function:\n{c_func_decompile}')

        except FileNotFoundError:
            print(f"Error: Could not read original pseudo file (for display only).", file=sys.stderr)
            print(f'refined function:\n{c_func_decompile}') # Still print the decompiled output

    else:
        print("Decompilation failed.", file=sys.stderr)


if __name__ == "__main__":
    main()

4. License

This code repository is licensed under the MIT License.

5. Contact

If you have any questions, please raise an issue.