Update README.md

README.md

@@ -13,70 +13,79 @@ LLM4Decompile aims to decompile x86 assembly instructions into C. It is finetune
 
 
 ### 2. Evaluation Results
-| Model              | Re-compilability |           |           |           |           | Re-executability |           |           |           |           |
-|--------------------|:----------------:|:---------:|:---------:|:---------:|:---------:|:----------------:|-----------|-----------|-----------|:---------:|
-| Optimization-level          | O0               | O1        | O2        | O3        | Avg.      | O0               | O1        | O2        | O3        | Avg.      |
-| GPT4               | 0.92             | 0.94      | 0.88      | 0.84      | 0.895     | 0.1341           | 0.1890    | 0.1524    | 0.0854    | 0.1402    |
-| DeepSeek-Coder-33B |   0.0659         |   0.0866  |   0.1500  |   0.1463  |   0.1122  |   0.0000         |   0.0000  |   0.0000  |   0.0000  |   0.0000  |
-| LLM4Decompile-1b   |   0.8780         |   0.8732  |   0.8683  |   0.8378  |   0.8643  |   0.1573         |   0.0768  |   0.1000  |   0.0878  |   0.1055  |
-| LLM4Decompile-6b   |   0.8817         |   0.8951  |   0.8671  |   0.8476  |   0.8729  |   0.3000         |   0.1732  |   0.1988  |   0.1841  |   0.2140  |
-| LLM4Decompile-33b  |   0.8134         |   0.8195  |   0.8183  |   0.8305  |   0.8204  |   0.3049         |   0.1902  |   0.1817  |   0.1817  |   0.2146  |
-
 
+|          Model          | HumanEval-Decompile |        |        |        |        | ExeBench |        |        |        |        |
+|:-----------------------:|:-------------------:|:------:|:------:|:------:|:------:|:--------:|:------:|:------:|:------:|:------:|
+|        opt-level        |          O0         |   O1   |   O2   |   O3   |  Avg.  |    O0    |   O1   |   O2   |   O3   |  Avg.  |
+|           GPT4          |        0.1341       | 0.1890 | 0.1524 | 0.0854 | 0.1402 |    TBD   |   TBD  |   TBD  |   TBD  |   TBD  |
+|    Deepseek-Coder-33B   |          0          |    0   |    0   |    0   |    0   |     0    |    0   |    0   |    0   |    0   |
+|  LLM4Decompile-6.7B-UO  |        0.3720       | 0.1585 | 0.2134 | 0.2134 | 0.2393 |  0.0904  | 0.0988 | 0.0988 | 0.0950 | 0.0957 |
+| LLM4Decompile-1.3B-V1.5 |        0.4817       | 0.2463 | 0.2329 | 0.2280 | 0.2972 |  0.2076  | 0.1774 | 0.1721 | 0.1728 | 0.1824 |
+| LLM4Decompile-6.7B-V1.5 |        0.6927       | 0.4280 | 0.4134 | 0.3732 | 0.4768 |  0.2453  | 0.1999 | 0.1927 | 0.1938 | 0.2079 |
 
 ### 3. How to Use
-Here give an example of how to use our model.
-First compile the C code into binary, disassemble the binary into assembly instructions:
+Here is an example of how to use our model (Revised for V1.5).
+Note: **Replace** func0 with the function name you want to decompile.
+
+**Preprocessing:** Compile the C code into binary, and disassemble the binary into assembly instructions.
 ```python
 import subprocess
 import os
-import re
 
-digit_pattern = r'\b0x[a-fA-F0-9]+\b'#  binary codes in Hexadecimal
-zeros_pattern = r'^0+\s'#0s
 OPT = ["O0", "O1", "O2", "O3"]
-before = f"# This is the assembly code with {opt_state} optimization:\n"
-after = "\n# What is the source code?\n"
-fileName = 'path/to/file'
-with open(fileName+'.c','r') as f:#original file
-    c_func = f.read()
+fileName = 'samples/sample' #'path/to/file'
 for opt_state in OPT:
     output_file = fileName +'_' + opt_state
     input_file = fileName+'.c'
-    compile_command = f'gcc -c -o {output_file}.o {input_file} -{opt_state} -lm'#compile the code with GCC on Linux
+    compile_command = f'gcc -o {output_file}.o {input_file} -{opt_state} -lm'#compile the code with GCC on Linux
     subprocess.run(compile_command, shell=True, check=True)
     compile_command = f'objdump -d {output_file}.o > {output_file}.s'#disassemble the binary file into assembly instructions
     subprocess.run(compile_command, shell=True, check=True)
     
     input_asm = ''
-    asm = read_file(output_file+'.s')
-    asm = asm.split('Disassembly of section .text:')[-1].strip()
-    for tmp in asm.split('\n'):
-        tmp_asm = tmp.split('\t')[-1]#remove the binary code
-        tmp_asm = tmp_asm.split('#')[0].strip()#remove the comments
-        input_asm+=tmp_asm+'\n'
-    input_asm = re.sub(zeros_pattern, '', input_asm)
-    
+    with open(output_file+'.s') as f:#asm file
+        asm= f.read()
+        if '<'+'func0'+'>:' not in asm: #IMPORTANT replace func0 with the function name
+            raise ValueError("compile fails")
+        asm = '<'+'func0'+'>:' + asm.split('<'+'func0'+'>:')[-1].split('\n\n')[0] #IMPORTANT replace func0 with the function name
+        asm_clean = ""
+        asm_sp = asm.split("\n")
+        for tmp in asm_sp:
+            idx = min(
+                len(tmp.split("\t")) - 1, 2
+            )
+            tmp_asm = "\t".join(tmp.split("\t")[idx:])  # remove the binary code
+            tmp_asm = tmp_asm.split("#")[0].strip()  # remove the comments
+            asm_clean += tmp_asm + "\n"
+    input_asm = asm_clean.strip()
+    before = f"# This is the assembly code:\n"#prompt
+    after = "\n# What is the source code?\n"#prompt
     input_asm_prompt = before+input_asm.strip()+after
     with open(fileName +'_' + opt_state +'.asm','w',encoding='utf-8') as f:
         f.write(input_asm_prompt)
 ```
 
-Then use LLM4Decompile to translate the assembly instructions into C:
+**Decompilation:** Use LLM4Decompile to translate the assembly instructions into C:
 ```python
 from transformers import AutoTokenizer, AutoModelForCausalLM
 import torch
 
-model_path = 'arise-sustech/llm4decompile-1.3b'
+model_path = 'LLM4Binary/llm4decompile-6.7b-v1.5' # V1.5 Model
 tokenizer = AutoTokenizer.from_pretrained(model_path)
 model = AutoModelForCausalLM.from_pretrained(model_path,torch_dtype=torch.bfloat16).cuda()
 
-with open(fileName +'_' + opt_state +'.asm','r') as f:#original file
+with open(fileName +'_' + OPT[0] +'.asm','r') as f:#optimization level O0
     asm_func = f.read()
 inputs = tokenizer(asm_func, return_tensors="pt").to(model.device)
-    with torch.no_grad():
-        outputs = model.generate(**inputs, max_new_tokens=512)
+with torch.no_grad():
+    outputs = model.generate(**inputs, max_new_tokens=4000)
 c_func_decompile = tokenizer.decode(outputs[0][len(inputs[0]):-1])
+
+with open(fileName +'.c','r') as f:#original file
+    func = f.read()
+
+print(f'original function:\n{func}')# Note we only decompile one function, where the original file may contain multiple functions
+print(f'decompiled function:\n{c_func_decompile}')
 ```
 
 ### 4. License