Calculation of immediate operand in logical immediate instructions was done wrong...
[dyninst.git] / instructionAPI / h / InstructionAST.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(INSTRUCTIONAST_H)
32 #define INSTRUCTIONAST_H
33
34 #if defined(_MSC_VER)
35 // Exported class inheriting from non-exported class.  This is by design; don't
36 // use the shared_from_this externally!
37 #pragma warning(disable:4251)
38 #endif
39
40 #include "util.h"
41 #include <vector>
42 #include <set>
43 #include <iostream>
44 #include "Result.h"
45 #include "boost/enable_shared_from_this.hpp"
46
47 namespace Dyninst
48 {
49   namespace InstructionAPI
50   {
51   
52     class InstructionAST;
53   
54     using std::vector;
55     using std::set;
56     enum formatStyle
57     {
58         defaultStyle,
59         memoryAccessStyle
60     };
61     /// The %InstructionAST class is the base class for all nodes in the ASTs used by the %Operand class.
62     /// It defines the necessary interfaces for traversing and searching
63     /// an abstract syntax tree representing an operand.
64     /// For the purposes of searching an %InstructionAST, we provide two related interfaces.  The first,
65     /// \c getUses, will return the registers that appear in a given tree.  The second, \c isUsed, will
66     /// take as input another tree and return true if that tree is a (not necessarily proper) subtree of this one.
67     /// \c isUsed requires us to define an equality relation on these abstract
68     /// syntax trees, and the equality operator is provided by the %InstructionAST, with the details
69     /// implemented by the classes derived from %InstructionAST.  Two AST nodes are equal if the following conditions hold:
70     /// - They are of the same type
71     /// - If leaf nodes, they represent the same immediate value or the same register
72     /// - If non-leaf nodes, they represent the same operation and their corresponding children are equal
73     class INSTRUCTION_EXPORT InstructionAST : public boost::enable_shared_from_this<InstructionAST>
74     {
75     public:
76       typedef boost::shared_ptr<InstructionAST> Ptr;
77
78       InstructionAST();
79       virtual ~InstructionAST();
80
81       /// Compare two AST nodes for equality.  
82       ///
83       /// Non-leaf nodes are equal
84       /// if they are of the same type and their children are equal.  %RegisterASTs
85       /// are equal if they represent the same register.  %Immediates are equal if they
86       /// represent the same value.
87       bool operator==(const InstructionAST& rhs) const;
88
89       /// Children of this node are appended to the vector \c children
90       virtual void getChildren(vector<InstructionAST::Ptr>& children) const = 0;
91
92       /// \param uses The use set of this node is appended to the vector \c uses
93       ///
94       /// The use set of an %InstructionAST is defined as follows:
95       ///   - A %RegisterAST uses itself
96       ///   - A %BinaryFunction uses the use sets of its children
97       ///   - An %Immediate uses nothing
98       ///   - A %Dereference uses the use set of its child
99       virtual void getUses(set<InstructionAST::Ptr>& uses) = 0;
100
101       /// \return True if \c findMe is used by this AST node.
102       /// \param findMe AST node to find in the use set of this node
103       ///
104       /// Unlike \c getUses, \c isUsed looks for \c findMe as a subtree
105       /// of the current tree.  \c getUses is designed to return a minimal
106       /// set of registers used in this tree, whereas \c isUsed is designed
107       /// to allow searches for arbitrary subexpressions
108       virtual bool isUsed(InstructionAST::Ptr findMe) const = 0;
109
110       /// The \c format interface returns the contents of an %InstructionAST
111       /// object as a string.  By default, \c format() produces assembly language.
112       virtual std::string format(formatStyle how = defaultStyle) const = 0;
113   
114     protected:
115       friend class RegisterAST;
116       friend class Immediate;
117       virtual bool isStrictEqual(const InstructionAST& rhs) const= 0;
118       virtual bool checkRegID(MachRegister, unsigned int = 0, unsigned int = 0) const;
119       virtual const Result& eval() const = 0;
120     };
121   };
122 };
123 #if defined(_MSC_VER)
124 // reenable warning
125 #pragma warning(default:4251)
126 #endif
127
128
129 #endif //!defined(INSTRUCTIONAST_H)