Allow accessing StateARM64's Dyninst::Address member in RegisterStateARM64 for use...
[dyninst.git] / dataflowAPI / rose / semantics / DispatcherARM64.h
1 #ifndef ROSE_DispatcherARM64_H
2 #define ROSE_DispatcherARM64_H
3
4 #include "BaseSemantics2.h"
5 #include "../SgAsmArmv8Instruction.h"
6 #include "external/rose/armv8InstructionEnum.h"
7
8 namespace rose {
9     namespace BinaryAnalysis {
10         namespace InstructionSemantics2 {
11
12
13 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
14 //                                      Dispatcher
15 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
16
17 /** Shared-ownership pointer to an ARM instruction dispatcher. See @ref heap_object_shared_ownership. */
18             typedef boost::shared_ptr<class DispatcherARM64> DispatcherARM64Ptr;
19
20             class DispatcherARM64 : public BaseSemantics::Dispatcher {
21             protected:
22                 // Prototypical constructor
23                 DispatcherARM64()
24                         : BaseSemantics::Dispatcher(64, RegisterDictionary::dictionary_armv8()) { }
25
26                 // Prototypical constructor
27                 DispatcherARM64(size_t addrWidth, const RegisterDictionary *regs/*=NULL*/)
28                         : BaseSemantics::Dispatcher(addrWidth, regs ? regs : RegisterDictionary::dictionary_armv8()) { }
29
30                 // Normal constructor
31                 DispatcherARM64(const BaseSemantics::RiscOperatorsPtr &ops, size_t addrWidth,
32                                 const RegisterDictionary *regs)
33                         : BaseSemantics::Dispatcher(ops, addrWidth,
34                                                     regs ? regs : RegisterDictionary::dictionary_armv8()) {
35                     regcache_init();
36                     iproc_init();
37                     memory_init();
38                 }
39
40             public:
41
42                 /** Loads the iproc table with instruction processing functors. This normally happens from the constructor. */
43                 void iproc_init();
44
45                 /** Load the cached register descriptors.  This happens at construction and on set_register_dictionary() calls. */
46                 void regcache_init();
47
48                 /** Make sure memory is set up correctly. For instance, byte order should be little endian. */
49                 void memory_init();
50
51             public:
52                 /** Cached register. This register is cached so that there are not so many calls to Dispatcher::findRegister(). The
53                  *  register descriptor is updated only when the register dictionary is changed (see set_register_dictionary()).
54                  *
55                  *  Register names like REG_anyAX have sizes that depend on the architecture: 16 bits for 16-bit architectures, 32 bits for
56                  *  32-bit architectures, etc.  The other register names have specific sizes--such as REG_EAX being 32 bits--and are
57                  *  defined only on architectures that support them.
58                  *
59                  * @{ */
60
61                 RegisterDescriptor REG_PC, REG_NZCV, REG_SP;
62
63                 /** @}*/
64
65                 /** Construct a prototypical dispatcher.  The only thing this dispatcher can be used for is to create another dispatcher
66                  *  with the virtual @ref create method. */
67                 static DispatcherARM64Ptr instance() {
68                     return DispatcherARM64Ptr(new DispatcherARM64);
69                 }
70
71                 /** Construct a prototyipcal dispatcher. Construct a prototypical dispatcher with a specified address size. The only thing
72                  * this dispatcher can be used for is to create another dispatcher with the virtual @ref create method. */
73                 static DispatcherARM64Ptr instance(size_t addrWidth, const RegisterDictionary *regs = NULL) {
74                     return DispatcherARM64Ptr(new DispatcherARM64(addrWidth, regs));
75                 }
76
77                 /** Constructor. */
78                 static DispatcherARM64Ptr instance(const BaseSemantics::RiscOperatorsPtr &ops, size_t addrWidth,
79                                                    const RegisterDictionary *regs = NULL) {
80                     return DispatcherARM64Ptr(new DispatcherARM64(ops, addrWidth, regs));
81                 }
82
83                 /** Virtual constructor. */
84                 virtual BaseSemantics::DispatcherPtr create(const BaseSemantics::RiscOperatorsPtr &ops,
85                                                             size_t addrWidth = 0,
86                                                             const RegisterDictionary *regs = NULL) const {
87                     if (0 == addrWidth) {
88                         //TODO
89                         //addressWidth(64);
90                         addrWidth = 64;//addressWidth();
91                     }
92
93                     return instance(ops, addrWidth, regs);
94                 }
95
96                 /** Dynamic cast to a DispatcherARM64Ptr with assertion. */
97                 static DispatcherARM64Ptr promote(const BaseSemantics::DispatcherPtr &d) {
98                     DispatcherARM64Ptr retval = boost::dynamic_pointer_cast<DispatcherARM64>(d);
99                     assert(retval != NULL);
100                     return retval;
101                 }
102
103                 virtual void set_register_dictionary(const RegisterDictionary *regdict);
104
105                 /** Get list of common registers. Returns a list of non-overlapping registers composed of the largest registers except
106                  *  using individual flags for the fields of the FLAGS/EFLAGS register. */
107                 virtual RegisterDictionary::RegisterDescriptors get_usual_registers() const;
108
109                 virtual RegisterDescriptor instructionPointerRegister() const;
110
111                 virtual RegisterDescriptor stackPointerRegister() const;
112
113                 virtual int iproc_key(SgAsmInstruction *insn_) const {
114                     SgAsmArmv8Instruction *insn = isSgAsmArmv8Instruction(insn_);
115                     assert(insn != NULL);
116                     return insn->get_kind();
117                 }
118
119                 virtual void write(SgAsmExpression *e, const BaseSemantics::SValuePtr &value, size_t addr_nbits = 0);
120
121                 /** Architecture-specific read from register.
122                  *
123                  *  Similar to RiscOperators::readRegister, but might do additional architecture-specific things. */
124                 virtual BaseSemantics::SValuePtr readRegister(const RegisterDescriptor &);
125
126                 /** Architecture-specific write to register.
127                  *
128                  *  Similar to RiscOperators::writeRegister, but might do additional architecture-specific things. For instance, writing to
129                  *  a 32-bit GPR such as "eax" on x86-64 will write zeros to the upper half of "rax". */
130                 virtual void writeRegister(const RegisterDescriptor &, const BaseSemantics::SValuePtr &result);
131
132                 /** Set parity, sign, and zero flags appropriate for result value. */
133                 virtual void setFlagsForResult(const BaseSemantics::SValuePtr &result,
134                                                const BaseSemantics::SValuePtr &carries,
135                                                bool invertCarries, size_t nbits, BaseSemantics::SValuePtr &nzcv);
136
137                 /** Returns true if byte @p v has an even number of bits set; false for an odd number */
138                 virtual BaseSemantics::SValuePtr parity(const BaseSemantics::SValuePtr &v);
139
140                 /** Conditionally invert the bits of @p value.  The bits are inverted if @p maybe is true, otherwise @p value is returned. */
141                 virtual BaseSemantics::SValuePtr invertMaybe(const BaseSemantics::SValuePtr &value, bool maybe);
142
143                 /** Adds two values and adjusts flags.  This method can be used for subtraction if @p b is two's complement and @p
144                  *  invertCarries is set.  If @p cond is supplied, then the addition and flag adjustments are conditional.
145                  * @{ */
146                 virtual BaseSemantics::SValuePtr doAddOperation(BaseSemantics::SValuePtr a, BaseSemantics::SValuePtr b,
147                                                                 bool invertCarries,
148                                                                 const BaseSemantics::SValuePtr &carryIn, BaseSemantics::SValuePtr &nzcv);
149
150                 //FIXME
151                 /** Implements the RCL, RCR, ROL, and ROR instructions for various operand sizes.  The rotate amount is always 8 bits wide
152                  * in the instruction, but the semantics mask off all but the low-order bits, keeping 5 bits in 32-bit mode and 6 bits in
153                  * 64-bit mode (indicated by the rotateSignificantBits argument). */
154                 /*virtual BaseSemantics::SValuePtr doRotateOperation(ARMv8InstructionKind kind,
155                                                                    const BaseSemantics::SValuePtr &operand,
156                                                                    const BaseSemantics::SValuePtr &total_rotate,
157                                                                    size_t rotateSignificantBits);*/
158
159                 //FIXME
160                 /** Implements the SHR, SAR, SHL, SAL, SHRD, and SHLD instructions for various operand sizes.  The shift amount is always 8
161                  *  bits wide in the instruction, but the semantics mask off all but the low-order bits, keeping 5 bits in 32-bit mode and
162                  *  7 bits in 64-bit mode (indicated by the @p shiftSignificantBits argument).  The semantics of SHL and SAL are
163                  *  identical (in fact, ROSE doesn't even define x86_sal). The @p source_bits argument contains the bits to be shifted into
164                  *  the result and is used only for SHRD and SHLD instructions. */
165                 /*virtual BaseSemantics::SValuePtr doShiftOperation(ARMv8InstructionKind kind,
166                                                                   const BaseSemantics::SValuePtr &operand,
167                                                                   const BaseSemantics::SValuePtr &source_bits,
168                                                                   const BaseSemantics::SValuePtr &total_shift,
169                                                                   size_t shiftSignificantBits);*/
170
171                 /** Extend or truncate value to propert memory address width. */
172                 virtual BaseSemantics::SValuePtr fixMemoryAddress(const BaseSemantics::SValuePtr &address) const;
173
174                 /** Checks if the supplied value is or isn't equal to zero */
175                 virtual BaseSemantics::SValuePtr isZero(const BaseSemantics::SValuePtr &value);
176
177                 virtual BaseSemantics::SValuePtr ConditionHolds(const BaseSemantics::SValuePtr &cond);
178
179                 /** Inverts the passed in expression and returns the result */
180                 virtual BaseSemantics::SValuePtr NOT(const BaseSemantics::SValuePtr &expr);
181
182                 /** Execute a branch -- equivalent to writing the target address value to the PC */
183                 virtual void BranchTo(const BaseSemantics::SValuePtr &target);
184
185                 /** Returns a value that equals 0. nbits specifies what should be the bit-length of the value,
186                  * but is irrelevant in practice as a 64-bit zero is returned anyway. */
187                 virtual BaseSemantics::SValuePtr Zeros(const unsigned int nbits);
188             };
189
190 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
191 //                                      Instruction processors
192 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
193
194             namespace ARM64 {
195
196 /** Base class for all x86 instruction processors.
197  *
198  *  This class provides single-letter names for some types that are used in all instructions: D, I, A, and Ops for the
199  *  dispatcher raw pointer, instruction pointer, argument list pointer, and RISC operators raw pointer.  It also takes care
200  *  of advancing the instruction pointer prior to handing the instruction to the subclass, which by the way is done via
201  *  @ref p method (short for "process").  See examples in DispatcherX86.C -- there are <em>lots</em> of them. */
202                 class InsnProcessor : public BaseSemantics::InsnProcessor {
203                 public:
204                     typedef DispatcherARM64 *D;
205                     typedef BaseSemantics::RiscOperators *Ops;
206                     typedef SgAsmArmv8Instruction *I;
207                     typedef const SgAsmExpressionPtrList &A;
208                     typedef uint32_t B;
209
210                     virtual void p(D, Ops, I, A, B) = 0;
211
212                     virtual void process(const BaseSemantics::DispatcherPtr &, SgAsmInstruction *);
213
214                     virtual void assert_args(I insn, A args, size_t nargs);
215                     //void check_arg_width(D d, I insn, A args);
216                 };
217
218             } // namespace
219
220         } // namespace
221     } // namespace
222 } // namespace
223
224 #endif