rebased to master after sw 3rd party completed
[dyninst.git] / parseAPI / src / IA_aarch64.C
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 #include "IA_IAPI.h"
32 #include "IA_aarch64.h"
33
34 #include "Register.h"
35 #include "Dereference.h"
36 #include "Immediate.h"
37 #include "BinaryFunction.h"
38
39 #include "common/src/arch.h"
40
41 #include "parseAPI/src/debug_parse.h"
42
43 #include <deque>
44 #include <iostream>
45 #include <sstream>
46 #include <functional>
47 #include <algorithm>
48 #include <set>
49
50 using namespace Dyninst;
51 using namespace InstructionAPI;
52 using namespace Dyninst::ParseAPI;
53 using namespace Dyninst::InsnAdapter;
54
55 //#warning "The reg defines are not correct now!"
56 static RegisterAST::Ptr aarch64_R11 (new RegisterAST (aarch64::x11));
57 static RegisterAST::Ptr aarch64_LR  (new RegisterAST (aarch64::x30));
58 //SP is an independent reg in aarch64
59 static RegisterAST::Ptr aarch64_SP  (new RegisterAST (aarch64::x0));
60
61 bool IA_IAPI::isFrameSetupInsn(Instruction::Ptr) const
62 {
63         assert(0);
64     return false;
65 }
66
67 bool IA_IAPI::isNop() const
68 {
69         assert(0);
70     return false;
71 }
72
73 bool IA_IAPI::isThunk() const {
74         assert(0);
75     return false;
76 }
77
78 bool IA_IAPI::isTailCall(Function* context, EdgeTypeEnum type, unsigned int,
79         const std::set<Address>& ) const
80 {
81         assert(0);
82     return false;
83 }
84
85 bool IA_IAPI::savesFP() const
86 {
87         assert(0);
88     return false;
89 }
90
91 bool IA_IAPI::isStackFramePreamble() const
92 {
93         assert(0);
94     return false;
95 }
96
97 bool IA_IAPI::cleansStack() const
98 {
99         assert(0);
100     return false;
101 }
102
103 class AARCH64ReturnPredicates : public Slicer::Predicates {
104   virtual bool widenAtPoint(Assignment::Ptr p) {
105                 return true;
106     }
107 };
108
109
110
111 bool IA_IAPI::sliceReturn(ParseAPI::Block* bit, Address ret_addr, ParseAPI::Function * func) const {
112         assert(0);
113         return 0;
114 }
115
116 bool IA_IAPI::isReturnAddrSave(Address& retAddr) const
117 {
118         assert(0);
119   return 0;
120 }
121
122 bool IA_IAPI::isReturn(Dyninst::ParseAPI::Function * context, Dyninst::ParseAPI::Block* currBlk) const
123 {
124         assert(0);
125         return 0;
126 }
127
128 bool IA_IAPI::isFakeCall() const
129 {
130         assert(0);
131     return false;
132 }
133
134 bool IA_IAPI::isIATcall(std::string &) const
135 {
136         assert(0);
137     return false;
138 }
139
140 const unsigned int B_UNCOND      = 0x0;
141 const unsigned int ADDIS_R12_R12 = 0x0;
142 const unsigned int ADDIS_R12_R2  = 0x0;
143 const unsigned int ADDIS_R2_R2   = 0x0;
144 const unsigned int ADDI_R12_R12  = 0x0;
145 const unsigned int ADDI_R2_R2    = 0x0;
146 const unsigned int STD_R2_40R1   = 0x0;
147 const unsigned int LD_R2_40R1    = 0x0;
148 const unsigned int LD_R2_0R2     = 0x0;
149 const unsigned int LD_R2_0R12    = 0x0;
150 const unsigned int LD_R11_0R12   = 0x0;
151 const unsigned int LD_R11_0R2    = 0x0;
152 const unsigned int MTCTR_R11     = 0x0;
153 const unsigned int BCTR          = 0x0;
154
155 typedef enum {
156     STUB_UNKNOWN,
157     STUB_LONG_BRANCH,
158     STUB_TOC_BRANCH,
159     STUB_PLT_CALL
160 } linker_stub_t;
161
162 linker_stub_t checkLinkerStub(void *insn_buf, Offset &off)
163 {
164         assert(0);
165     instruction *insn = static_cast<instruction *>(insn_buf);
166
167     off = 0;
168     return STUB_UNKNOWN;
169 }
170
171 bool IA_IAPI::isLinkerStub() const
172 {
173   // Disabling this code because it ends with an
174   // incorrect CFG.
175
176   return false;
177 }
178
179 AST::Ptr AARCH64_BLR_Visitor::visit(AST *a) {
180         assert(0);
181   return a->ptr();
182 }
183
184 AST::Ptr AARCH64_BLR_Visitor::visit(DataflowAPI::BottomAST *b) {
185         assert(0);
186   return_ = AARCH64_BLR_UNKNOWN;
187   return b->ptr();
188 }
189
190 AST::Ptr AARCH64_BLR_Visitor::visit(DataflowAPI::ConstantAST *c) {
191         assert(0);
192   // Very odd case, but claiming not a return
193   return_ = AARCH64_BLR_NOTRETURN;
194   return c->ptr();
195 }
196
197 AST::Ptr AARCH64_BLR_Visitor::visit(DataflowAPI::VariableAST *v) {
198         assert(0);
199   return v->ptr();
200 }
201 /*
202 AST::Ptr AARCH64_BLR_Visitor::visit(StackAST *s) {
203   return_ = UNKNOWN;
204   return s->Ptr();
205 }
206 */
207 AST::Ptr AARCH64_BLR_Visitor::visit(DataflowAPI::RoseAST *r) {
208         assert(0);
209   return r->ptr();
210 }
211
212 #if 0
213 ParseAPI::StackTamper
214 IA_IAPI::tampersStack(ParseAPI::Function *, Address &) const
215 {
216     return TAMPER_NONE;
217 }
218 #endif
219
220 bool IA_IAPI::isNopJump() const
221 {
222         assert(0);
223     return false;
224 }