Calculation of immediate operand in logical immediate instructions was done wrong...
[dyninst.git] / instructionAPI / h / Operation.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(DYN_OPERATION_H)
32 #define DYN_OPERATION_H
33
34 #include "Register.h"
35 #include "Expression.h"
36 #include "entryIDs.h"
37 #include "Result.h"
38 #include <set>
39
40 #include "util.h"
41
42 // OpCode = operation + encoding
43 // contents:
44 // hex value
45 // information on how to decode operands
46 // operation encoded
47
48 // Operation = what an instruction does
49 // contents:
50 // read/write semantics on explicit operands
51 // register implicit read/write lists, including flags
52 // string/enum representation of the operation
53
54 // Use cases:
55 // OpCode + raw instruction -> Operation + ExpressionPtrs
56 // Operation + ExpressionPtrs -> Instruction + Operands
57
58 namespace NS_x86 {
59 struct ia32_entry;
60 class ia32_prefixes;
61 }
62 class ia32_locations;
63
64 namespace Dyninst
65 {
66   namespace InstructionAPI
67   {
68     /// An %Operation object represents a family of opcodes (operation encodings)
69     /// that perform the same task (e.g. the \c MOV family).  It includes
70     /// information about the number of operands, their read/write semantics,
71     /// the implicit register reads and writes, and the control flow behavior
72     /// of a particular assembly language operation.  It additionally provides
73     /// access to the assembly mnemonic, which allows any semantic details that
74     /// are not encoded in the %Instruction representation to be added by higher
75     /// layers of analysis.
76     ///
77     /// As an example, the \c CMP operation on IA32/AMD64 processors has the following
78     /// properties:
79     ///   - %Operand 1 is read, but not written
80     ///   - %Operand 2 is read, but not written
81     ///   - The following flags are written:
82     ///     - Overflow
83     ///     - Sign
84     ///     - Zero
85     ///     - Parity
86     ///     - Carry
87     ///     - Auxiliary
88     ///   - No other registers are read, and no implicit memory operations are performed
89     ///
90     /// %Operations are constructed by the %InstructionDecoder as part of the process
91     /// of constructing an %Instruction.
92     
93     class Operation
94     {
95     public:
96       typedef std::set<RegisterAST::Ptr> registerSet;
97       typedef std::set<Expression::Ptr> VCSet;
98       typedef boost::shared_ptr<Operation> Ptr;
99       friend class InstructionDecoder_power; // for editing mnemonics after creation
100       friend class InstructionDecoder_aarch64;
101       
102     public:
103       INSTRUCTION_EXPORT Operation(NS_x86::ia32_entry* e, NS_x86::ia32_prefixes* p = NULL, ia32_locations* l = NULL,
104                                   Architecture arch = Arch_none);
105       INSTRUCTION_EXPORT Operation(const Operation& o);
106       INSTRUCTION_EXPORT Operation();
107       INSTRUCTION_EXPORT Operation(entryID id, const char* mnem, Architecture arch);
108       
109       INSTRUCTION_EXPORT const Operation& operator=(const Operation& o);
110       
111       /// Returns the set of registers implicitly read (i.e. those not included in the operands, but read anyway)
112       INSTRUCTION_EXPORT const registerSet& implicitReads() const;
113       /// Returns the set of registers implicitly written (i.e. those not included in the operands, but written anyway)
114       INSTRUCTION_EXPORT const registerSet& implicitWrites() const;
115       /// Returns the mnemonic for the operation.  Like \c instruction::format, this is exposed for debugging
116       /// and will be replaced with stream operators in the public interface.
117       INSTRUCTION_EXPORT std::string format() const;
118       /// Returns the entry ID corresponding to this operation.  Entry IDs are enumerated values that correspond
119       /// to assembly mnemonics.
120       INSTRUCTION_EXPORT entryID getID() const;
121       /// Returns the prefix entry ID corresponding to this operation, if any.
122       /// Prefix IDs are enumerated values that correspond to assembly prefix mnemonics.
123       INSTRUCTION_EXPORT prefixEntryID getPrefixID() const;
124
125       /// Returns true if the expression represented by \c candidate is read implicitly.
126       INSTRUCTION_EXPORT bool isRead(Expression::Ptr candidate) const;
127       /// Returns true if the expression represented by \c candidate is written implicitly.
128       INSTRUCTION_EXPORT bool isWritten(Expression::Ptr candidate) const;
129       /// Returns the set of memory locations implicitly read.
130       INSTRUCTION_EXPORT const VCSet& getImplicitMemReads() const;
131       /// Returns the set of memory locations implicitly written.
132       INSTRUCTION_EXPORT const VCSet& getImplicitMemWrites() const;
133
134     private:
135       void SetUpNonOperandData(bool doFlags = false) const;
136       
137       mutable registerSet otherRead;
138       mutable registerSet otherWritten;
139       mutable VCSet otherEffAddrsRead;
140       mutable VCSet otherEffAddrsWritten;
141       mutable std::string mnemonic;
142       mutable entryID operationID;
143       mutable bool doneOtherSetup;
144       mutable bool doneFlagsSetup;
145       Architecture archDecodedFrom;
146       prefixEntryID prefixID;
147       Result_Type addrWidth;
148       
149     };
150   };
151 };
152
153
154 #endif //!defined(DYN_OPERATION_H)