Update copyright to LGPL on all files
[dyninst.git] / instructionAPI / h / Operation.h
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #if !defined(DYN_OPERATION_H)
33 #define DYN_OPERATION_H
34
35 #include "Register.h"
36 #include "Expression.h"
37 #include "entryIDs-IA32.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 struct ia32_entry;
58 class ia32_prefixes;
59 struct ia32_locations;
60
61 namespace Dyninst
62 {
63   namespace InstructionAPI
64   {
65     /// An %Operation object represents a family of opcodes (operation encodings)
66     /// that perform the same task (e.g. the \c MOV family).  It includes
67     /// information about the number of operands, their read/write semantics,
68     /// the implicit register reads and writes, and the control flow behavior
69     /// of a particular assembly language operation.  It additionally provides
70     /// access to the assembly mnemonic, which allows any semantic details that
71     /// are not encoded in the %Instruction representation to be added by higher
72     /// layers of analysis.
73     ///
74     /// As an example, the \c CMP operation on IA32/AMD64 processors has the following
75     /// properties:
76     ///   - %Operand 1 is read, but not written
77     ///   - %Operand 2 is read, but not written
78     ///   - The following flags are written:
79     ///     - Overflow
80     ///     - Sign
81     ///     - Zero
82     ///     - Parity
83     ///     - Carry
84     ///     - Auxiliary
85     ///   - No other registers are read, and no implicit memory operations are performed
86     ///
87     /// %Operations are constructed by the %InstructionDecoder as part of the process
88     /// of constructing an %Instruction.
89     
90     class Operation
91     {
92     public:
93       typedef std::set<RegisterAST::Ptr> registerSet;
94       typedef std::set<Expression::Ptr> VCSet;
95       typedef dyn_detail::boost::shared_ptr<Operation> Ptr;
96       
97     public:
98       INSTRUCTION_EXPORT Operation(ia32_entry* e, ia32_prefixes* p = NULL, ia32_locations* l = NULL);
99       INSTRUCTION_EXPORT Operation(const Operation& o);
100       INSTRUCTION_EXPORT Operation();
101       
102       INSTRUCTION_EXPORT const Operation& operator=(const Operation& o);
103       
104       /// Returns the set of registers implicitly read (i.e. those not included in the operands, but read anyway)
105       INSTRUCTION_EXPORT const registerSet& implicitReads() const;
106       /// Returns the set of registers implicitly written (i.e. those not included in the operands, but written anyway)
107       INSTRUCTION_EXPORT const registerSet& implicitWrites() const;
108       /// Returns the mnemonic for the operation.  Like \c instruction::format, this is exposed for debugging
109       /// and will be replaced with stream operators in the public interface.
110       INSTRUCTION_EXPORT std::string format() const;
111       /// Returns the entry ID corresponding to this operation.  Entry IDs are enumerated values that correspond
112       /// to assembly mnemonics.
113       INSTRUCTION_EXPORT entryID getID() const;
114
115       INSTRUCTION_EXPORT bool isRead(Expression::Ptr candidate) const;
116       INSTRUCTION_EXPORT bool isWritten(Expression::Ptr candidate) const;
117       INSTRUCTION_EXPORT const VCSet& getImplicitMemReads() const;
118       INSTRUCTION_EXPORT const VCSet& getImplicitMemWrites() const;
119
120     private:
121       void SetUpNonOperandData(bool doFlags = false) const;
122       
123       mutable registerSet otherRead;
124       mutable registerSet otherWritten;
125       mutable VCSet otherEffAddrsRead;
126       mutable VCSet otherEffAddrsWritten;
127       entryID operationID;
128       mutable bool doneOtherSetup;
129       mutable bool doneFlagsSetup;
130       
131     };
132   };
133 };
134
135
136 #endif //!defined(DYN_OPERATION_H)