Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / emit-power.h
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 /*
33  * emit-x86.h - x86 & AMD64 code generators
34  * $Id: emit-power.h,v 1.6 2008/03/25 19:24:26 bernat Exp $
35  */
36
37 #ifndef _EMITTER_POWER_H
38 #define _EMITTER_POWER_H
39
40 #include "common/h/headers.h"
41 #include "dyninstAPI/src/instPoint.h"
42 #include "dyninstAPI/src/baseTramp.h"
43 #include "dyninstAPI/src/ast.h"
44
45 #include "dyninstAPI/src/emitter.h"
46
47 class codeGen;
48 class registerSpace;
49 class baseTramp;
50
51 // class for encapsulating
52 // platform dependent code generation functions
53 class EmitterPOWER : public Emitter {
54
55  public:
56     virtual ~EmitterPOWER() {};
57     virtual codeBufIndex_t emitIf(Register, Register, RegControl, codeGen &) { assert(0); return 0; }
58     virtual void emitOp(unsigned, Register, Register, Register, codeGen &) { assert(0); }
59     virtual void emitOpImm(unsigned, unsigned, Register, Register, RegValue,
60                            codeGen &) { assert(0); }
61     virtual void emitRelOp(unsigned, Register, Register, Register, codeGen &) { assert(0); }
62     virtual void emitRelOpImm(unsigned, Register, Register, RegValue, codeGen &) { assert(0); }
63     virtual void emitDiv(Register, Register, Register, codeGen &) { assert(0); }
64     virtual void emitTimesImm(Register, Register, RegValue, codeGen &) { assert(0); }
65     virtual void emitDivImm(Register, Register, RegValue, codeGen &) { assert(0); }
66     virtual void emitLoad(Register, Address, int, codeGen &) { assert(0); }
67     virtual void emitLoadConst(Register, Address, codeGen &) { assert(0); }
68     virtual void emitLoadIndir(Register, Register, int, codeGen &) { assert(0); }
69     virtual bool emitLoadRelative(Register, Address, Register, codeGen &) { assert(0); return true;}
70     virtual bool emitLoadRelative(registerSlot *dest, Address offset, registerSlot *base, codeGen &gen);
71     // Not implemented yet
72     virtual void emitLoadShared(opCode op, Register dest, const image_variable *var, bool is_local, int size, codeGen &gen, Address offset);
73     virtual void emitLoadFrameAddr(Register, Address, codeGen &) { assert(0); }
74
75     // These implicitly use the stored original/non-inst value
76     virtual void emitLoadOrigFrameRelative(Register, Address, codeGen &) { assert(0); }
77     virtual void emitLoadOrigRegRelative(Register, Address, Register, codeGen &, bool) { assert(0); }
78     virtual void emitLoadOrigRegister(Address, Register, codeGen &) { assert(0); }
79
80     virtual void emitStore(Address, Register, int, codeGen &) { assert(0); }
81     virtual void emitStoreIndir(Register, Register, int, codeGen &) { assert(0); }
82     virtual void emitStoreFrameRelative(Address, Register, Register, int, codeGen &) { assert(0); }
83     virtual void emitStoreRelative(Register, Address, Register, codeGen &) { assert(0); }
84     virtual void emitStoreRelative(registerSlot *source, Address offset, registerSlot *base, codeGen &gen);
85     // Not implemented yet
86     virtual void emitStoreShared(Register source, const image_variable *var, bool is_local, int size, codeGen &gen);
87
88
89     virtual void emitStoreOrigRegister(Address, Register, codeGen &) { assert(0); }
90
91     virtual bool emitMoveRegToReg(Register, Register, codeGen &) { assert(0); return 0;}
92     virtual bool emitMoveRegToReg(registerSlot *src, registerSlot *dest, codeGen &gen);
93     // This one we actually use now.
94     virtual Register emitCall(opCode, codeGen &, const pdvector<AstNodePtr> &,
95                               bool, int_function *) = 0;
96
97     virtual void emitGetRetVal(Register, bool, codeGen &) { assert(0); }
98     virtual void emitGetParam(Register, Register, instPointType_t, bool, codeGen &) { assert(0); }
99     virtual void emitFuncJump(int_function*, instPointType_t, codeGen &) { assert(0); }
100     virtual void emitASload(int, int, int, long, Register, codeGen &) { assert(0); }
101     virtual void emitCSload(int, int, int, long, Register, codeGen &) { assert(0); }
102     virtual void emitPushFlags(codeGen &) { assert(0); }
103     virtual void emitRestoreFlags(codeGen &, unsigned) { assert(0); }
104     // Built-in offset...
105     virtual void emitRestoreFlagsFromStackSlot(codeGen &) { assert(0); }
106     virtual bool emitBTSaves(baseTramp*, baseTrampInstance*, codeGen &) { assert(0); return true;}
107     virtual bool emitBTRestores(baseTramp*, baseTrampInstance *, codeGen &) { assert(0); return true; }
108     virtual void emitStoreImm(Address, int, codeGen &, bool) { assert(0); }
109     virtual void emitAddSignedImm(Address, int, codeGen &, bool) { assert(0); }
110     virtual int Register_DWARFtoMachineEnc(int) { assert(0); return 0;}
111     virtual bool emitPush(codeGen &, Register) { assert(0); return true;}
112     virtual bool emitPop(codeGen &, Register) { assert(0); return true;}
113     virtual bool emitAdjustStackPointer(int, codeGen &) { assert(0); return true;}
114     
115     virtual bool clobberAllFuncCall(registerSpace *rs,int_function *callee);
116 };
117
118 class EmitterPOWERDyn : public EmitterPOWER {
119  public:
120     virtual ~EmitterPOWERDyn() {};
121
122     Register emitCallReplacement(opCode ocode, codeGen &gen,
123                                  bool noCost, int_function *callee);
124     Register emitCall(opCode op, codeGen &gen,
125                       const pdvector<AstNodePtr> &operands,
126                       bool noCost, int_function *callee);
127 };
128
129 class EmitterPOWERStat : public EmitterPOWER {
130  public:
131     virtual ~EmitterPOWERStat() {};
132 };
133
134 class EmitterPOWER32Dyn : public EmitterPOWERDyn {
135  public:
136     virtual ~EmitterPOWER32Dyn() {}
137 };
138
139 class EmitterPOWER32Stat : public EmitterPOWERStat {
140  public:
141     virtual ~EmitterPOWER32Stat() {}
142
143     Register emitCall(opCode op, codeGen &gen,
144                       const pdvector<AstNodePtr> &operands,
145                       bool noCost, int_function *callee);
146 };
147
148 class EmitterPOWER64Dyn : public EmitterPOWERDyn {
149  public:
150     virtual ~EmitterPOWER64Dyn() {}
151
152 };
153
154 class EmitterPOWER64Stat : public EmitterPOWERStat {
155  public:
156     virtual ~EmitterPOWER64Stat() {}
157
158     Register emitCall(opCode op, codeGen &gen,
159                       const pdvector<AstNodePtr> &operands,
160                       bool noCost, int_function *callee);
161 };
162
163 #endif