These functions were moved to the Emitter class.
[dyninst.git] / dyninstAPI / src / emit-x86.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  * emit-x86.h - x86 & AMD64 code generators
33  * $Id: emit-x86.h,v 1.32 2008/09/11 20:14:14 mlam Exp $
34  */
35
36 #ifndef _EMIT_X86_H
37 #define _EMIT_X86_H
38
39 #include "common/src/headers.h"
40 #include "common/src/arch.h"
41 #include "dyninstAPI/src/instPoint.h"
42 #include "dyninstAPI/src/baseTramp.h"
43
44 #include "dyninstAPI/src/emitter.h"
45 class codeGen;
46 class registerSpace;
47
48 class registerSlot;
49
50 // Emitter moved to emitter.h - useful on other platforms as well
51
52 class Emitterx86 : public Emitter {
53     public:
54         virtual ~Emitterx86() {};
55
56         virtual bool emitLoadRelativeSegReg(Register dest, Address offset, Register base, int size, codeGen &gen) = 0;
57
58         virtual bool emitXorRegRM(Register dest, Register base, int disp, codeGen& gen) = 0;
59         virtual bool emitXorRegReg(Register dest, Register base, codeGen& gen) = 0;
60         virtual bool emitXorRegImm(Register dest, int imm, codeGen& gen) = 0;
61         virtual bool emitXorRegSegReg(Register dest, Register base, int disp, codeGen& gen) = 0;
62
63         virtual void emitLEA(Register base, Register index, unsigned int scale, int disp, Register dest, codeGen& gen) = 0;
64
65         virtual bool emitCallInstruction(codeGen &, func_instance *, Register) = 0;
66 };
67
68 // 32-bit class declared here since its implementation is in both inst-x86.C and emit-x86.C
69 class EmitterIA32 : public Emitterx86 {
70
71 public:
72     virtual ~EmitterIA32() {};
73     static const int mt_offset;
74     codeBufIndex_t emitIf(Register expr_reg, Register target, RegControl rc, codeGen &gen);
75     void emitOp(unsigned opcode, Register dest, Register src1, Register src2, codeGen &gen);
76     void emitRelOp(unsigned op, Register dest, Register src1, Register src2, codeGen &gen, bool s);
77     void emitDiv(Register dest, Register src1, Register src2, codeGen &gen, bool s);
78     void emitOpImm(unsigned opcode1, unsigned opcode2, Register dest, Register src1, RegValue src2imm,
79                            codeGen &gen);
80     void emitRelOpImm(unsigned op, Register dest, Register src1, RegValue src2imm, codeGen &gen, bool s);
81     void emitTimesImm(Register dest, Register src1, RegValue src1imm, codeGen &gen, bool s);
82     void emitDivImm(Register dest, Register src1, RegValue src1imm, codeGen &gen, bool s);
83     void emitLoad(Register dest, Address addr, int size, codeGen &gen);
84     void emitLoadConst(Register dest, Address imm, codeGen &gen);
85     void emitLoadIndir(Register dest, Register addr_reg, int size, codeGen &gen);
86     bool emitCallRelative(Register, Address, Register, codeGen &) {assert (0); return false; }
87     bool emitLoadRelative(Register dest, Address offset, Register base, int size, codeGen &gen);
88     bool emitLoadRelativeSegReg(Register dest, Address offset, Register base, int size, codeGen &gen);
89     void emitLoadShared(opCode op, Register dest, const image_variable *var, bool is_local,int size, codeGen &gen, Address offset);
90     void emitLoadFrameAddr(Register dest, Address offset, codeGen &gen);
91     void emitLoadOrigFrameRelative(Register dest, Address offset, codeGen &gen);
92     void emitLoadOrigRegRelative(Register dest, Address offset, Register base, codeGen &gen, bool store);
93     void emitLoadOrigRegister(Address register_num, Register dest, codeGen &gen);
94
95     void emitStoreOrigRegister(Address register_num, Register dest, codeGen &gen);
96
97     void emitStore(Address addr, Register src, int size, codeGen &gen);
98     void emitStoreIndir(Register addr_reg, Register src, int size, codeGen &gen);
99     void emitStoreFrameRelative(Address offset, Register src, Register scratch, int size, codeGen &gen);
100     void emitStoreRelative(Register source, Address offset, Register base, int size, codeGen &gen);
101     void emitStoreShared(Register source, const image_variable *var, bool is_local,int size, codeGen &gen);
102
103     bool clobberAllFuncCall(registerSpace *rs,func_instance *callee);
104     void setFPSaveOrNot(const int * liveFPReg,bool saveOrNot);
105     // We can overload this for the stat/dyn case
106     virtual Register emitCall(opCode op, codeGen &gen,
107                               const pdvector<AstNodePtr> &operands,
108                               bool noCost, func_instance *callee);
109     //virtual bool emitPIC(codeGen& /*gen*/, Address, Address )=0;
110     int emitCallParams(codeGen &gen, 
111                        const pdvector<AstNodePtr> &operands,
112                        func_instance *target, 
113                        pdvector<Register> &extra_saves,
114                        bool noCost);
115     bool emitCallCleanup(codeGen &gen, func_instance *target, 
116                          int frame_size, pdvector<Register> &extra_saves);
117     void emitGetRetVal(Register dest, bool addr_of, codeGen &gen);
118     void emitGetRetAddr(Register dest, codeGen &gen);
119     void emitGetParam(Register dest, Register param_num, instPoint::Type pt_type, opCode op, bool addr_of, codeGen &gen);
120     void emitASload(int ra, int rb, int sc, long imm, Register dest, int stackShift, codeGen &gen);
121     void emitCSload(int ra, int rb, int sc, long imm, Register dest, codeGen &gen);
122     void emitPushFlags(codeGen &gen);
123     void emitRestoreFlags(codeGen &gen, unsigned offset);
124     void emitRestoreFlagsFromStackSlot(codeGen &gen);
125     void emitStackAlign(int offset, codeGen &gen);
126     bool emitBTSaves(baseTramp* bt, codeGen &gen);
127     bool emitBTRestores(baseTramp* bt, codeGen &gen);
128     void emitLoadEffectiveAddress(Register base, Register index, unsigned int scale, int disp,
129                                   Register dest, codeGen &gen);
130     void emitStoreImm(Address addr, int imm, codeGen &gen, bool noCost);
131     void emitAddSignedImm(Address addr, int imm, codeGen &gen, bool noCost);
132     int Register_DWARFtoMachineEnc(int n);
133     bool emitPush(codeGen &gen, Register pushee);
134     bool emitPop(codeGen &gen, Register popee);
135
136     bool emitAdjustStackPointer(int index, codeGen &gen);
137
138     bool emitMoveRegToReg(Register src, Register dest, codeGen &gen);
139     bool emitMoveRegToReg(registerSlot* /*src*/, registerSlot* /*dest*/, codeGen& /*gen*/) { assert(0); return true; }
140     void emitLEA(Register base, Register index, unsigned int scale, int disp, Register dest, codeGen& gen);
141
142     bool emitXorRegRM(Register dest, Register base, int disp, codeGen& gen);
143     bool emitXorRegReg(Register dest, Register base, codeGen& gen);
144     bool emitXorRegImm(Register dest, int imm, codeGen& gen);
145     bool emitXorRegSegReg(Register dest, Register base, int disp, codeGen& gen);
146
147
148  protected:
149     virtual bool emitCallInstruction(codeGen &gen, func_instance *target, Register ret) = 0;
150
151 };
152
153 class EmitterIA32Dyn : public EmitterIA32 {
154  public:
155     ~EmitterIA32Dyn() {};
156     
157  protected:
158     bool emitCallInstruction(codeGen &gen, func_instance *target, Register ret);
159     //virtual bool emitPIC(codeGen& /*gen*/, Address, Address );
160 };
161
162 class EmitterIA32Stat : public EmitterIA32 {
163  public:
164
165     ~EmitterIA32Stat() {};
166
167     virtual bool emitPLTCall(func_instance *dest, codeGen &gen);
168     virtual bool emitPLTJump(func_instance *dest, codeGen &gen);
169     
170  protected:
171     bool emitCallInstruction(codeGen &gen, func_instance *target, Register ret);
172     //virtual bool emitPIC(codeGen& /*gen*/, Address, Address );
173 };
174
175 extern EmitterIA32Dyn emitterIA32Dyn;
176 extern EmitterIA32Stat emitterIA32Stat;
177
178
179 // some useful 64-bit codegen functions
180 void emitMovRegToReg64(Register dest, Register src, bool is_64, codeGen &gen);
181 void emitMovPCRMToReg64(Register dest, int offset, int size, codeGen &gen);
182 void emitMovImmToReg64(Register dest, long imm, bool is_64, codeGen &gen);
183 void emitPushReg64(Register src, codeGen &gen);
184 void emitPopReg64(Register dest, codeGen &gen);
185 void emitMovImmToRM64(Register base, int disp, int imm, codeGen &gen);
186 void emitAddMem64(Address addr, int imm, codeGen &gen);
187 void emitAddRM64(Address addr, int imm, codeGen &gen);
188 void emitOpRegImm64(unsigned opcode, unsigned opcode_ext, Register rm_reg, int imm,
189                     bool is_64, codeGen &gen);
190
191 #if defined(arch_x86_64)
192 class EmitterAMD64 : public Emitterx86 {
193
194 public:
195     virtual ~EmitterAMD64() {};
196     static const int mt_offset;
197     codeBufIndex_t emitIf(Register expr_reg, Register target, RegControl rc, codeGen &gen);
198     void emitOp(unsigned op, Register dest, Register src1, Register src2, codeGen &gen);
199     void emitRelOp(unsigned op, Register dest, Register src1, Register src2, codeGen &gen, bool s);
200     void emitDiv(Register dest, Register src1, Register src2, codeGen &gen, bool s);
201     void emitOpImm(unsigned opcode1, unsigned opcode2, Register dest, Register src1, RegValue src2imm,
202                            codeGen &gen);
203     void emitRelOpImm(unsigned op, Register dest, Register src1, RegValue src2imm, codeGen &gen, bool s);
204     void emitTimesImm(Register dest, Register src1, RegValue src1imm, codeGen &gen, bool s);
205     void emitDivImm(Register dest, Register src1, RegValue src1imm, codeGen &gen, bool s);
206     void emitLoad(Register dest, Address addr, int size, codeGen &gen);
207     void emitLoadConst(Register dest, Address imm, codeGen &gen);
208     void emitLoadIndir(Register dest, Register addr_reg, int size, codeGen &gen);
209     bool emitCallRelative(Register, Address, Register, codeGen &) {assert (0); return false; }
210     bool emitLoadRelative(Register dest, Address offset, Register base, int size, codeGen &gen);
211     bool emitLoadRelativeSegReg(Register dest, Address offset, Register base, int size, codeGen &gen);
212     void emitLoadFrameAddr(Register dest, Address offset, codeGen &gen);
213
214     void emitLoadOrigFrameRelative(Register dest, Address offset, codeGen &gen);
215     void emitLoadOrigRegRelative(Register dest, Address offset, Register base, codeGen &gen, bool store);
216     void emitLoadOrigRegister(Address register_num, Register dest, codeGen &gen);
217     void emitLoadShared(opCode op, Register dest, const image_variable *var, bool is_local,int size, codeGen &gen, Address offset);
218
219     void emitStoreOrigRegister(Address register_num, Register dest, codeGen &gen);
220
221     void emitStore(Address addr, Register src, int size, codeGen &gen);
222     void emitStoreIndir(Register addr_reg, Register src, int size, codeGen &gen);
223     void emitStoreFrameRelative(Address offset, Register src, Register scratch, int size, codeGen &gen);
224     void emitStoreRelative(Register source, Address offset, Register base, int size, codeGen &gen);
225
226     void emitStoreShared(Register source, const image_variable *var, bool is_local,int size, codeGen &gen);
227
228     bool clobberAllFuncCall(registerSpace *rs, func_instance *callee);
229     void setFPSaveOrNot(const int * liveFPReg,bool saveOrNot);
230     // See comment on 32-bit emitCall
231     virtual Register emitCall(opCode op, codeGen &gen,
232                               const pdvector<AstNodePtr> &operands,
233                               bool noCost, func_instance *callee);
234     //virtual bool emitPIC(codeGen& /*gen*/, Address, Address )=0;
235     void emitGetRetVal(Register dest, bool addr_of, codeGen &gen);
236     void emitGetRetAddr(Register dest, codeGen &gen);
237     void emitGetParam(Register dest, Register param_num, instPoint::Type pt_type, opCode op, bool addr_of, codeGen &gen);
238     void emitASload(int ra, int rb, int sc, long imm, Register dest, int stackShift, codeGen &gen);
239     void emitCSload(int ra, int rb, int sc, long imm, Register dest, codeGen &gen);
240     void emitPushFlags(codeGen &gen);
241     void emitRestoreFlags(codeGen &gen, unsigned offset);
242     void emitRestoreFlagsFromStackSlot(codeGen &gen);
243     void emitStackAlign(int offset, codeGen &gen);
244     bool emitBTSaves(baseTramp* bt, codeGen &gen);
245     bool emitBTRestores(baseTramp* bt, codeGen &gen);
246     void emitStoreImm(Address addr, int imm, codeGen &gen, bool noCost);
247     void emitAddSignedImm(Address addr, int imm, codeGen &gen, bool noCost);
248     /* The DWARF register numbering does not correspond to the architecture's
249        register encoding for 64-bit target binaries *only*. This method
250        maps the number that DWARF reports for a register to the actual
251        register number. */
252     int Register_DWARFtoMachineEnc(int n);
253     bool emitPush(codeGen &gen, Register pushee);
254     bool emitPop(codeGen &gen, Register popee);
255
256     bool emitAdjustStackPointer(int index, codeGen &gen);
257
258     bool emitMoveRegToReg(Register src, Register dest, codeGen &gen);
259     bool emitMoveRegToReg(registerSlot *src, registerSlot *dest, codeGen &gen);
260     void emitLEA(Register base, Register index, unsigned int scale, int disp, Register dest, codeGen& gen);
261
262     bool emitXorRegRM(Register dest, Register base, int disp, codeGen& gen);
263     bool emitXorRegReg(Register dest, Register base, codeGen& gen);
264     bool emitXorRegImm(Register dest, int imm, codeGen& gen);
265     bool emitXorRegSegReg(Register dest, Register base, int disp, codeGen& gen);
266
267  protected:
268     virtual bool emitCallInstruction(codeGen &gen, func_instance *target, Register ret) = 0;
269
270 };
271
272 class EmitterAMD64Dyn : public EmitterAMD64 {
273  public:
274     ~EmitterAMD64Dyn() {}
275
276     bool emitCallInstruction(codeGen &gen, func_instance *target, Register ret);
277     //virtual bool emitPIC(codeGen& /*gen*/, Address, Address );
278 };
279
280 class EmitterAMD64Stat : public EmitterAMD64 {
281  public:
282     ~EmitterAMD64Stat() {};
283     
284     virtual bool emitPLTCall(func_instance *dest, codeGen &gen);
285     virtual bool emitPLTJump(func_instance *dest, codeGen &gen);
286
287     bool emitCallInstruction(codeGen &gen, func_instance *target, Register ret);
288     //virtual bool emitPIC(codeGen& /*gen*/, Address, Address );
289 };
290
291 extern EmitterAMD64Dyn emitterAMD64Dyn;
292 extern EmitterAMD64Stat emitterAMD64Stat;
293
294 /* useful functions for inter-library function/variable references
295  * (used in the binary rewriter) */
296 //Address getInterModuleFuncAddr(func_instance *func, codeGen& gen);
297 //Address getInterModuleVarAddr(const image_variable *var, codeGen& gen);
298
299 #endif
300
301 #endif