fix warning defines
[dyninst.git] / dyninstAPI / src / registerSpace.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 // $Id: registerSpace.C,v 1.25 2008/10/27 17:23:53 mlam Exp $
32
33 #include "dyninstAPI/src/image.h"
34 #include "dyninstAPI/src/inst.h"
35 #include "dyninstAPI/src/instP.h"
36 #include "dyninstAPI/src/instPoint.h"
37 #include "dyninstAPI/src/ast.h"
38 #include "dyninstAPI/src/util.h"
39 #include "dyninstAPI/src/debug.h"
40 #include "dyninstAPI/src/addressSpace.h"
41
42 #include "dyninstAPI/src/function.h"
43 #include "dyninstAPI/src/mapped_object.h"
44 #include "dyninstAPI/src/registerSpace.h"
45
46 #include "dyninstAPI/h/BPatch.h"
47 #include "dyninstAPI/src/BPatch_collections.h"
48 #include "dyninstAPI/h/BPatch_type.h"
49 #include "dyninstAPI/src/BPatch_libInfo.h" // For instPoint->BPatch_point mapping
50
51 #include "dyninstAPI/h/BPatch_point.h"
52 #include "dyninstAPI/h/BPatch_memoryAccess_NP.h"
53
54 #include "liveness.h"
55 #include "dyninstAPI/src/RegisterConversion.h"
56 #include <map>
57
58 #if defined(arch_power)
59 #include "dyninstAPI/src/inst-power.h"
60 #include "dyninstAPI/src/emit-power.h"
61 #elif defined(arch_x86) || defined(arch_x86_64)
62 #include "dyninstAPI/src/inst-x86.h"
63 #include "dyninstAPI/src/emit-x86.h"
64 #elif defined (arch_aarch64)
65 #include "dyninstAPI/src/inst-aarch64.h"
66 #include "dyninstAPI/src/emit-aarch64.h"
67 #endif
68
69 registerSpace *registerSpace::globalRegSpace_ = NULL;
70 registerSpace *registerSpace::globalRegSpace64_ = NULL;
71
72 bool registerSpace::hasXMM = false;
73
74 void registerSlot::cleanSlot() {
75     assert(this);
76     // number does not change
77     refCount = 0;
78     //liveState = live;
79     //liveState does not change
80     keptValue = false;
81     beenUsed = false;
82     // initialState doesn't change
83     // offLimits doesn't change
84     spilledState = unspilled;
85     saveOffset = 0;
86     // type doesn't change
87 }
88
89 unsigned registerSlot::encoding() const {
90     // Should write this for all platforms when the encoding is done.
91 #if defined(arch_power)
92     switch (type) {
93     case GPR:
94         return registerSpace::GPR(number);
95         break;
96     case FPR:
97         return registerSpace::FPR(number);
98         break;
99     case SPR:
100         return registerSpace::SPR(number);
101         break;
102     default:
103         assert(0);
104         return REG_NULL;
105         break;
106     }
107 #elif defined(arch_x86) || defined(arch_x86_64)
108     // Should do a mapping here from entire register space to "expected" encodings.
109     return number;
110 #else
111     assert(0);
112     return 0;
113 #endif
114 }
115
116 registerSpace *registerSpace::getRegisterSpace(unsigned width) {
117     if (globalRegSpace_ == NULL) initialize();
118     registerSpace *ret = (width == 4) ? globalRegSpace_ : globalRegSpace64_;
119     assert(ret);
120     return ret;
121 }
122
123 registerSpace *registerSpace::getRegisterSpace(AddressSpace *as) {
124     return getRegisterSpace(as->getAddressWidth());
125 }
126
127 registerSpace *registerSpace::conservativeRegSpace(AddressSpace *proc) {
128     registerSpace *ret = getRegisterSpace(proc);
129     ret->specializeSpace(arbitrary);
130     ret->initRealRegSpace();
131     return ret;
132 }
133
134 registerSpace *registerSpace::optimisticRegSpace(AddressSpace *proc) {
135     registerSpace *ret = getRegisterSpace(proc);
136     ret->specializeSpace(ABI_boundary);
137     ret->initRealRegSpace();
138
139     return ret;
140 }
141
142 registerSpace *registerSpace::irpcRegSpace(AddressSpace *proc) {
143    registerSpace *rspace = conservativeRegSpace(proc);
144    rspace->initRealRegSpace();
145    return rspace;
146 }
147
148 registerSpace *registerSpace::savedRegSpace(AddressSpace *proc) {
149     registerSpace *ret = getRegisterSpace(proc);
150     ret->specializeSpace(allSaved);
151     ret->initRealRegSpace();
152     return ret;
153 }
154
155 registerSpace *registerSpace::actualRegSpace(instPoint *iP)
156 {
157     // We just can't trust liveness in defensive mode.
158     if (BPatch_defensiveMode == iP->func()->obj()->hybridMode()) {
159         return conservativeRegSpace(iP->proc());
160     }
161    if (BPatch::bpatch->livenessAnalysisOn()) {
162       assert(iP);
163       registerSpace *ret = NULL;
164
165       ret = getRegisterSpace(iP->proc());
166       ret->specializeSpace(iP->liveRegisters());
167
168       ret->cleanSpace();
169       ret->initRealRegSpace();
170       return ret;
171    }
172     // Use one of the other registerSpaces...
173     // If we're entry/exit/call site, return the optimistic version
174     /*    if (iP->getPointType() == functionEntry)
175         return optimisticRegSpace(iP->proc());
176     if (iP->getPointType() == functionExit)
177         return optimisticRegSpace(iP->proc());
178     if (iP->getPointType() == callSite)
179     return optimisticRegSpace(iP->proc());*/
180
181     return conservativeRegSpace(iP->proc());
182 }
183
184
185 registerSpace::registerSpace() :
186     pc_rel_reg(0),
187     pc_rel_use_count(0),
188     instFrameSize_(0),
189     savedFlagSize(0),
190     currStackPointer(0),
191     addr_width(0)
192 {
193 }
194
195 registerSpace::~registerSpace()
196 {
197     for (auto i = registers_.begin(); i != registers_.end(); i++) {
198        delete i->second;
199     }
200 }
201
202 void registerSpace::createRegisterSpace(pdvector<registerSlot *> &registers) {
203     // We need to initialize the following:
204     // registers_ (std::unordered_map)
205     // GPRs_ (vector of pointers to elements in registers_
206     // FPRs_ (vector of pointers ...)
207     // SPRs_ (...)
208
209     assert(globalRegSpace_ == NULL);
210     globalRegSpace_ = new registerSpace();
211     globalRegSpace_->addr_width = 4;
212     createRegSpaceInt(registers, globalRegSpace_);
213
214 }
215
216 void registerSpace::createRegisterSpace64(pdvector<registerSlot *> &registers) {
217     // We need to initialize the following:
218     // registers_ (std::unordered_map)
219     // GPRs_ (vector of pointers to elements in registers_
220     // FPRs_ (vector of pointers ...)
221     // SPRs_ (...)
222
223     assert(globalRegSpace64_ == NULL);
224     globalRegSpace64_ = new registerSpace();
225     globalRegSpace64_->addr_width = 8;
226     createRegSpaceInt(registers, globalRegSpace64_);
227
228 }
229
230 void registerSpace::createRegSpaceInt(pdvector<registerSlot *> &registers,
231                                       registerSpace *rs) {
232     for (unsigned i = 0; i < registers.size(); i++) {
233         Register reg = registers[i]->number;
234
235         rs->registers_[reg] = registers[i];
236
237         rs->registersByName[registers[i]->name] = registers[i]->number;
238
239         switch (registers[i]->type) {
240         case registerSlot::GPR: {
241           bool physical = true;
242 #if defined(arch_x86) || defined(arch_x86_64)
243           if (rs->addr_width == 4)
244             physical = false;
245 #endif
246           if (physical) rs->physicalRegisters_[reg] = registers[i];
247
248           rs->GPRs_.push_back(registers[i]);
249           break;
250         }
251         case registerSlot::FPR:
252           rs->FPRs_.push_back(registers[i]);
253           break;
254         case registerSlot::SPR:
255           rs->SPRs_.push_back(registers[i]);
256           break;
257         case registerSlot::realReg:
258           rs->physicalRegisters_[reg] = registers[i];
259           rs->realRegisters_.push_back(registers[i]);
260           break;
261         default:
262             fprintf(stderr, "Error: no match for %d\n", registers[i]->type);
263             assert(0);
264             break;
265         }
266     }
267
268 }
269
270 bool registerSpace::trySpecificRegister(codeGen &gen, Register num,
271                                         bool noCost)
272 {
273   auto iter = registers_.find(num);
274   if (iter == registers_.end()) return false;
275   registerSlot *reg = iter->second;
276
277   if (reg->offLimits) return false;
278   else if (reg->refCount > 0) return false;
279   else if (reg->liveState == registerSlot::live) {
280      if (!spillRegister(num, gen, noCost)) {
281         return false;
282      }
283   }
284   else if (reg->keptValue) {
285      return false;
286   }
287
288   reg->markUsed(true);
289
290   regalloc_printf("Allocated register %d\n", num);
291
292   return true;
293 }
294
295 bool registerSpace::allocateSpecificRegister(codeGen &gen, Register num,
296                                              bool noCost)
297 {
298   regalloc_printf("Allocating specific register %d\n", num);
299
300   debugPrint();
301
302   auto iter = registers_.find(num);
303   if (iter == registers_.end()) {
304      regalloc_printf("Error: register does not exist!\n");
305      return false;
306   }
307
308   registerSlot *reg = iter->second;
309     if (reg->offLimits) {
310       regalloc_printf("Error: register off limits!\n");
311       return false;
312     }
313     else if (reg->refCount > 0) {
314       regalloc_printf("Error: register currently in use!\n");
315       return false;
316     }
317     else if (reg->liveState == registerSlot::live) {
318       if (!spillRegister(num, gen, noCost)) {
319         regalloc_printf("Error: specific register could not be spilled!\n");
320         return false;
321       }
322     }
323     else if (reg->keptValue) {
324       if (!stealRegister(num, gen, noCost)) {
325         regalloc_printf("Error: register has cached value, unable to steal!\n");
326         return false;
327       }
328     }
329
330     reg->markUsed(true);
331     gen.markRegDefined(reg->number);
332
333
334     regalloc_printf("Allocated register %d\n", num);
335
336     return true;
337 }
338
339 Register registerSpace::getScratchRegister(codeGen &gen, bool noCost, bool realReg) {
340     pdvector<Register> empty;
341     return getScratchRegister(gen, empty, noCost, realReg);
342 }
343
344 Register registerSpace::getScratchRegister(codeGen &gen, pdvector<Register> &excluded, bool noCost, bool realReg) {
345   static int num_allocs = 0;
346
347   pdvector<registerSlot *> couldBeStolen;
348   pdvector<registerSlot *> couldBeSpilled;
349
350   debugPrint();
351
352   registerSlot *toUse = NULL;
353
354   regalloc_printf("Allocating register: selection is %s\n",
355                   realReg ? (realRegisters_.empty() ? "GPRS" : "Real registers") : "GPRs");
356
357   pdvector<registerSlot *> &regs = (realReg ? (realRegisters_.empty() ? GPRs_ : realRegisters_ ) : GPRs_ );
358   regalloc_printf("%d options in registers\n", regs.size());
359
360   for (unsigned i = 0; i < regs.size(); i++) {
361     registerSlot *reg = regs[i];
362
363     regalloc_printf("%s[%d]: getting scratch register, examining %d of %d: reg %d (%s), offLimits %d, refCount %d, liveState %s, keptValue %d\n",
364                     FILE__, __LINE__, i, regs.size(),
365                     reg->number,
366                     reg->name.c_str(),
367                     reg->offLimits,
368                     reg->refCount,
369                     (reg->liveState == registerSlot::live) ? "live" : ((reg->liveState == registerSlot::dead) ? "dead" : "spilled"),
370                     reg->keptValue);
371
372     bool found = false;
373     for (unsigned int i = 0; i < excluded.size(); ++i) {
374       Register &ex_reg = excluded[i];
375       if (reg->number == ex_reg) {
376         found = true;
377         break;
378       }
379     }
380
381         if (found) continue;
382
383         if (reg->offLimits) continue;
384         if (reg->refCount > 0) continue;
385         if (reg->liveState == registerSlot::live) {
386             // Don't do anything for now, but add to the "could be" list
387             couldBeSpilled.push_back(reg);
388             continue;
389         }
390         if (reg->keptValue) {
391             // As above
392             couldBeStolen.push_back(reg);
393             continue;
394         }
395         // Hey, got one.
396         toUse = reg;
397         break;
398     }
399
400     if (toUse == NULL) {
401         // Argh. Let's assume spilling is cheaper
402         for (unsigned i = 0; i < couldBeSpilled.size(); i++) {
403             if (spillRegister(couldBeSpilled[i]->number, gen, noCost)) {
404                 toUse = couldBeSpilled[i];
405                 break;
406             }
407         }
408     }
409
410     // Still?
411     if (toUse == NULL) {
412         for (unsigned i = 0; i < couldBeStolen.size(); i++) {
413             if (stealRegister(couldBeStolen[i]->number, gen, noCost)) {
414                 toUse = couldBeStolen[i];
415                 break;
416             }
417         }
418     }
419
420     if (toUse == NULL) {
421         // Crap.
422       // debugPrint();
423         return REG_NULL;
424     }
425
426     toUse->alloc_num = num_allocs;
427     num_allocs++;
428
429   toUse->markUsed(false);
430
431   gen.markRegDefined(toUse->number);
432
433   return toUse->number;
434 }
435
436 Register registerSpace::allocateRegister(codeGen &gen,
437                                          bool noCost,
438                                          bool realReg)
439 {
440   regalloc_printf("Allocating and retaining register...\n");
441   Register reg = getScratchRegister(gen, noCost, realReg);
442   regalloc_printf("retaining register %d\n", reg);
443   if (reg == REG_NULL) return REG_NULL;
444   if (realReg) {
445     physicalRegs(reg)->refCount = 1;
446   }
447   else {
448     registers_[reg]->refCount = 1;
449   }
450   regalloc_printf("Allocated register %d\n", reg);
451   return reg;
452 }
453
454 bool registerSpace::spillRegister(Register reg, codeGen &, bool /*noCost*/) {
455   assert(!registers_[reg]->offLimits);
456
457   //assert(0 && "Unimplemented!");
458   return false;
459 }
460
461 bool registerSpace::stealRegister(Register reg, codeGen &gen, bool /*noCost*/) {
462     // Can be made a return false; this for correctness.
463     assert(registers_[reg]->refCount == 0);
464     assert(registers_[reg]->keptValue == true);
465     assert(registers_[reg]->liveState != registerSlot::live);
466
467     regalloc_printf("Stealing register %d\n", reg);
468
469     // Let the AST know it just lost...
470     if (!gen.tracker()->stealKeptRegister(registers_[reg]->number)) return false;
471     registers_[reg]->keptValue = false;
472
473     return true;
474 }
475
476
477 // This might mean something different later, but for now means
478 // "Save special purpose registers". We may want to define a "volatile"
479 // later - something like "can be unintentionally nuked". For example,
480 // x86 flags register.
481 #if defined(arch_x86_64) || defined(arch_x86)
482 bool registerSpace::checkVolatileRegisters(codeGen & /*gen*/,
483                                            registerSlot::livenessState_t state)
484 {
485    if (addr_width == 8) {
486       if (registers_[REGNUM_EFLAGS]->liveState == state) {
487          // Must have been an override from somewhere...
488          return true;
489       }
490       for (unsigned i = REGNUM_OF; i <= REGNUM_RF; i++) {
491          if (registers_[i]->liveState == state)
492             return true;
493       }
494       return false;
495    }
496
497    assert(addr_width == 4);
498    return (registers_[IA32_FLAG_VIRTUAL_REGISTER]->liveState == state);
499 }
500 #else
501 bool registerSpace::checkVolatileRegisters(codeGen &,
502                                            registerSlot::livenessState_t)
503 {
504     assert(0);
505     return false;
506 }
507 #endif
508
509 #if defined(arch_x86_64) || defined(arch_x86)
510 bool registerSpace::saveVolatileRegisters(codeGen &gen)
511 {
512     savedFlagSize = 0;
513     if (!checkVolatileRegisters(gen, registerSlot::live))
514         return false;
515
516     // Okay, save.
517     if (addr_width == 8) {
518         // save flags (PUSHFQ)
519        //emitSimpleInsn(0x9C, gen);
520        bool override = false;
521        if (registers_[REGNUM_EFLAGS]->liveState == registerSlot::live) {
522           override = true;
523           registers_[REGNUM_EFLAGS]->liveState = registerSlot::spilled;
524        }
525        if (registers_[REGNUM_SF]->liveState == registerSlot::live ||
526            registers_[REGNUM_ZF]->liveState == registerSlot::live ||
527            registers_[REGNUM_AF]->liveState == registerSlot::live ||
528            registers_[REGNUM_PF]->liveState == registerSlot::live ||
529            registers_[REGNUM_CF]->liveState == registerSlot::live ||
530            override) {
531           emitSimpleInsn(0x9f, gen);
532           registers_[REGNUM_SF]->liveState = registerSlot::spilled;
533           registers_[REGNUM_ZF]->liveState = registerSlot::spilled;
534           registers_[REGNUM_AF]->liveState = registerSlot::spilled;
535           registers_[REGNUM_PF]->liveState = registerSlot::spilled;
536           registers_[REGNUM_CF]->liveState = registerSlot::spilled;
537           registers_[REGNUM_CF]->liveState = registerSlot::spilled;
538        }
539        if (registers_[REGNUM_OF]->liveState == registerSlot::live ||
540            override) {
541           emitSaveO(gen);
542           registers_[REGNUM_OF]->liveState = registerSlot::spilled;
543        }
544
545     } else {
546         assert(addr_width == 4);
547
548         emitPush(RealRegister(REGNUM_EAX), gen);
549         emitSimpleInsn(0x9f, gen);
550         emitSaveO(gen);
551         gen.markRegDefined(REGNUM_EAX);
552         //emitSimpleInsn(PUSHFD, gen);
553         registers_[IA32_FLAG_VIRTUAL_REGISTER]->liveState =
554             registerSlot::spilled;
555
556     }
557
558     savedFlagSize = addr_width;
559     return true;
560 }
561 #else
562 bool registerSpace::saveVolatileRegisters(codeGen &) {
563     assert(0);
564     return true;
565 }
566 #endif
567
568 #if defined(arch_x86_64) || defined(arch_x86)
569 bool registerSpace::restoreVolatileRegisters(codeGen &gen)
570 {
571     if (!checkVolatileRegisters(gen, registerSlot::spilled))
572         return false;
573
574     // Okay, restore.
575     if (addr_width == 8) {
576        if (registers_[REGNUM_OF]->liveState == registerSlot::spilled) {
577           emitRestoreO(gen);
578        }
579        if (registers_[REGNUM_SF]->liveState == registerSlot::spilled ||
580            registers_[REGNUM_ZF]->liveState == registerSlot::spilled ||
581            registers_[REGNUM_AF]->liveState == registerSlot::spilled ||
582            registers_[REGNUM_PF]->liveState == registerSlot::spilled ||
583            registers_[REGNUM_CF]->liveState == registerSlot::spilled) {
584           emitSimpleInsn(0x9e, gen);
585        }
586
587     } else {
588         assert(addr_width == 4);
589
590         emitRestoreO(gen);
591         emitSimpleInsn(0x9E, gen);
592         emitPop(RealRegister(REGNUM_EAX), gen);
593         // State stays at spilled, which is incorrect - but will never matter.
594
595     }
596
597     return true;
598 }
599 #else
600 bool registerSpace::restoreVolatileRegisters(codeGen &) {
601     assert(0);
602     return true;
603 }
604 #endif
605
606 // Free the specified register (decrement its refCount)
607 void registerSpace::freeRegister(Register num)
608 {
609     registerSlot *reg = findRegister(num);
610     if (!reg) return;
611
612     reg->refCount--;
613     regalloc_printf("Freed register %d: refcount now %d\n", num, reg->refCount);
614
615     if( reg->refCount < 0 ) {
616         //bperr( "Freed free register!\n" );
617         reg->refCount = 0;
618     }
619
620 #if defined(arch_x86) || defined(arch_x86_64)
621     if (addr_width == 4) {
622       if (reg->refCount == 0 && !registers_[num]->keptValue) {
623         markVirtualDead(num);
624       }
625     }
626 #endif
627     return;
628
629 }
630
631 // Free the register even if its refCount is greater that 1
632 void registerSpace::forceFreeRegister(Register num)
633 {
634     registerSlot *reg = findRegister(num);
635     if (!reg) return;
636
637     reg->refCount = 0;
638 }
639
640 // DO NOT USE THIS!!!! to tell if you can use a register as
641 // a scratch register; do that with trySpecificRegister
642 // or allocateSpecificRegister. This is _ONLY_ to determine
643 // if a register should be saved (e.g., over a call).
644 bool registerSpace::isFreeRegister(Register num) {
645     registerSlot *reg = findRegister(num);
646     if (!reg) return false;
647
648     if (reg->refCount > 0)
649         return false;
650     if (reg->keptValue)
651       return false;
652     return true;
653 }
654
655 // Bump up the reference count. Occasionally, we underestimate it
656 // and call this routine to correct this.
657 void registerSpace::incRefCount(Register num)
658 {
659     registerSlot *reg = findRegister(num);
660     if (!reg) return;
661     reg->refCount++;
662 }
663
664 void registerSpace::cleanSpace() {
665     regalloc_printf("============== CLEAN ==============\n");
666
667     for (auto i = registers_.begin(); i != registers_.end(); i++) {
668         i->second->cleanSlot();
669     }
670     for (unsigned i=0; i<realRegisters_.size(); i++) {
671        realRegisters_[i]->cleanSlot();
672     }
673 }
674
675 bool registerSpace::restoreAllRegisters(codeGen &, bool) {
676     assert(0);
677     return true;
678 }
679
680 bool registerSpace::restoreRegister(Register, codeGen &, bool /*noCost*/)
681 {
682     assert(0);
683     return true;
684 }
685
686 bool registerSpace::popRegister(Register, codeGen &, bool) {
687     assert(0);
688     return true;
689 }
690
691 bool registerSpace::markReadOnly(Register) {
692     assert(0);
693     return true;
694 }
695
696 bool registerSpace::readProgramRegister(codeGen &gen,
697                                         Register source,
698                                         Register destination,
699                                         unsigned
700 #if !defined(arch_power)
701                                         size
702 #endif
703 )
704 {
705 #if !defined(arch_power)
706     emitLoadPreviousStackFrameRegister((Address)source,
707                                        destination,
708                                        gen,
709                                        size,
710                                        true);
711     return true;
712 #elif defined(arch_aarch64)
713 //#warning "This fucntion is not implemented yet!"
714                 assert(0);
715                 return false;
716 #else
717     // Real version that uses stored information
718
719     // First step: identify the registerSlot that contains information
720     // about the source register.
721     // cap_emitter
722
723
724     registerSlot *src = registers_[source];
725     // If we didn't find src we just corrupted registers_; assert fail.
726     // AND FIX THE STRUCTURE.
727     assert(src);
728     registerSlot *dest = registers_[destination];
729     assert(dest);
730
731     // Okay. We need to know where the register is compared with our
732     // current location vis-a-vis the stack pointer. Now, on most
733     // platforms this doesn't matter, as the SP never moves. Well, not
734     // so x86.
735     switch (src->spilledState) {
736     case registerSlot::unspilled:
737
738         gen.codeEmitter()->emitMoveRegToReg(src, dest, gen);
739         return true;
740         break;
741     case registerSlot::framePointer: {
742         registerSlot *frame = registers_[framePointer()];
743         assert(frame);
744
745         // We can't use existing mechanisms because they're all built
746         // off the "non-instrumented" case - emit a load from the
747         // "original" frame pointer, whereas we want the current one.
748         gen.codeEmitter()->emitLoadRelative(destination, src->saveOffset, framePointer(),  gen.addrSpace()->getAddressWidth(), gen);
749         return true;
750         break;
751     }
752     default:
753         assert(0);
754         return false;
755         break;
756     }
757 #endif
758
759 }
760 bool registerSpace::writeProgramRegister(codeGen &gen,
761                                          Register destination,
762                                          Register source,
763                                          unsigned) {
764 #if defined(arch_aarch64)
765                 //not implemented yet
766                 return false;
767 #else
768     registerSlot *src = registers_[source];
769     assert(source);
770     registerSlot *dest = registers_[destination];
771     assert(dest);
772
773     // Okay. We need to know where the register is compared with our
774     // current location vis-a-vis the stack pointer. Now, on most
775     // platforms this doesn't matter, as the SP never moves. Well, not
776     // so x86.
777
778     switch (src->spilledState) {
779     case registerSlot::unspilled:
780         if (source != destination)
781             gen.codeEmitter()->emitMoveRegToReg(source, destination, gen);
782         return true;
783         break;
784     case registerSlot::framePointer: {
785         registerSlot *frame = registers_[framePointer()];
786         assert(frame);
787
788         // When this register was saved we stored its offset from the base pointer.
789         // Use that to load it.
790         gen.codeEmitter()->emitStoreRelative(source, dest->saveOffset, framePointer(), gen.addrSpace()->getAddressWidth(), gen);
791         return true;
792         break;
793     }
794     default:
795         assert(0);
796         return false;
797         break;
798     }
799 #endif
800 }
801
802
803 registerSlot *registerSpace::findRegister(Register source) {
804     // Oh, oops... we're handed a register number... and we can't tell if it's
805     // GPR, FPR, or SPR...
806     if (source == REG_NULL) return NULL;
807
808     auto iter = registers_.find(source);
809     if (iter == registers_.end()) return NULL;
810     return iter->second;
811 }
812
813 registerSlot *registerSpace::findRegister(RealRegister source) {
814     return realRegisters_[source.reg()];
815 }
816
817 bool registerSpace::markSavedRegister(RealRegister num, int offsetFromFP) {
818    regalloc_printf("Marking register %d as saved, %d from frame pointer\n",
819                    num.reg(), offsetFromFP);
820    registerSlot *s = findRegister(num);
821    return markSavedRegister(s, offsetFromFP);
822 }
823
824 bool registerSpace::markSavedRegister(Register num, int offsetFromFP) {
825     regalloc_printf("Marking register %d as saved, %d from frame pointer\n",
826                     num, offsetFromFP);
827     // Find the register slot
828     registerSlot *s = findRegister(num);
829     return markSavedRegister(s, offsetFromFP);
830 }
831
832 bool registerSpace::markSavedRegister(registerSlot *s, int offsetFromFP) {
833     if (s == NULL)  {
834         // We get this on platforms where we save registers we don't use in
835         // code generation... like, say, RSP or RBP on AMD-64.
836         //fprintf(stderr, "ERROR: unable to find register %d\n", num);
837         return false;
838     }
839
840     if (s->spilledState != registerSlot::unspilled) {
841         // Things to do... add this check in, yo. Right now we don't clean
842         // properly.
843
844 //        assert(0);
845     }
846
847     s->liveState = registerSlot::spilled;
848
849     s->spilledState = registerSlot::framePointer;
850     s->saveOffset = offsetFromFP;
851     return true;
852 }
853
854 void registerSlot::debugPrint(const char *prefix) {
855     if (!dyn_debug_regalloc) return;
856
857         if (prefix) fprintf(stderr, "%s", prefix);
858         fprintf(stderr, "Num: %d, name %s, type %s, refCount %d, liveState %s, beenUsed %d, initialState %s, offLimits %d, keptValue %d, alloc %d\n",
859                 number,
860                 name.c_str(),
861                 (type == GPR) ? "GPR" : ((type == FPR) ? "FPR" : "SPR"),
862                 refCount,
863                 (liveState == live ) ? "live" : ((liveState == spilled) ? "spilled" : "dead"),
864                 beenUsed,
865                 (initialState == deadAlways) ? "always dead" : ((initialState == deadABI) ? "ABI dead" : "always live"),
866                 offLimits,
867                 keptValue,
868                 alloc_num);
869 }
870
871 void registerSpace::debugPrint() {
872   if (!dyn_debug_regalloc) return;
873
874   // Dump out our data
875   fprintf(stderr, "Beginning debug print of registerSpace at %p...", this);
876   fprintf(stderr, "GPRs: %ld, FPRs: %ld, SPRs: %ld\n",
877           (long) GPRs_.size(), (long) FPRs_.size(), (long) SPRs_.size());
878   fprintf(stderr, "Stack pointer is at %d\n",
879           currStackPointer);
880   fprintf(stderr, "Register dump:");
881   fprintf(stderr, "=====GPRs=====\n");
882   for (unsigned i = 0; i < GPRs_.size(); i++) {
883     GPRs_[i]->debugPrint("\t");
884   }
885   fprintf(stderr, "=====FPRs=====\n");
886   for (unsigned i = 0; i < FPRs_.size(); i++) {
887     FPRs_[i]->debugPrint("\t");
888   }
889   fprintf(stderr, "=====SPRs=====\n");
890   for (unsigned i = 0; i < SPRs_.size(); i++) {
891     SPRs_[i]->debugPrint("\t");
892   }
893   fprintf(stderr, "=====RealRegs=====\n");
894   for (unsigned i = 0; i < realRegisters_.size(); i++) {
895     realRegisters_[i]->debugPrint("\t");
896   }
897 }
898
899 bool registerSpace::markKeptRegister(Register reg) {
900         regalloc_printf("Marking register %d as kept\n", reg);
901    registers_[reg]->keptValue = true;
902    return false;
903 }
904
905 void registerSpace::unKeepRegister(Register reg) {
906         regalloc_printf("Marking register %d as unkept\n", reg);
907    registers_[reg]->keptValue = false;
908 }
909
910
911 void registerSpace::specializeSpace(rs_location_t state) {
912     for (auto i = registers_.begin(); i != registers_.end(); i++) {
913         registerSlot *reg = i->second;
914         switch (state) {
915         case arbitrary:
916             if (reg->initialState == registerSlot::deadAlways)
917                 reg->liveState = registerSlot::dead;
918             else
919                 reg->liveState = registerSlot::live;
920             break;
921         case ABI_boundary:
922             if ((reg->initialState == registerSlot::deadABI) ||
923                 (reg->initialState == registerSlot::deadAlways))
924                 reg->liveState = registerSlot::dead;
925             else
926                 reg->liveState = registerSlot::live;
927             break;
928         case allSaved:
929             reg->liveState = registerSlot::dead;
930             break;
931         default:
932             assert(0);
933         }
934     }
935     cleanSpace();
936
937     regalloc_printf("%s[%d]: specialize space done with argument %d\n", FILE__, __LINE__, state);
938 }
939
940 bool registerSpace::anyLiveGPRsAtEntry() const {
941     for (unsigned i = 0; i < GPRs_.size(); i++) {
942         if (GPRs_[i]->liveState != registerSlot::dead)
943             return true;
944     }
945     return false;
946 }
947
948 bool registerSpace::anyLiveFPRsAtEntry() const {
949     for (unsigned i = 0; i < FPRs_.size(); i++) {
950         if (FPRs_[i]->liveState != registerSlot::dead)
951             return true;
952     }
953     return false;
954 }
955
956 bool registerSpace::anyLiveSPRsAtEntry() const {
957     for (unsigned i = 0; i < SPRs_.size(); i++) {
958         if (SPRs_[i]->liveState != registerSlot::dead)
959             return true;
960     }
961     return false;
962 }
963
964 pdvector<registerSlot *>& registerSpace::trampRegs()
965 {
966 #if defined(arch_x86) || defined(arch_x86_64)
967    if (addr_width == 4)
968       return realRegs();
969 #endif
970    return GPRs_;
971 }
972
973 registerSlot *registerSpace::operator[](Register reg) {
974     return registers_[reg];
975 }
976
977
978 // Big honkin' name->register map
979
980 void registerSpace::getAllRegisterNames(std::vector<std::string> &ret) {
981     // Currently GPR only
982     for (unsigned i = 0; i < GPRs_.size(); i++) {
983         ret.push_back(GPRs_[i]->name);
984     }
985 }
986
987 Register registerSpace::getRegByName(const std::string name) {
988     map<std::string,Register>::iterator cur = registersByName.find(name);
989     if (cur == registersByName.end())
990         return REG_NULL;
991     return (*cur).second;
992 }
993
994 std::string registerSpace::getRegByNumber(Register reg) {
995     return registers_[reg]->name;
996 }
997
998 // If we have defined realRegisters_ (IA-32 and 32-bit mode AMD-64)
999 // return that. Otherwise return GPRs.
1000 pdvector<registerSlot *> &registerSpace::realRegs() {
1001     if (realRegisters_.size())
1002        return realRegisters_;
1003     else
1004        return GPRs();
1005 }
1006
1007 RealRegister registerSpace::findReal(registerSlot *virt_r, bool &already_setup)
1008 {
1009    assert(virt_r);
1010
1011    int oldest_reg = -1;
1012    int oldest_free_reg = -1;
1013    int used_free_reg = -1;
1014    already_setup = false;
1015
1016    for (unsigned i=0; i<regState().size(); i++) {
1017       RealRegsState &real_reg = regState()[i];
1018       if (!real_reg.is_allocatable)
1019          continue;
1020
1021       if (virt_r == real_reg.contains) {
1022          //We already have this virtual register stored in a real register.
1023          // just return it.
1024          real_reg.last_used = timeline()++;
1025          already_setup = true;
1026          return RealRegister(i);
1027       }
1028       if (!real_reg.contains &&
1029           real_reg.been_used)
1030       {
1031          used_free_reg = i;
1032       }
1033       if (!real_reg.contains &&
1034           (oldest_free_reg == -1 ||
1035            real_reg.last_used < regState()[oldest_free_reg].last_used))
1036       {
1037          //There's a free register, remember it.
1038          oldest_free_reg = i;
1039       }
1040       if (real_reg.contains &&
1041           (oldest_reg == -1 ||
1042            real_reg.last_used < regState()[oldest_reg].last_used))
1043       {
1044          //Keep track of the LRU register, in case we don't
1045          // have anything free.  LRU isn't ideal for register
1046          // allocation, but we're trying to keep this single pass.
1047          oldest_reg = i;
1048       }
1049    }
1050
1051    //We shouldn't have no free registers and no oldest alloced registers.
1052    assert(oldest_free_reg != -1 || oldest_reg != -1 || used_free_reg != -1);
1053    if (used_free_reg != -1)
1054       return RealRegister(used_free_reg);
1055    if (oldest_free_reg != -1) {
1056       return RealRegister(oldest_free_reg);
1057    }
1058    return RealRegister(oldest_reg);
1059 }
1060
1061 void registerSpace::spillReal(RealRegister r, codeGen &gen)
1062 {
1063    if (!regState()[r.reg()].is_allocatable)
1064       return;
1065    if (!regState()[r.reg()].contains)
1066       return;
1067
1068    if (regState()[r.reg()].contains->refCount == 0 &&
1069        !regState()[r.reg()].contains->keptValue) {
1070       // Sure, it's spilled...
1071       freeReal(r);
1072       return;
1073    }
1074
1075    regs_been_spilled.insert(regState()[r.reg()].contains);
1076    spillToVReg(r, regState()[r.reg()].contains, gen);
1077    freeReal(r);
1078 }
1079
1080 void registerSpace::loadReal(RealRegister r, registerSlot *virt_r, codeGen &gen)
1081 {
1082
1083    assert(!regState()[r.reg()].contains);
1084    if (regs_been_spilled.count(virt_r)) {
1085       movVRegToReal(virt_r, r, gen);
1086    }
1087    regState()[r.reg()].contains = virt_r;
1088    regState()[r.reg()].last_used = timeline()++;
1089 }
1090
1091 void registerSpace::freeReal(RealRegister r)
1092 {
1093   regalloc_printf("Freeing register %d\n", r.reg());
1094    assert(regState()[r.reg()].contains);
1095    regState()[r.reg()].contains = NULL;
1096    regState()[r.reg()].last_used = timeline()++;
1097 }
1098
1099 RealRegister registerSpace::loadVirtual(registerSlot *virt_r, codeGen &gen)
1100 {
1101    assert(virt_r);
1102    bool done;
1103
1104    RealRegister reg_to_use = findReal(virt_r, done);
1105    if (done) {
1106       return reg_to_use;
1107    }
1108
1109    spillReal(reg_to_use, gen);
1110    loadReal(reg_to_use, virt_r, gen);
1111
1112    return reg_to_use;
1113 }
1114
1115 RealRegister registerSpace::loadVirtual(Register virt_r, codeGen &gen)
1116 {
1117    return loadVirtual((*this)[virt_r], gen);
1118 }
1119
1120 RealRegister registerSpace::loadVirtualForWrite(registerSlot *virt_r, codeGen &gen)
1121 {
1122    assert(virt_r);
1123    bool done;
1124
1125    RealRegister reg_to_use = findReal(virt_r, done);
1126    if (done) {
1127       return reg_to_use;
1128    }
1129
1130    spillReal(reg_to_use, gen);
1131    regState()[reg_to_use.reg()].contains = virt_r;
1132    regState()[reg_to_use.reg()].last_used = timeline()++;
1133
1134    gen.markRegDefined(reg_to_use.reg());
1135    return reg_to_use;
1136 }
1137
1138 RealRegister registerSpace::loadVirtualForWrite(Register virt_r, codeGen &gen)
1139 {
1140    return loadVirtualForWrite((*this)[virt_r], gen);
1141 }
1142
1143 void registerSpace::makeRegisterAvail(RealRegister r, codeGen &gen) {
1144    spillReal(r, gen);
1145    gen.markRegDefined(r.reg());
1146 }
1147
1148 void registerSpace::noteVirtualInReal(registerSlot *v_r, RealRegister r_r)
1149 {
1150   regalloc_printf("Noting virtual %s in real reg %d\n",
1151                   (v_r ? v_r->name.c_str() : "<NULL>"), r_r.reg());
1152
1153    int reg = r_r.reg();
1154
1155    bool already_allocd;
1156    RealRegister old_location = findReal(v_r, already_allocd);
1157    if (already_allocd) {
1158       regState()[old_location.reg()].contains = NULL;
1159       regState()[old_location.reg()].last_used = timeline()++;
1160    }
1161
1162    if (regState()[reg].contains) {
1163      assert(0);
1164    }
1165    regState()[reg].contains = v_r;
1166    regState()[reg].last_used = timeline()++;
1167 }
1168
1169 void registerSpace::noteVirtualInReal(Register v_r, RealRegister r_r)
1170 {
1171    noteVirtualInReal((*this)[v_r], r_r);
1172 }
1173
1174 void registerSpace::loadVirtualToSpecific(registerSlot *virt_r, RealRegister real_r, codeGen &gen)
1175 {
1176    bool already_in_reg;
1177    RealRegister old_loc = findReal(virt_r, already_in_reg);
1178    if (already_in_reg && old_loc.reg() == real_r.reg()) {
1179       return;
1180    }
1181
1182    spillReal(real_r, gen);
1183
1184    if (already_in_reg) {
1185       movRegToReg(real_r, old_loc, gen);
1186       freeReal(old_loc);
1187    }
1188    else {
1189       loadReal(real_r, virt_r, gen);
1190    }
1191 }
1192
1193 void registerSpace::loadVirtualToSpecific(Register virt_r, RealRegister real_r, codeGen &gen)
1194 {
1195    loadVirtualToSpecific((*this)[virt_r], real_r, gen);
1196 }
1197
1198 void registerSpace::markVirtualDead(Register num)
1199 {
1200    registerSlot *slot = (*this)[num];
1201    for (unsigned i=0; i<regState().size(); i++) {
1202       if (regState()[i].contains == slot) {
1203          regState()[i].contains = NULL;
1204          regState()[i].last_used = 0;
1205       }
1206    }
1207 }
1208
1209 bool registerSpace::spilledAnything()
1210 {
1211    return regs_been_spilled.size() != 0;
1212 }
1213
1214 /**
1215  * This handles merging register states at merges
1216  * in the generated code CFG.  Used for things like
1217  * 'if' statements.
1218  * Takes the top level registerState (e.g, the code that was
1219  * generated in an 'if') and emits the saves/restores such to
1220  * takes us back to the preceding registerState (e.g, the code
1221  * we would be in if the 'if' hadn't executed).
1222  **/
1223 void registerSpace::unifyTopRegStates(codeGen &gen)
1224 {
1225    if (addr_width == 8) {
1226       //Not implemented on x86_64 yet
1227       return;
1228    }
1229    if (regStateStack.size() == 0)
1230       return;
1231    assert(regStateStack.size() >= 2);
1232    regState_t *src = regStateStack[regStateStack.size() - 1];
1233    regState_t *dest = regStateStack[regStateStack.size() - 2];
1234
1235    assert(src->registerStates.size() == dest->registerStates.size());
1236
1237    //Make a map of loaded dest virtuals -> reals
1238    std::map<registerSlot*, unsigned> dest_virts;
1239    for (unsigned i=0; i<dest->registerStates.size(); i++) {
1240       RealRegsState &rrs = dest->registerStates[i];
1241       if (!rrs.is_allocatable || !rrs.contains)
1242          continue;
1243       dest_virts[rrs.contains] = i;
1244    }
1245
1246    //For any loaded virtual in src that's not loaded or not loaded in the
1247    // proper place in dest,  unload that virtual in src.
1248    for (unsigned i=0; i<src->registerStates.size(); i++) {
1249       RealRegsState &rrs = src->registerStates[i];
1250       if (!rrs.is_allocatable || !rrs.contains) {
1251          //Unloaded in src or uninteresting register
1252          continue;
1253       }
1254       std::map<registerSlot*, unsigned>::iterator j = dest_virts.find(rrs.contains);
1255       if (j != dest_virts.end() && (*j).second == i) {
1256          //Loaded in the same place in dest and src
1257          continue;
1258       }
1259       spillReal(RealRegister(i), gen);
1260    }
1261
1262    //Make a map of loaded src virtuals -> reals
1263    std::map<registerSlot*, unsigned> src_virts;
1264    for (unsigned i=0; i<src->registerStates.size(); i++) {
1265       RealRegsState &rrs = src->registerStates[i];
1266       if (!rrs.is_allocatable || !rrs.contains)
1267          continue;
1268       src_virts[rrs.contains] = i;
1269    }
1270
1271    //For any loaded virtual in dest that's not loaded in src,
1272    // load that virtual in src.
1273    for (unsigned i=0; i<dest->registerStates.size(); i++) {
1274       RealRegsState &rrs = dest->registerStates[i];
1275       if (!rrs.is_allocatable || !rrs.contains) {
1276          //Unloaded in src or uninteresting register
1277          continue;
1278       }
1279       std::map<registerSlot*, unsigned>::iterator j = src_virts.find(rrs.contains);
1280       if (j != src_virts.end()) {
1281          //Loaded in src
1282          assert((*j).second == i); //assert it's loaded in the same place
1283          continue;
1284       }
1285       loadReal(RealRegister(i), rrs.contains, gen);
1286    }
1287
1288    for (unsigned i=0; i<src->registerStates.size(); i++) {
1289       assert(src->registerStates[i].contains == dest->registerStates[i].contains);
1290    }
1291
1292    if (dest->pc_rel_offset == -1 && src->pc_rel_offset != -1) {
1293       //src allocated a register for the PCREL operations.  We'll
1294       // have to free that bad boy.
1295       gen.rs()->freeRegister(gen.rs()->pc_rel_reg);
1296    }
1297    regStateStack.pop_back();
1298    delete src;
1299 }
1300
1301 void registerSpace::pushNewRegState()
1302 {
1303    if (regStateStack.size() == 0)
1304       return;
1305    regState_t *new_top = new regState_t();
1306    regState_t *old_top = regStateStack[regStateStack.size()-1];
1307    new_top->pc_rel_offset = old_top->pc_rel_offset;
1308    new_top->timeline = old_top->timeline;
1309    new_top->registerStates = old_top->registerStates;
1310    new_top->stack_height = old_top->stack_height;
1311    regStateStack.push_back(new_top);
1312 }
1313
1314 #if defined(arch_x86) || defined(arch_x86_64)
1315 int& registerSpace::pc_rel_offset()
1316 {
1317    if (!regStateStack.size())
1318       initRealRegSpace();
1319    return regStateStack[regStateStack.size()-1]->pc_rel_offset;
1320 }
1321
1322 int& registerSpace::timeline()
1323 {
1324    if (!regStateStack.size())
1325       initRealRegSpace();
1326    return regStateStack[regStateStack.size()-1]->timeline;
1327 }
1328
1329 std::vector<RealRegsState>& registerSpace::regState()
1330 {
1331    if (!regStateStack.size())
1332       initRealRegSpace();
1333
1334    return regStateStack[regStateStack.size()-1]->registerStates;
1335 }
1336
1337 void registerSpace::incStack(int val) {
1338    if (!regStateStack.size())
1339       initRealRegSpace();
1340    regStateStack[regStateStack.size()-1]->stack_height += val;
1341 }
1342
1343 void registerSpace::setStackHeight(int val) {
1344    if (!regStateStack.size())
1345       initRealRegSpace();
1346    regStateStack[regStateStack.size()-1]->stack_height = val;
1347 }
1348
1349 int registerSpace::getStackHeight()
1350 {
1351    if (!regStateStack.size())
1352       initRealRegSpace();
1353    return regStateStack[regStateStack.size()-1]->stack_height;
1354 }
1355
1356 void registerSpace::setInstFrameSize(int val) {
1357     instFrameSize_ = val;
1358 }
1359
1360 int registerSpace::getInstFrameSize() {
1361     return instFrameSize_;
1362 }
1363
1364
1365 #endif
1366
1367 #if !defined(arch_x86) && !defined(arch_x86_64)
1368 void registerSpace::initRealRegSpace()
1369 {
1370 }
1371
1372 void registerSpace::spillToVReg(RealRegister /*reg*/, registerSlot * /*v_reg*/,
1373                                 codeGen & /*gen*/)
1374 {
1375    assert(0);
1376 }
1377
1378 void registerSpace::movVRegToReal(registerSlot * /*v_reg*/, RealRegister /*r*/,
1379                                   codeGen & /*gen*/)
1380 {
1381    assert(0);
1382 }
1383
1384 void registerSpace::movRegToReg(RealRegister /*dest*/, RealRegister /*src*/, codeGen & /*gen*/)
1385 {
1386    assert(0);
1387 }
1388
1389 regState_t::regState_t()
1390 {
1391    assert(0);
1392 }
1393
1394 int& registerSpace::pc_rel_offset()
1395 {
1396    static int none = 0;
1397    return none;
1398 }
1399
1400 int& registerSpace::timeline()
1401 {
1402    static int none = 0;
1403    return none;
1404 }
1405
1406 std::vector<RealRegsState>& registerSpace::regState()
1407 {
1408    static std::vector<RealRegsState> none;
1409    return none;
1410 }
1411
1412 void registerSpace::incStack(int) {
1413 }
1414
1415 void registerSpace::setStackHeight(int) {
1416 }
1417
1418 int registerSpace::getStackHeight()
1419 {
1420    return 0;
1421 }
1422 #endif
1423
1424
1425 void registerSpace::specializeSpace(const bitArray &liveRegs) {
1426     // Liveness info is stored as a single bitarray for all registers.
1427
1428 #if defined(arch_x86) || defined(arch_x86_64)
1429     // We use "virtual" registers on the IA-32 platform (or AMD-64 in
1430     // 32-bit mode), and thus the registerSlot objects have _no_ relation
1431     // to the liveRegs input set. We handle this as a special case, and
1432     // look only for the flags representation (which is used to set
1433     // the IA32_FLAG_VIRTUAL_REGISTER "register"
1434    if (addr_width == 4) {
1435       for (unsigned i = 1; i <= NUM_VIRTUAL_REGISTERS; i++) {
1436          registers_[i]->liveState = registerSlot::dead;
1437       }
1438       registers_[IA32_FLAG_VIRTUAL_REGISTER]->liveState = registerSlot::dead;
1439       for (unsigned i = REGNUM_OF; i <= REGNUM_RF; i++) {
1440          if (checkLive(i, liveRegs)) {
1441             registers_[IA32_FLAG_VIRTUAL_REGISTER]->liveState = registerSlot::live;
1442             break;
1443          }
1444       }
1445
1446       for (unsigned i = 0; i < realRegisters_.size(); ++i) {
1447          if (checkLive(realRegisters_[i]->number, liveRegs))
1448             realRegisters_[i]->liveState = registerSlot::live;
1449          else
1450             realRegisters_[i]->liveState = registerSlot::dead;
1451       }
1452
1453       // All we care about for now.
1454       return;
1455    }
1456 #endif
1457    for (auto i = registers_.begin(); i != registers_.end(); i++) {
1458       if (checkLive(i->second->number, liveRegs))
1459          i->second->liveState = registerSlot::live;
1460       else
1461       {
1462          i->second->liveState = registerSlot::dead;
1463       }
1464    }
1465 }
1466
1467 bool registerSpace::checkLive(Register reg, const bitArray &liveRegs){
1468         static LivenessAnalyzer live1(4);
1469         static LivenessAnalyzer live2(8);
1470         std::pair<std::multimap<Register, MachRegister>::iterator, std::multimap<Register, MachRegister>::iterator> range;
1471         LivenessAnalyzer *live;
1472         if (addr_width == 4){
1473 #if defined(arch_aarch64)
1474         assert(0);
1475         //#error "aarch64 should not be 32bit long"
1476 #else
1477                 range = regToMachReg32.equal_range(reg);
1478                 live = &live1;
1479 #endif
1480         }
1481         else {
1482                 range = regToMachReg64.equal_range(reg);
1483                 live = &live2;
1484         }
1485         if (range.first == range.second) assert(0);
1486         for (std::multimap<Register, MachRegister>::iterator iter = range.first; iter != range.second; ++iter)
1487                 if (liveRegs[live->getIndex(iter->second)]) return true;
1488
1489         return false;
1490 }