Fix memory leaks in emitElf (#895)
[dyninst.git] / dyninstAPI / src / registerSpace.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 // $Id: registerSpace.h,v 1.18 2008/06/19 19:53:37 legendre Exp $
32
33 #ifndef REGISTER_SPACE_H
34 #define REGISTER_SPACE_H
35
36 #include <stdio.h>
37 #include <string>
38 #include <map>
39 #include <set>
40 #include "common/src/Vector.h"
41 #include <unordered_map>
42 #include "common/src/Types.h"
43 #include "inst.h" // callWhen...
44
45 #include "bitArray.h"
46
47 class codeGen;
48 class instPoint;
49 class AddressSpace;
50 class parse_block;
51 class baseTramp;
52
53 // A class to retain information about where the original register can be found. It can be in one of the following states:
54 // 1) Unsaved, and available via the register itself;
55 // 2) Saved in a frame, e.g., a base tramp;
56 // 3) Pushed on the stack at a relative offset from the current stack pointer.
57 // 4) TODO: we could subclass this and make "get me the current value" a member function; not sure it's really worth it for the minimal amount of memory multiple types will use.
58
59 // We also need a better way of tracking what state a register is in. Here's some possibilities, not at all mutually independent:
60
61 // Live at the start of instrumentation, or dead;
62 // Used during the generation of a subexpression
63 // Currently reserved by another AST, but we could recalculate if necessary
64 // At a function call node, is it carrying a value?
65
66 // Terminology:
67 // "Live" : contains a value outside of instrumentation, and so must be saved before use
68 // "Used" : used by instrumentation code.
69
70 class RealRegister {
71    //This is currently only used on x86_32 to represent the
72    // virtual/real register difference.  'Register' still refers
73    // to virtual registers on this platform.  Contained in a struct
74    // so that no one can accidently cast a Register into a RealRegister
75    friend class registerSpace;
76    signed int r;
77  public:
78    RealRegister() { r = 0; }
79    explicit RealRegister(int reg) { r = reg; }
80    int reg() const { return r; }
81 };
82
83 #if defined(arch_x86_64)
84 #include "inst-x86.h"
85 #endif
86
87 class registerSlot {
88  public:
89    int alloc_num; //MATT TODO: Remove
90     const Register number;    // what register is it, using our Register enum
91     const std::string name;
92
93     typedef enum { deadAlways, deadABI, liveAlways } initialLiveness_t;
94     const initialLiveness_t initialState;
95
96     // Are we off limits for allocation in this particular instance?
97     bool offLimits;
98
99     typedef enum { invalid, GPR, FPR, SPR, realReg} regType_t;
100     const regType_t type;
101
102     ////////// Code generation
103
104     int refCount;       // == 0 if free
105
106     typedef enum { live, spilled, dead } livenessState_t;
107     livenessState_t liveState;
108
109     bool keptValue;     // Are we keeping this (as long as we can) to save
110     // the pre-calculated value? Note: refCount can be 0 and
111     // this still set.
112
113     bool beenUsed;      // Has this register been used by generated code?
114
115     // New version of "if we were saved, then where?" It's a pair - true/false,
116     // then offset from the "zeroed" stack pointer.
117     typedef enum { unspilled, framePointer } spillReference_t;
118     spillReference_t spilledState;
119     int saveOffset; // Offset where this register can be
120                     // retrieved.
121     // AMD-64: this is the number of words
122     // POWER: this is the number of bytes
123     // I know it's inconsistent, but it's easier this way since POWER
124     // has some funky math.
125
126     //////// Member functions
127
128     unsigned encoding() const;
129
130     void cleanSlot();
131
132     void markUsed(bool incRefCount) {
133         assert(offLimits == false);
134         assert(refCount == 0);
135         assert(liveState != live);
136
137         if (incRefCount)
138             refCount = 1;
139         beenUsed = true;
140     }
141
142     // Default is just fine
143     // registerSlot(const registerSlot &r)
144
145     void debugPrint(const char *str = NULL);
146
147     // Don't want to use this...
148     registerSlot() :
149        alloc_num(0),
150         number(REG_NULL),
151         name("DEFAULT REGISTER"),
152         initialState(deadAlways),
153         offLimits(true),
154         type(invalid)
155         {};
156
157     registerSlot(Register num,
158                  std::string name_,
159                  bool offLimits_,
160                  initialLiveness_t initial,
161                  regType_t type_) :
162        alloc_num(0),
163         number(num),
164         name(name_),
165         initialState(initial),
166         offLimits(offLimits_),
167         type(type_),
168         refCount(0),
169         liveState(live),
170         keptValue(false),
171         beenUsed(false),
172         spilledState(unspilled),
173         saveOffset(-1) {}
174
175 };
176
177 class instPoint;
178
179 typedef struct {
180    bool is_allocatable;
181    bool been_used;
182    int last_used;
183    registerSlot *contains;
184 } RealRegsState;
185
186
187 class regState_t {
188  public:
189    regState_t();
190    int pc_rel_offset;
191    int timeline;
192    int stack_height;
193    std::vector<RealRegsState> registerStates;
194 };
195
196 class registerSpace {
197    friend class baseTramp;
198  private:
199     // A global mapping of register names to slots
200     static registerSpace *globalRegSpace_;
201     static registerSpace *globalRegSpace64_;
202
203     static void createRegSpaceInt(pdvector<registerSlot *> &regs,
204                                   registerSpace *regSpace);
205
206  public:
207     // Pre-set unknown register state:
208     // Everything is live...
209     static registerSpace *conservativeRegSpace(AddressSpace *proc);
210     // Everything is dead...
211     static registerSpace *optimisticRegSpace(AddressSpace *proc);
212     // IRPC-specific - everything live for now
213     static registerSpace *irpcRegSpace(AddressSpace *proc);
214     // Aaand instPoint-specific
215     static registerSpace *actualRegSpace(instPoint *iP);
216     // DO NOT DELETE THESE.
217     static registerSpace *savedRegSpace(AddressSpace *proc);
218
219     static registerSpace *getRegisterSpace(AddressSpace *proc);
220     static registerSpace *getRegisterSpace(unsigned addr_width);
221
222     registerSpace();
223
224     static void createRegisterSpace(pdvector<registerSlot *> &registers);
225     static void createRegisterSpace64(pdvector<registerSlot *> &registers);
226
227     ~registerSpace();
228
229     // Read the value in register souce from wherever we've stored it in
230     // memory (including the register itself), and stick it in actual register
231     // destination. So the source is the label, and destination is an actual.
232     // Size is a legacy parameter for places where we don't have register information
233     bool readProgramRegister(codeGen &gen, Register source,
234                              Register destination,
235                              unsigned size);
236
237     // And the reverse
238     bool writeProgramRegister(codeGen &gen, Register destination,
239                               Register source,
240                               unsigned size);
241
242
243     Register allocateRegister(codeGen &gen, bool noCost, bool realReg = false);
244     bool allocateSpecificRegister(codeGen &gen, Register r, bool noCost = true);
245
246
247     // Like allocate, but don't keep it around; if someone else tries to
248     // allocate they might get this one.
249     Register getScratchRegister(codeGen &gen, bool noCost = true, bool realReg = false);
250     // Like the above, but excluding a set of registers (that we don't want
251     // to touch)
252     Register getScratchRegister(codeGen &gen, pdvector<Register> &excluded, bool noCost = true, bool realReg = false);
253
254
255     bool trySpecificRegister(codeGen &gen, Register reg, bool noCost = true);
256
257     bool saveAllRegisters(codeGen &gen, bool noCost);
258     bool restoreAllRegisters(codeGen &gen, bool noCost);
259
260     // For now, we save registers elsewhere and mark them here.
261     bool markSavedRegister(Register num, int offsetFromFP);
262     bool markSavedRegister(RealRegister num, int offsetFromFP);
263
264     //
265     bool markKeptRegister(Register num);
266
267     // Things that will be modified implicitly by anything else we
268     // generate - condition registers, etc.
269     bool checkVolatileRegisters(codeGen &gen, registerSlot::livenessState_t);
270     bool saveVolatileRegisters(codeGen &gen);
271     bool restoreVolatileRegisters(codeGen &gen);
272
273     // Free the specified register (decrement its refCount)
274     void freeRegister(Register k);
275     // Free the register even if its refCount is greater that 1
276     void forceFreeRegister(Register k);
277     // And mark a register as not being kept any more
278     void unKeepRegister(Register k);
279
280
281     // Mark all registers as unallocated, but keep live/dead info
282     void cleanSpace();
283
284     // Check to see if the register is free
285     // DO NOT USE THIS!!!! to tell if you can use a register as
286     // a scratch register; do that with trySpecificRegister
287     // or allocateSpecificRegister. This is _ONLY_ to determine
288     // if a register should be saved (e.g., over a call).
289     bool isFreeRegister(Register k);
290
291     // Checks to see if register starts live
292     bool isRegStartsLive(Register reg);
293     int fillDeadRegs(Register * deadRegs, int num);
294
295     // Bump up the reference count. Occasionally, we underestimate it
296     // and call this routine to correct this.
297     void incRefCount(Register k);
298
299     // Reset when the regSpace is reset - marked offlimits for
300     // allocation.
301     bool markReadOnly(Register k);
302     bool readOnlyRegister(Register k);
303     // Make sure that no registers remain allocated, except "to_exclude"
304     // Used for assertion checking.
305     void checkLeaks(Register to_exclude);
306
307     int getAddressWidth() { return addr_width; }
308     void debugPrint();
309     void printAllocedRegisters();
310
311     int numGPRs() const { return GPRs_.size(); }
312     int numFPRs() const { return FPRs_.size(); }
313     int numSPRs() const { return SPRs_.size(); }
314     int numRegisters() const { return registers_.size(); }
315
316     pdvector <registerSlot *> &GPRs() { return GPRs_; }
317     pdvector <registerSlot *> &FPRs() { return FPRs_; }
318     pdvector <registerSlot *> &SPRs() { return SPRs_; }
319
320     pdvector <registerSlot *> &realRegs();
321
322     pdvector <registerSlot *> &trampRegs(); //realRegs() on x86-32, GPRs on all others
323
324     registerSlot *physicalRegs(Register reg) { return physicalRegisters_[reg]; }
325
326     registerSlot *operator[](Register);
327
328     // For platforms with "save all" semantics...
329     bool anyLiveGPRsAtEntry() const;
330     bool anyLiveFPRsAtEntry() const;
331     bool anyLiveSPRsAtEntry() const;
332
333
334     /**
335      * The following set of 'public' and 'private' methods and data deal with
336      * virtual registers, currently used only on x86.  The above 'Register' class
337      * allocates and uses virtual registers, these methods provide mappings from
338      * virtual registers to real registers.
339      **/
340  public:
341     //Put VReg into RReg
342     RealRegister loadVirtual(registerSlot *virt_r, codeGen &gen);
343     RealRegister loadVirtual(Register virt_r, codeGen &gen);
344
345     //Put VReg into specific real register
346     void loadVirtualToSpecific(registerSlot *virt_r, RealRegister real_r, codeGen &gen);
347     void loadVirtualToSpecific(Register virt_r, RealRegister real_r, codeGen &gen);
348
349     //Spill away any virtual register in a real so that the real
350     // can be used freely.  Careful with this, no guarentee it won't
351     // be reallocated in the next step.
352     void makeRegisterAvail(RealRegister r, codeGen &gen);
353
354     //Tell the tracker that we've manually put some virtual into a real
355     void noteVirtualInReal(Register v_r, RealRegister r_r);
356     void noteVirtualInReal(registerSlot *v_r, RealRegister r_r);
357
358     //Like loadVirtual, but don't load orig value first
359     RealRegister loadVirtualForWrite(Register virt_r, codeGen &gen);
360     RealRegister loadVirtualForWrite(registerSlot *virt_r, codeGen &gen);
361
362     void markVirtualDead(Register num);
363     bool spilledAnything();
364
365     Register pc_rel_reg;
366     int pc_rel_use_count;
367     int& pc_rel_offset();
368     void incStack(int val);
369     int getInstFrameSize();
370     void setInstFrameSize(int val);
371
372     int getStackHeight();
373     void setStackHeight(int val);
374
375     void unifyTopRegStates(codeGen &gen);
376     void pushNewRegState();
377
378  private:
379     int instFrameSize_;  // How much stack space we allocate for
380                          // instrumentation before a frame is set up.
381
382     std::vector<regState_t *> regStateStack;
383
384     std::vector<RealRegsState>& regState();
385     int& timeline();
386
387     std::set<registerSlot *> regs_been_spilled;
388
389     void initRealRegSpace();
390
391     //High-level functions that track data structures and call code gen
392     RealRegister findReal(registerSlot *virt_r, bool &already_setup);
393     void spillReal(RealRegister r, codeGen &gen);
394     void loadReal(RealRegister r, registerSlot *v_r, codeGen &gen);
395     void freeReal(RealRegister r);
396
397     //low-level functions for code gen
398     void spillToVReg(RealRegister reg, registerSlot *v_reg, codeGen &gen);
399     void movVRegToReal(registerSlot *v_reg, RealRegister r, codeGen &gen);
400     void movRegToReg(RealRegister dest, RealRegister src, codeGen &gen);
401
402     unsigned savedFlagSize;
403
404  private:
405
406     registerSpace(const registerSpace &);
407
408     registerSlot &getRegisterSlot(Register reg);
409
410     registerSlot *findRegister(Register reg);
411     registerSlot *findRegister(RealRegister reg);
412
413     bool spillRegister(Register reg, codeGen &gen, bool noCost);
414     bool stealRegister(Register reg, codeGen &gen, bool noCost);
415
416     bool restoreRegister(Register reg, codeGen &gen, bool noCost);
417     bool popRegister(Register reg, codeGen &gen, bool noCost);
418
419     bool markSavedRegister(registerSlot *num, int offsetFromFP);
420
421     int currStackPointer;
422
423     // This structure is permanently tainted by its association with
424     // virtual registers...
425     std::unordered_map<Register, registerSlot *> registers_;
426
427     std::map<Register, registerSlot *> physicalRegisters_;
428
429     // And convenience vectors
430     pdvector<registerSlot *> GPRs_;
431     pdvector<registerSlot *> FPRs_;
432     pdvector<registerSlot *> SPRs_;
433
434     // Used on platforms that have "virtual" registers to provide a mapping
435     // for real (e.g., architectural) registers
436     pdvector<registerSlot *> realRegisters_;
437
438     static void initialize();
439     static void initialize32();
440     static void initialize64();
441
442
443     registerSpace &operator=(const registerSpace &src);
444
445     typedef enum {arbitrary, ABI_boundary, allSaved} rs_location_t;
446
447     // Specialize liveness as represented by a bit array
448     void specializeSpace(rs_location_t state);
449
450     void specializeSpace(const bitArray &);
451     bool checkLive(Register reg, const bitArray &liveRegs);
452
453     unsigned addr_width;
454
455  public:
456     static bool hasXMM;  // for Intel architectures, XMM registers
457
458  public:
459 #if defined(arch_power)
460     typedef enum { r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12,
461                    r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23,
462                    r24, r25, r26, r27, r28, r29, r30, r31,
463                    fpr0, fpr1, fpr2, fpr3, fpr4, fpr5, fpr6,
464                    fpr7, fpr8, fpr9, fpr10, fpr11, fpr12, fpr13,
465                    fpr14, fpr15, fpr16, fpr17, fpr18, fpr19, fpr20,
466                    fpr21, fpr22, fpr23, fpr24, fpr25, fpr26, fpr27,
467                    fpr28, fpr29, fpr30, fpr31,
468                    xer, lr, ctr, mq, cr, lastReg, ignored } powerRegisters_t;
469     static unsigned GPR(Register x) { return x; }
470     static unsigned FPR(Register x) { return x - fpr0; }
471     static unsigned SPR(Register x);
472     int framePointer() { return r1; }
473 #endif
474 #if defined(arch_x86) || defined(arch_x86_64)
475     int framePointer();
476 #endif
477 #if defined(arch_aarch64)
478 //#warning "Not verified yet!"
479         //31 GPRs, 32 FPRs
480     typedef enum { r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12,
481                    r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23,
482                    r24, r25, r26, r27, r28, r29, r30,
483                    fpr0, fpr1, fpr2, fpr3, fpr4, fpr5, fpr6,
484                    fpr7, fpr8, fpr9, fpr10, fpr11, fpr12, fpr13,
485                    fpr14, fpr15, fpr16, fpr17, fpr18, fpr19, fpr20,
486                    fpr21, fpr22, fpr23, fpr24, fpr25, fpr26, fpr27,
487                    fpr28, fpr29, fpr30, fpr31,
488                    lr, sp, pc, pstate, fpcr, fpsr, ignored } aarch64Registers_t;
489     static unsigned GPR(Register x) { return x; }
490     static unsigned FPR(Register x) { return x - fpr0; }
491     int framePointer() { return r29; }
492 #endif
493     // Create a map of register names to register numbers
494     std::map<std::string, Register> registersByName;
495     // The reverse map can be handled by doing a rs[x]->name
496
497     Register getRegByName(const std::string name);
498     std::string getRegByNumber(Register num);
499     void getAllRegisterNames(std::vector<std::string> &ret);
500
501
502 };
503
504 #endif