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 c_byte
14 from ctypes import c_char_p
15 from ctypes import c_int
16 from ctypes import c_size_t
17 from ctypes import c_ubyte
18 from ctypes import c_uint64
19 from ctypes import c_void_p
20 from ctypes import cast
22 from .common import LLVMObject
23 from .common import c_object_p
24 from .common import get_library
33 # Constants for set_options
39 _targets = ['AArch64', 'ARM', 'Hexagon', 'MSP430', 'Mips', 'NVPTX', 'PowerPC', 'R600', 'Sparc', 'SystemZ', 'X86', 'XCore']
40 def _ensure_initialized():
43 # Here one would want to call the functions
44 # LLVMInitializeAll{TargetInfo,TargetMC,Disassembler}s, but
45 # unfortunately they are only defined as static inline
46 # functions in the header files of llvm-c, so they don't exist
47 # as symbols in the shared library.
48 # So until that is fixed use this hack to initialize them all
50 for initializer in ("TargetInfo", "TargetMC", "Disassembler"):
52 f = getattr(lib, "LLVMInitialize" + tgt + initializer)
53 except AttributeError:
59 class Disassembler(LLVMObject):
60 """Represents a disassembler instance.
62 Disassembler instances are tied to specific "triple," which must be defined
65 Disassembler instances can disassemble instructions from multiple sources.
67 def __init__(self, triple):
68 """Create a new disassembler instance.
70 The triple argument is the triple to create the disassembler for. This
71 is something like 'i386-apple-darwin9'.
76 ptr = lib.LLVMCreateDisasm(c_char_p(triple), c_void_p(None), c_int(0),
77 callbacks['op_info'](0), callbacks['symbol_lookup'](0))
79 raise Exception('Could not obtain disassembler for triple: %s' %
82 LLVMObject.__init__(self, ptr, disposer=lib.LLVMDisasmDispose)
84 def get_instruction(self, source, pc=0):
85 """Obtain the next instruction from an input source.
87 The input source should be a str or bytearray or something that
88 represents a sequence of bytes.
90 This function will start reading bytes from the beginning of the
93 The pc argument specifies the address that the first byte is at.
95 This returns a 2-tuple of:
97 long number of bytes read. 0 if no instruction was read.
98 str representation of instruction. This will be the assembly that
99 represents the instruction.
101 buf = cast(c_char_p(source), POINTER(c_ubyte))
102 out_str = cast((c_byte * 255)(), c_char_p)
104 result = lib.LLVMDisasmInstruction(self, buf, c_uint64(len(source)),
105 c_uint64(pc), out_str, 255)
107 return (result, out_str.value)
109 def get_instructions(self, source, pc=0):
110 """Obtain multiple instructions from an input source.
112 This is like get_instruction() except it is a generator for all
113 instructions within the source. It starts at the beginning of the
114 source and reads instructions until no more can be read.
116 This generator returns 3-tuple of:
118 long address of instruction.
119 long size of instruction, in bytes.
120 str representation of instruction.
122 source_bytes = c_char_p(source)
123 out_str = cast((c_byte * 255)(), c_char_p)
125 # This could probably be written cleaner. But, it does work.
126 buf = cast(source_bytes, POINTER(c_ubyte * len(source))).contents
129 end_address = pc + len(source)
130 while address < end_address:
131 b = cast(addressof(buf) + offset, POINTER(c_ubyte))
132 result = lib.LLVMDisasmInstruction(self, b,
133 c_uint64(len(source) - offset), c_uint64(address),
139 yield (address, result, out_str.value)
144 def set_options(self, options):
145 if not lib.LLVMSetDisasmOptions(self, options):
146 raise Exception('Unable to set all disassembler options in %i' % options)
149 def register_library(library):
150 library.LLVMCreateDisasm.argtypes = [c_char_p, c_void_p, c_int,
151 callbacks['op_info'], callbacks['symbol_lookup']]
152 library.LLVMCreateDisasm.restype = c_object_p
154 library.LLVMDisasmDispose.argtypes = [Disassembler]
156 library.LLVMDisasmInstruction.argtypes = [Disassembler, POINTER(c_ubyte),
157 c_uint64, c_uint64, c_char_p, c_size_t]
158 library.LLVMDisasmInstruction.restype = c_size_t
160 library.LLVMSetDisasmOptions.argtypes = [Disassembler, c_uint64]
161 library.LLVMSetDisasmOptions.restype = c_int
164 callbacks['op_info'] = CFUNCTYPE(c_int, c_void_p, c_uint64, c_uint64, c_uint64,
166 callbacks['symbol_lookup'] = CFUNCTYPE(c_char_p, c_void_p, c_uint64,
167 POINTER(c_uint64), c_uint64,
170 register_library(lib)