Fix vpadd decoding. Clean up control flow target logic and shared pointer constructio...
[dyninst.git] / instructionAPI / doc / 1-Intro.tex
1 \section{Introduction}
2 \label{sec:intro}
3
4 When analyzing and modifying binary code, it is necessary to translate between
5 raw binary instructions and an abstract form that describes the semantics of the
6 instructions. As a part of the Dyninst project, we have developed the
7 Instruction API, an API and library for decoding and representing machine
8 instructions in a platform-\/independent manner. The Instruction API includes
9 methods for decoding machine language, convenient abstractions for its analysis,
10 and methods to produce disassembly from those abstractions. The current
11 implementation supports the x86, x86-64, PowerPC-32, and PowerPC-64 instruction sets.
12 The Instruction API has the following basic capabilities:
13
14 \begin{itemize}
15 \item Decoding: interpreting a sequence of bytes as a machine instruction in a given machine language.
16 \item Abstract representation: representing the behavior of that instruction as an abstract syntax tree.
17 \item Disassembly: translating an abstract representation of a machine instruction into a string representation of the corresponding assembly language instruction.
18 \end{itemize}
19
20 Our goal in designing the Instruction API is to provide a representation of
21 machine instructions that can be manipulated by higher-\/level algorithms with
22 minimal knowledge of platform-\/specific details. In addition, users who need
23 platform-\/specific information should be able to access it. To do so, we
24 provide an interface that disassembles a machine instruction, extracts an
25 operation and its operands, converts the operands to abstract syntax trees, and
26 presents this to the user. A user of the Instruction API can work at a level of
27 abstraction slightly higher than assembly language, rather than working directly
28 with machine language. Additionally, by converting the operands to abstract
29 syntax trees, we make it possible to analyze the operands in a uniform manner,
30 regardless of the complexity involved in the operand's actual computation.