1 #===- disassembler.py - Python LLVM Bindings -----------------*- python -*--===#
3 # The LLVM Compiler Infrastructure
5 # This file is distributed under the University of Illinois Open Source
6 # License. See LICENSE.TXT for details.
8 #===------------------------------------------------------------------------===#
10 from ctypes import CFUNCTYPE
11 from ctypes import POINTER
12 from ctypes import addressof
13 from ctypes import byref
14 from ctypes import c_byte
15 from ctypes import c_char_p
16 from ctypes import c_int
17 from ctypes import c_size_t
18 from ctypes import c_ubyte
19 from ctypes import c_uint64
20 from ctypes import c_void_p
21 from ctypes import cast
23 from .common import LLVMObject
24 from .common import c_object_p
25 from .common import get_library
34 # Constants for set_options
37 class Disassembler(LLVMObject):
38 """Represents a disassembler instance.
40 Disassembler instances are tied to specific "triple," which must be defined
43 Disassembler instances can disassemble instructions from multiple sources.
45 def __init__(self, triple):
46 """Create a new disassembler instance.
48 The triple argument is the triple to create the disassembler for. This
49 is something like 'i386-apple-darwin9'.
51 ptr = lib.LLVMCreateDisasm(c_char_p(triple), c_void_p(None), c_int(0),
52 callbacks['op_info'](0), callbacks['symbol_lookup'](0))
54 raise Exception('Could not obtain disassembler for triple: %s' %
57 LLVMObject.__init__(self, ptr, disposer=lib.LLVMDisasmDispose)
59 def get_instruction(self, source, pc=0):
60 """Obtain the next instruction from an input source.
62 The input source should be a str or bytearray or something that
63 represents a sequence of bytes.
65 This function will start reading bytes from the beginning of the
68 The pc argument specifies the address that the first byte is at.
70 This returns a 2-tuple of:
72 long number of bytes read. 0 if no instruction was read.
73 str representation of instruction. This will be the assembly that
74 represents the instruction.
76 buf = cast(c_char_p(source), POINTER(c_ubyte))
77 out_str = cast((c_byte * 255)(), c_char_p)
79 result = lib.LLVMDisasmInstruction(self, buf, c_uint64(len(source)),
80 c_uint64(pc), out_str, 255)
82 return (result, out_str.value)
84 def get_instructions(self, source, pc=0):
85 """Obtain multiple instructions from an input source.
87 This is like get_instruction() except it is a generator for all
88 instructions within the source. It starts at the beginning of the
89 source and reads instructions until no more can be read.
91 This generator returns 3-tuple of:
93 long address of instruction.
94 long size of instruction, in bytes.
95 str representation of instruction.
97 source_bytes = c_char_p(source)
98 out_str = cast((c_byte * 255)(), c_char_p)
100 # This could probably be written cleaner. But, it does work.
101 buf = cast(source_bytes, POINTER(c_ubyte * len(source))).contents
104 end_address = pc + len(source)
105 while address < end_address:
106 b = cast(addressof(buf) + offset, POINTER(c_ubyte))
107 result = lib.LLVMDisasmInstruction(self, b,
108 c_uint64(len(source) - offset), c_uint64(address),
114 yield (address, result, out_str.value)
119 def set_options(self, options):
120 if not lib.LLVMSetDisasmOptions(self, options):
121 raise Exception('Unable to set all disassembler options in %i' % options)
124 def register_library(library):
125 library.LLVMCreateDisasm.argtypes = [c_char_p, c_void_p, c_int,
126 callbacks['op_info'], callbacks['symbol_lookup']]
127 library.LLVMCreateDisasm.restype = c_object_p
129 library.LLVMDisasmDispose.argtypes = [Disassembler]
131 library.LLVMDisasmInstruction.argtypes = [Disassembler, POINTER(c_ubyte),
132 c_uint64, c_uint64, c_char_p, c_size_t]
133 library.LLVMDisasmInstruction.restype = c_size_t
135 library.LLVMSetDisasmOptions.argtypes = [Disassembler, c_uint64]
136 library.LLVMSetDisasmOptions.restype = c_int
139 callbacks['op_info'] = CFUNCTYPE(c_int, c_void_p, c_uint64, c_uint64, c_uint64,
141 callbacks['symbol_lookup'] = CFUNCTYPE(c_char_p, c_void_p, c_uint64,
142 POINTER(c_uint64), c_uint64,
145 register_library(lib)