Implements getDynamicCallSiteArgs to monitor dynamic call sites.
[dyninst.git] / dyninstAPI / src / emit-aarch64.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
32 #ifndef _EMITTER_AARCH64_H
33 #define _EMITTER_AARCH64_H
34
35 #include "common/src/headers.h"
36 #include "dyninstAPI/src/instPoint.h"
37 #include "dyninstAPI/src/baseTramp.h"
38 #include "dyninstAPI/src/ast.h"
39
40 #include "dyninstAPI/src/emitter.h"
41
42 class codeGen;
43
44 class registerSpace;
45
46 class baseTramp;
47
48 // class for encapsulating
49 // platform dependent code generation functions
50 class EmitterAARCH64 : public Emitter {
51
52 public:
53     virtual ~EmitterAARCH64() {};
54
55     virtual codeBufIndex_t emitIf(Register, Register, RegControl, codeGen &);
56
57     virtual void emitOp(unsigned, Register, Register, Register, codeGen &);
58
59     virtual void emitOpImm(unsigned, unsigned, Register, Register, RegValue,
60                            codeGen &) { assert(0); }
61
62     virtual void emitRelOp(unsigned, Register, Register, Register, codeGen &);
63
64     virtual void emitRelOpImm(unsigned, Register, Register, RegValue, codeGen &);
65
66     virtual void emitDiv(Register, Register, Register, codeGen &) { assert(0); }
67
68     virtual void emitTimesImm(Register, Register, RegValue, codeGen &) { assert(0); }
69
70     virtual void emitDivImm(Register, Register, RegValue, codeGen &) { assert(0); }
71
72     virtual void emitLoad(Register, Address, int, codeGen &);
73
74     virtual void emitLoadConst(Register, Address, codeGen &);
75
76     virtual void emitLoadIndir(Register, Register, int, codeGen &);
77
78     virtual bool emitCallRelative(Register, Address, Register, codeGen &);
79
80     virtual bool emitLoadRelative(Register, Address, Register, int, codeGen &);
81
82     virtual void
83     emitLoadShared(opCode op, Register dest, const image_variable *var, bool is_local, int size, codeGen &gen,
84                    Address offset);
85
86     virtual void emitLoadFrameAddr(Register, Address, codeGen &) { assert(0); }
87
88     // These implicitly use the stored original/non-inst value
89     virtual void emitLoadOrigFrameRelative(Register, Address, codeGen &) { assert(0); }
90
91     virtual void emitLoadOrigRegRelative(Register, Address, Register, codeGen &, bool);
92
93     virtual void emitLoadOrigRegister(Address, Register, codeGen &);
94
95     virtual void emitStore(Address, Register, int, codeGen &);
96
97     virtual void emitStoreIndir(Register, Register, int, codeGen &);
98
99     virtual void emitStoreFrameRelative(Address, Register, Register, int, codeGen &) { assert(0); }
100
101     virtual void emitStoreRelative(Register, Address, Register, int, codeGen &);
102
103     virtual void emitStoreShared(Register source, const image_variable *var, bool is_local, int size, codeGen &gen);
104
105
106     virtual void emitStoreOrigRegister(Address, Register, codeGen &) { assert(0); }
107
108     virtual bool emitMoveRegToReg(Register, Register, codeGen &) {
109         assert(0);
110         return 0;
111     }
112
113     virtual bool emitMoveRegToReg(registerSlot *src, registerSlot *dest, codeGen &gen);
114
115     virtual Address emitMovePCToReg(Register, codeGen &gen);
116
117     // This one we actually use now.
118     virtual Register emitCall(opCode, codeGen &, const pdvector <AstNodePtr> &,
119                               bool, func_instance *);
120     //virtual bool emitPIC(codeGen& /*gen*/, Address, Address )=0;
121
122     virtual void emitGetRetVal(Register, bool, codeGen &) { assert(0); }
123
124     virtual void emitGetRetAddr(Register, codeGen &) { assert(0); }
125
126     virtual void emitGetParam(Register, Register, instPoint::Type, opCode, bool, codeGen &);
127
128     virtual void emitASload(int, int, int, long, Register, int, codeGen &) { assert(0); }
129
130     virtual void emitCSload(int, int, int, long, Register, codeGen &) { assert(0); }
131
132     virtual void emitPushFlags(codeGen &) { assert(0); }
133
134     virtual void emitRestoreFlags(codeGen &, unsigned) { assert(0); }
135
136     // Built-in offset...
137     virtual void emitRestoreFlagsFromStackSlot(codeGen &) { assert(0); }
138
139     virtual bool emitBTSaves(baseTramp *, codeGen &) {
140         assert(0);
141         return true;
142     }
143
144     virtual bool emitBTRestores(baseTramp *, codeGen &) {
145         assert(0);
146         return true;
147     }
148
149     virtual void emitStoreImm(Address, int, codeGen &, bool) { assert(0); }
150
151     virtual void emitAddSignedImm(Address, int, codeGen &, bool) { assert(0); }
152
153     virtual int Register_DWARFtoMachineEnc(int) {
154         assert(0);
155         return 0;
156     }
157
158     virtual bool emitPush(codeGen &, Register) {
159         assert(0);
160         return true;
161     }
162
163     virtual bool emitPop(codeGen &, Register) {
164         assert(0);
165         return true;
166     }
167
168     virtual bool emitAdjustStackPointer(int, codeGen &) {
169         assert(0);
170         return true;
171     }
172
173     virtual bool clobberAllFuncCall(registerSpace *rs, func_instance *callee);
174
175 protected:
176     virtual bool emitCallInstruction(codeGen &, func_instance *,
177                                      bool, Address);
178
179     virtual Register emitCallReplacement(opCode, codeGen &, bool,
180                                          func_instance *);
181 };
182
183 class EmitterAARCH64Dyn : public EmitterAARCH64 {
184 public:
185     virtual bool emitTOCCall(block_instance *dest, codeGen &gen) { return emitTOCCommon(dest, true, gen); }
186
187     virtual bool emitTOCJump(block_instance *dest, codeGen &gen) { return emitTOCCommon(dest, false, gen); }
188
189     virtual ~EmitterAARCH64Dyn() {}
190
191 private:
192     bool emitTOCCommon(block_instance *dest, bool call, codeGen &gen);
193
194 };
195
196 class EmitterAARCH64Stat : public EmitterAARCH64 {
197 public:
198     virtual ~EmitterAARCH64Stat() {}
199
200     virtual bool emitPLTCall(func_instance *dest, codeGen &gen);
201
202     virtual bool emitPLTJump(func_instance *dest, codeGen &gen);
203
204     virtual bool emitTOCCall(block_instance *dest, codeGen &gen);
205
206     virtual bool emitTOCJump(block_instance *dest, codeGen &gen);
207
208 protected:
209     virtual bool emitCallInstruction(codeGen &, func_instance *, bool,
210                                      Address);
211
212     virtual Register emitCallReplacement(opCode, codeGen &, bool,
213                                          func_instance *) {
214         assert(0 && "emitCallReplacement not implemented for binary rewriter");
215     }
216
217 private:
218     bool emitPLTCommon(func_instance *dest, bool call, codeGen &gen);
219
220     bool emitTOCCommon(block_instance *dest, bool call, codeGen &gen);
221 };
222
223 class EmitterAARCH64SaveRegs {
224 public:
225     virtual ~EmitterAARCH64SaveRegs() {}
226
227     unsigned saveGPRegisters(codeGen &gen, registerSpace *theRegSpace,
228             int offset, int numReqGPRs = -1);
229
230     unsigned saveFPRegisters(codeGen &gen, registerSpace *theRegSpace, int offset);
231
232     unsigned saveSPRegisters(codeGen &gen, registerSpace *, int offset, bool force_save);
233
234     void createFrame(codeGen &gen);
235
236 private:
237     void saveSPR(codeGen &gen, Register scratchReg, int sprnum, int stkOffset);
238
239     void saveFPRegister(codeGen &gen, Register reg, int save_off);
240 };
241
242 class EmitterAARCH64RestoreRegs {
243 public:
244     virtual ~EmitterAARCH64RestoreRegs() {}
245
246     unsigned restoreGPRegisters(codeGen &gen, registerSpace *theRegSpace, int offset);
247
248     unsigned restoreFPRegisters(codeGen &gen, registerSpace *theRegSpace, int offset);
249
250     unsigned restoreSPRegisters(codeGen &gen, registerSpace *, int offset, int force_save);
251
252     void tearFrame(codeGen &gen);
253
254     void restoreSPR(codeGen &gen, Register scratchReg, int sprnum, int stkOffset);
255
256     void restoreFPRegister(codeGen &gen, Register reg, int save_off);
257 };
258
259 #endif