Calculation of immediate operand in logical immediate instructions was done wrong...
[dyninst.git] / instructionAPI / h / InstructionDecoder.h
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  *
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  *
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  *
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  *
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  *
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #if !defined(INSTRUCTION_DECODER_H)
32 #define INSTRUCTION_DECODER_H
33
34 #include "Instruction.h"
35
36 #if defined(_MSC_VER)
37 #pragma warning(disable:4251)
38 #endif
39
40 namespace Dyninst
41 {
42   namespace InstructionAPI
43   {
44     /// The %InstructionDecoder class decodes instructions, given a buffer of bytes and a length, and
45     /// the architecture for which to decode instructions,
46     /// and constructs shared pointers to %Instruction objects representing those instructions.
47     /// %InstructionDecoder objects are given a buffer from which to decode at construction.
48     /// Calls to \c decode will proceed to decode instructions sequentially from that buffer until its
49     /// end is reached.  At that point, all subsequent calls to \c decode will return a null %Instruction pointer.
50     ///
51       class InstructionDecoderImpl;
52
53     class INSTRUCTION_EXPORT InstructionDecoder
54     {
55       friend class Instruction;
56         public:
57         static const unsigned int maxInstructionLength = 16;
58       /// Construct an %InstructionDecoder object that decodes \c arch from \c buffer, up to \c size bytes.
59       /// Valid values for \c arch are \c Arch_x86, \c Arch_x86_64, \c Arch_ppc32, and \c Arch_ppc64.
60       InstructionDecoder(const unsigned char* buffer, size_t size, Architecture arch);
61       InstructionDecoder(const void* buffer, size_t size, Architecture arch);
62
63       ~InstructionDecoder();
64       InstructionDecoder(const InstructionDecoder& o);
65       /// Decode the current instruction in this %InstructionDecoder object's buffer, interpreting it as
66       /// machine language of the type understood by this %InstructionDecoder.
67       /// If the buffer does not contain a valid instruction stream, a null %Instruction pointer
68       /// will be returned.  The %Instruction's \c size field will contain the size of the instruction decoded.
69       Instruction::Ptr decode();
70       /// Decode the instruction at \c buffer, interpreting it as machine language of the type
71       /// understood by this %InstructionDecoder.  If the buffer does not contain a valid instruction stream,
72       /// a null %Instruction pointer will be returned.  The %Instruction's \c size field will contain
73       /// the size of the instruction decoded.
74       Instruction::Ptr decode(const unsigned char* buffer);
75       void doDelayedDecode(const Instruction* insn_to_complete);
76       struct INSTRUCTION_EXPORT buffer
77       {
78           const unsigned char* start;
79           const unsigned char* end;
80           buffer(const unsigned char* b, unsigned int len) :
81                   start(b), end(b+len) {}
82           buffer(const void* b, unsigned int len) :
83         start(reinterpret_cast<const unsigned char*>(b)), end(start+len) {}
84           buffer(const unsigned char* b, const unsigned char* e) :
85                   start(b), end(e) {}
86       };
87
88         private:
89             buffer m_buf;
90       boost::shared_ptr<InstructionDecoderImpl> m_Impl;
91     };
92
93   };
94 };
95
96 #endif //!defined(INSTRUCTION_DECODER_H)