A working, but not yet complete, implementation of backward slicing.
[dyninst.git] / common / src / dyn_regs.C
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 #define DYN_DEFINE_REGS
33 #include "dynutil/h/dyn_regs.h"
34
35 #include "external/rose/rose-compat.h"
36 #include "external/rose/powerpcInstructionEnum.h"
37
38 #include <iostream>
39
40 using namespace Dyninst;
41
42 std::map<signed int, const char *> *Dyninst::MachRegister::names;
43
44 MachRegister::MachRegister() :
45    reg(0)
46
47 }
48
49 MachRegister::MachRegister(signed int r) :
50    reg(r)
51 {
52 }
53  
54 MachRegister::MachRegister(const MachRegister& r) :
55         reg(r.reg)
56 {
57 }
58
59 MachRegister::MachRegister(signed int r, const char *n) :
60    reg(r)
61 {
62    if (!names) {
63       names = new std::map<signed int, const char *>();
64    }
65    (*names)[r] = n;
66 }
67
68 MachRegister::~MachRegister() {
69 }
70
71 MachRegister MachRegister::getBaseRegister() const { 
72    switch (getArchitecture()) {
73       case Arch_x86:
74       case Arch_x86_64:
75         
76           return MachRegister(reg & 0xfffff0ff);
77       case Arch_ppc32:
78       case Arch_ppc64:
79       case Arch_none:
80          return *this;
81    }
82    return InvalidReg;
83 }
84    
85 Architecture MachRegister::getArchitecture() const { 
86    return (Architecture) (reg & 0xff000000);
87 }
88
89 bool MachRegister::isValid() const {
90    return (reg != InvalidReg.reg);
91 }
92
93 MachRegisterVal MachRegister::getSubRegValue(const MachRegister subreg, 
94                                              MachRegisterVal &orig) const
95 {
96    if (subreg.reg == reg || 
97        getArchitecture() == Arch_ppc32 ||
98        getArchitecture() == Arch_ppc64)
99       return orig;
100
101    assert(subreg.getBaseRegister() == getBaseRegister());
102    switch ((subreg.reg & 0x00000f00) >> 8) {
103       case 0x0: return orig;
104       case 0x1: return (orig & 0xff);
105       case 0x2: return (orig & 0xff00) >> 8;              
106       case 0x3: return (orig & 0xffff);
107       case 0xf: return (orig & 0xffffffff);
108       default: assert(0); return orig;
109    }
110 }
111
112 const char *MachRegister::name() const { 
113    return (*names)[reg];
114 }
115
116 unsigned int MachRegister::size() const {
117    switch (getArchitecture())
118    {
119       case Arch_x86:
120          switch (reg & 0x0000ff00) {
121              case x86::L_REG: //L_REG
122             case x86::H_REG: //H_REG
123                return 1;
124                case x86::W_REG: //W_REG
125                return 2;
126                case x86::FULL: //FULL
127                return 4;
128              case x86::QUAD:
129                 return 8;
130              case x86::OCT:
131                  return 16;
132              case x86::FPDBL:
133                  return 10;
134          case x86::BIT:
135            return 0;
136              default:
137                assert(0);
138          }
139       case Arch_x86_64:
140          switch (reg & 0x0000ff00) {
141              case x86_64::L_REG: //L_REG
142              case x86_64::H_REG: //H_REG
143                 return 1;
144              case x86_64::W_REG: //W_REG
145                 return 2;
146              case x86_64::FULL: //FULL
147                 return 8;
148              case x86_64::D_REG:
149                  return 4;
150              case x86_64::OCT:
151                  return 16;
152              case x86_64::FPDBL:
153                  return 10;
154          case x86_64::BIT:
155            return 0;
156              default:
157                assert(0);
158          }
159       case Arch_ppc32: {
160          int reg_class = reg & 0x00ff0000;
161          if (reg_class == ppc32::FPR || reg_class == ppc32::FSR)
162             return 8;
163          return 4;
164       }
165       case Arch_ppc64:
166          return 8;
167       case Arch_none:
168          return 0;
169    }
170    return 0; //Unreachable, but disable warnings
171 }
172    
173 bool MachRegister::operator<(const MachRegister &a) const { 
174    return (reg < a.reg);
175 }
176  
177 bool MachRegister::operator==(const MachRegister &a) const { 
178    return (reg == a.reg);
179 }
180  
181 MachRegister::operator signed int() const {
182    return reg;
183 }
184
185 signed int MachRegister::val() const {
186    return reg;
187 }
188
189
190 MachRegister MachRegister::getPC(Dyninst::Architecture arch)
191 {
192    switch (arch)
193    {
194       case Arch_x86:
195          return x86::eip;
196       case Arch_x86_64:
197          return x86_64::rip;
198       case Arch_ppc32:
199          return ppc32::pc;
200       case Arch_ppc64:
201          return ppc64::pc;
202       case Arch_none:
203          return InvalidReg;
204    }
205    return InvalidReg;
206 }
207
208 MachRegister MachRegister::getFramePointer(Dyninst::Architecture arch)
209 {
210    switch (arch)
211    {
212       case Arch_x86:
213          return x86::ebp;
214       case Arch_x86_64:
215          return x86_64::rbp;
216       case Arch_ppc32:
217       case Arch_ppc64:
218          return FrameBase;
219       case Arch_none:
220          return InvalidReg;
221    }
222    return InvalidReg;
223 }
224
225 MachRegister MachRegister::getStackPointer(Dyninst::Architecture arch)
226 {
227    switch (arch)
228    {
229       case Arch_x86:
230          return x86::esp;
231       case Arch_x86_64:
232          return x86_64::rsp;
233       case Arch_ppc32:
234          return ppc32::r1;
235       case Arch_ppc64:
236          return ppc64::r1;
237       case Arch_none:
238          return InvalidReg;
239    }
240    return InvalidReg;
241 }
242
243 bool MachRegister::isPC() const
244 {
245    return (*this == x86_64::rip || *this == x86::eip ||
246            *this == ppc32::pc || *this == ppc64::pc);
247 }
248
249 bool MachRegister::isFramePointer() const
250 {
251    return (*this == x86_64::rbp || *this == x86::ebp ||
252            *this == FrameBase);
253 }
254
255 bool MachRegister::isStackPointer() const
256 {
257    return (*this == x86_64::rsp || *this == x86::esp ||
258            *this == ppc32::r1 || *this == ppc64::r1);
259 }
260
261 void MachRegister::getROSERegister(int &c, int &n, int &p)
262 {
263    // Rose: class, number, position
264    // Dyninst: category, base id, subrange
265
266    signed int category = (reg & 0x00ff0000);
267    signed int subrange = (reg & 0x0000ff00);
268    signed int baseID =   (reg & 0x000000ff);
269
270    switch (getArchitecture()) {
271       case Arch_x86:
272       case Arch_x86_64: // 64-bit not supported in ROSE
273          switch (category) {
274             case x86::GPR:
275                c = x86_regclass_gpr;
276                switch (baseID) {
277                   case x86::BASEA:
278                      n = x86_gpr_ax;
279                      break;
280                   case x86::BASEC:
281                      n = x86_gpr_cx;
282                      break;
283                   case x86::BASED:
284                      n = x86_gpr_dx;
285                      break;
286                   case x86::BASEB:
287                      n = x86_gpr_bx;
288                      break;
289                   case x86::BASESP:
290                      n = x86_gpr_sp;
291                      break;
292                   case x86::BASEBP:
293                      n = x86_gpr_bp;
294                      break;
295                   case x86::BASESI:
296                      n = x86_gpr_si;
297                      break;
298                   case x86::BASEDI:
299                      n = x86_gpr_di;
300                      break;
301                   default:
302                      n = 0;
303                      break;
304                }
305                break;
306             case x86::SEG:
307                c = x86_regclass_segment;
308                switch (baseID) {
309                   case 0x0:
310                      n = x86_segreg_ds;
311                      break;
312                   case 0x1:
313                      n = x86_segreg_es;
314                      break;
315                   case 0x2:
316                      n = x86_segreg_fs;
317                      break;
318                   case 0x3:
319                      n = x86_segreg_gs;
320                      break;
321                   case 0x4:
322                      n = x86_segreg_cs;
323                      break;
324                   case 0x5:
325                      n = x86_segreg_ss;
326                      break;
327                   default:
328                      n = 0;
329                      break;
330                }
331                break;
332             case x86::FLAG:
333                c = x86_regclass_flags;
334                switch(baseID) {
335                case x86::CF:
336                  n = x86_flag_cf;
337                  break;
338                case x86::PF:
339                  n = x86_flag_pf;
340                  break;
341                case x86::AF:
342                  n = x86_flag_af;
343                  break;
344                case x86::ZF:
345                  n = x86_flag_zf;
346                  break;
347                case x86::SF:
348                  n = x86_flag_sf;
349                  break;
350                case x86::TF:
351                  n = x86_flag_tf;
352                  break;
353                case x86::IF:
354                  n = x86_flag_if;
355                  break;
356                case x86::DF:
357                  n = x86_flag_df;
358                  break;
359                case x86::OF:
360                  n = x86_flag_of;
361                  break;
362                default:
363                  assert(0);
364                  break;
365                }
366                break;
367             case x86::MISC:
368                c = x86_regclass_unknown;
369                break;
370             case x86::XMM:
371                c = x86_regclass_xmm;
372                n = baseID;
373                break;
374             case x86::MMX:
375                c = x86_regclass_mm;
376                n = baseID;
377                break;
378             case x86::CTL:
379                c = x86_regclass_cr;
380                n = baseID;
381                break;
382             case x86::DBG:
383                c = x86_regclass_dr;
384                n = baseID;
385                break;
386             case x86::TST:
387                c = x86_regclass_unknown;
388                break;
389             case 0:
390                switch (baseID) {
391                   case 0x10:
392                      c = x86_regclass_ip;
393                      n = 0;
394                      break;
395                   default:
396                      c = x86_regclass_unknown;
397                      break;
398                }
399                break;
400          }
401          break;
402        case Arch_ppc32:
403        case Arch_ppc64: // 64-bit not supported in ROSE
404        {
405          baseID = reg & 0x0000FFFF;
406            n = baseID;
407            switch(category)
408            {
409                case ppc32::GPR:
410                    c = powerpc_regclass_gpr;
411                    break;
412                case ppc32::FPR:
413                case ppc32::FSR:
414                    c = powerpc_regclass_fpr;
415                    break;
416                case ppc32::SPR:
417                {
418                    if(baseID < 613) {
419                        c = powerpc_regclass_spr;
420                    } else if(baseID < 621 ) {
421                        c = powerpc_regclass_sr; 
422                    } else {
423                        c = powerpc_regclass_cr;
424                        n = baseID - 621;
425                        if(n > 7) {
426                          n = 0;
427                          p = powerpc_condreggranularity_whole;
428                        } else {
429                          p = powerpc_condreggranularity_field;
430                        }
431
432                    }
433                }
434                break;
435                default:
436                    assert(!"unknown register type!");
437                    break;
438            }
439            return;
440        }
441        default:
442          c = x86_regclass_unknown;
443          n = 0;
444          break;
445    }
446
447    switch (getArchitecture()) {
448       case Arch_x86:
449       case Arch_x86_64:
450          switch (subrange) {
451             case x86::FULL:
452             case x86::OCT:
453             case x86::FPDBL:
454                p = x86_regpos_all;
455                break;
456             case x86::H_REG:
457                p = x86_regpos_high_byte;
458                break;
459             case x86::L_REG:
460                p = x86_regpos_low_byte;
461                break;
462             case x86::W_REG:
463                p = x86_regpos_word;
464                break;
465             case x86_64::D_REG:
466                p = x86_regpos_dword;
467                break;
468             case x86::BIT:
469                p = x86_regpos_all;
470                break;
471          }
472          break;
473       default:
474         p = x86_regpos_unknown;
475    }
476 }
477
478 MachRegister MachRegister::DwarfEncToReg(int encoding, Dyninst::Architecture arch)
479 {
480    switch (arch)
481    {
482       case Arch_x86:
483          switch (encoding) {
484             case 0: return Dyninst::x86::eax;
485             case 1: return Dyninst::x86::ecx;
486             case 2: return Dyninst::x86::edx;
487             case 3: return Dyninst::x86::ebx;
488             case 4: return Dyninst::x86::esp;
489             case 5: return Dyninst::x86::ebp;
490             case 6: return Dyninst::x86::esi;
491             case 7: return Dyninst::x86::edi;
492             case 8: return Dyninst::x86::eip;
493             case 9: return Dyninst::x86::flags;
494             case 10: return Dyninst::InvalidReg;
495             case 11: return Dyninst::x86::st0;
496             case 12: return Dyninst::x86::st1;
497             case 13: return Dyninst::x86::st2;
498             case 14: return Dyninst::x86::st3;
499             case 15: return Dyninst::x86::st4;
500             case 16: return Dyninst::x86::st5;
501             case 17: return Dyninst::x86::st6;
502             case 18: return Dyninst::x86::st7;
503             case 19: return Dyninst::InvalidReg;
504             case 20: return Dyninst::InvalidReg;
505             case 21: return Dyninst::x86::xmm0;
506             case 22: return Dyninst::x86::xmm1;
507             case 23: return Dyninst::x86::xmm2;
508             case 24: return Dyninst::x86::xmm3;
509             case 25: return Dyninst::x86::xmm4;
510             case 26: return Dyninst::x86::xmm5;
511             case 27: return Dyninst::x86::xmm6;
512             case 28: return Dyninst::x86::xmm7;
513             case 29: return Dyninst::x86::mm0;
514             case 30: return Dyninst::x86::mm1;
515             case 31: return Dyninst::x86::mm2;
516             case 32: return Dyninst::x86::mm3;
517             case 33: return Dyninst::x86::mm4;
518             case 34: return Dyninst::x86::mm5;
519             case 35: return Dyninst::x86::mm6;
520             case 36: return Dyninst::x86::mm7;
521             case 37: return Dyninst::InvalidReg; //fcw
522             case 38: return Dyninst::InvalidReg; //fsw
523             case 39: return Dyninst::InvalidReg; //mxcsr
524             case 40: return Dyninst::x86::es;
525             case 41: return Dyninst::x86::cs;
526             case 42: return Dyninst::x86::ss;
527             case 43: return Dyninst::x86::ds;
528             case 44: return Dyninst::x86::fs;
529             case 45: return Dyninst::x86::gs;
530             case 46: return Dyninst::InvalidReg;
531             case 47: return Dyninst::InvalidReg;
532             case 48: return Dyninst::InvalidReg; //tr
533             case 49: return Dyninst::InvalidReg; //ldtr
534             default: return Dyninst::InvalidReg;
535          }
536          break;
537       case Arch_x86_64:
538          switch (encoding) {
539             case 0: return Dyninst::x86_64::rax;
540             case 1: return Dyninst::x86_64::rdx;
541             case 2: return Dyninst::x86_64::rcx;
542             case 3: return Dyninst::x86_64::rbx;
543             case 4: return Dyninst::x86_64::rsi;
544             case 5: return Dyninst::x86_64::rdi;
545             case 6: return Dyninst::x86_64::rbp;
546             case 7: return Dyninst::x86_64::rsp;
547             case 8: return Dyninst::x86_64::r8;
548             case 9: return Dyninst::x86_64::r9;
549             case 10: return Dyninst::x86_64::r10;
550             case 11: return Dyninst::x86_64::r11;
551             case 12: return Dyninst::x86_64::r12;
552             case 13: return Dyninst::x86_64::r13;
553             case 14: return Dyninst::x86_64::r14;
554             case 15: return Dyninst::x86_64::r15;
555             case 16: return Dyninst::x86_64::rip;
556             case 17: return Dyninst::x86_64::xmm0;
557             case 18: return Dyninst::x86_64::xmm1;
558             case 19: return Dyninst::x86_64::xmm2;
559             case 20: return Dyninst::x86_64::xmm3;
560             case 21: return Dyninst::x86_64::xmm4;
561             case 22: return Dyninst::x86_64::xmm5;
562             case 23: return Dyninst::x86_64::xmm6;
563             case 24: return Dyninst::x86_64::xmm7;
564             case 25: return Dyninst::x86_64::xmm8;
565             case 26: return Dyninst::x86_64::xmm9;
566             case 27: return Dyninst::x86_64::xmm10;
567             case 28: return Dyninst::x86_64::xmm11;
568             case 29: return Dyninst::x86_64::xmm12;
569             case 30: return Dyninst::x86_64::xmm13;
570             case 31: return Dyninst::x86_64::xmm14;
571             case 32: return Dyninst::x86_64::xmm15;
572             case 33: return Dyninst::x86_64::st0;
573             case 34: return Dyninst::x86_64::st1;
574             case 35: return Dyninst::x86_64::st2;
575             case 36: return Dyninst::x86_64::st3;
576             case 37: return Dyninst::x86_64::st4;
577             case 38: return Dyninst::x86_64::st5;
578             case 39: return Dyninst::x86_64::st6;
579             case 40: return Dyninst::x86_64::st7;
580             case 41: return Dyninst::x86_64::mm0;
581             case 42: return Dyninst::x86_64::mm1;
582             case 43: return Dyninst::x86_64::mm2;
583             case 44: return Dyninst::x86_64::mm3;
584             case 45: return Dyninst::x86_64::mm4;
585             case 46: return Dyninst::x86_64::mm5;
586             case 47: return Dyninst::x86_64::mm6;
587             case 48: return Dyninst::x86_64::mm7;
588             case 49: return Dyninst::x86_64::flags;
589             case 50: return Dyninst::x86_64::es;
590             case 51: return Dyninst::x86_64::cs;
591             case 52: return Dyninst::x86_64::ss;
592             case 53: return Dyninst::x86_64::ds;
593             case 54: return Dyninst::x86_64::fs;
594             case 55: return Dyninst::x86_64::gs;
595             case 56: return Dyninst::InvalidReg;
596             case 57: return Dyninst::InvalidReg;
597             case 58: return Dyninst::x86_64::fsbase;
598             case 59: return Dyninst::x86_64::gsbase;
599             case 60: return Dyninst::InvalidReg; 
600             case 61: return Dyninst::InvalidReg; 
601             case 62: return Dyninst::InvalidReg; //tr
602             case 63: return Dyninst::InvalidReg; //ldtr
603             case 64: return Dyninst::InvalidReg; //mxcsr
604             case 65: return Dyninst::InvalidReg; //fcw
605             case 66: return Dyninst::InvalidReg; //fsw
606          }
607          break;
608       case Arch_ppc32:
609          switch (encoding) {
610             case 0: return Dyninst::ppc32::r0;
611             case 1: return Dyninst::ppc32::r1;
612             case 2: return Dyninst::ppc32::r2;
613             case 3: return Dyninst::ppc32::r3;
614             case 4: return Dyninst::ppc32::r4;
615             case 5: return Dyninst::ppc32::r5;
616             case 6: return Dyninst::ppc32::r6;
617             case 7: return Dyninst::ppc32::r7;
618             case 8: return Dyninst::ppc32::r8;
619             case 9: return Dyninst::ppc32::r9;
620             case 10: return Dyninst::ppc32::r10;
621             case 11: return Dyninst::ppc32::r11;
622             case 12: return Dyninst::ppc32::r12;
623             case 13: return Dyninst::ppc32::r13;
624             case 14: return Dyninst::ppc32::r14;
625             case 15: return Dyninst::ppc32::r15;
626             case 16: return Dyninst::ppc32::r16;
627             case 17: return Dyninst::ppc32::r17;
628             case 18: return Dyninst::ppc32::r18;
629             case 19: return Dyninst::ppc32::r19;
630             case 20: return Dyninst::ppc32::r20;
631             case 21: return Dyninst::ppc32::r21;
632             case 22: return Dyninst::ppc32::r22;
633             case 23: return Dyninst::ppc32::r23;
634             case 24: return Dyninst::ppc32::r24;
635             case 25: return Dyninst::ppc32::r25;
636             case 26: return Dyninst::ppc32::r26;
637             case 27: return Dyninst::ppc32::r27;
638             case 28: return Dyninst::ppc32::r28;
639             case 29: return Dyninst::ppc32::r29;
640             case 30: return Dyninst::ppc32::r30;
641             case 31: return Dyninst::ppc32::r31;
642             case 32: return Dyninst::ppc32::fpr0;
643             case 33: return Dyninst::ppc32::fpr1;
644             case 34: return Dyninst::ppc32::fpr2;
645             case 35: return Dyninst::ppc32::fpr3;
646             case 36: return Dyninst::ppc32::fpr4;
647             case 37: return Dyninst::ppc32::fpr5;
648             case 38: return Dyninst::ppc32::fpr6;
649             case 39: return Dyninst::ppc32::fpr7;
650             case 40: return Dyninst::ppc32::fpr8;
651             case 41: return Dyninst::ppc32::fpr9;
652             case 42: return Dyninst::ppc32::fpr10;
653             case 43: return Dyninst::ppc32::fpr11;
654             case 44: return Dyninst::ppc32::fpr12;
655             case 45: return Dyninst::ppc32::fpr13;
656             case 46: return Dyninst::ppc32::fpr14;
657             case 47: return Dyninst::ppc32::fpr15;
658             case 48: return Dyninst::ppc32::fpr16;
659             case 49: return Dyninst::ppc32::fpr17;
660             case 50: return Dyninst::ppc32::fpr18;
661             case 51: return Dyninst::ppc32::fpr19;
662             case 52: return Dyninst::ppc32::fpr20;
663             case 53: return Dyninst::ppc32::fpr21;
664             case 54: return Dyninst::ppc32::fpr22;
665             case 55: return Dyninst::ppc32::fpr23;
666             case 56: return Dyninst::ppc32::fpr24;
667             case 57: return Dyninst::ppc32::fpr25;
668             case 58: return Dyninst::ppc32::fpr26;
669             case 59: return Dyninst::ppc32::fpr27;
670             case 60: return Dyninst::ppc32::fpr28;
671             case 61: return Dyninst::ppc32::fpr29;
672             case 62: return Dyninst::ppc32::fpr30;
673             case 63: return Dyninst::ppc32::fpr31;
674             case 64: return Dyninst::ppc32::cr;
675             case 65: return Dyninst::InvalidReg; //FPSCR
676          }
677          //Seperate switch statements to give compilers an easier time of 
678          // optimizing
679          switch (encoding) {
680             case 100: return Dyninst::ppc32::mq;
681             case 101: return Dyninst::ppc32::xer;
682             case 102: return Dyninst::InvalidReg;
683             case 103: return Dyninst::InvalidReg;
684             case 104: return Dyninst::InvalidReg; //RTCU
685             case 105: return Dyninst::InvalidReg; //RTCL
686             case 106: return Dyninst::InvalidReg;
687             case 107: return Dyninst::InvalidReg;
688             case 108: return Dyninst::ppc32::lr;
689             case 109: return Dyninst::ppc32::ctr;
690             default: return Dyninst::InvalidReg;
691          }
692          break;
693       case Arch_ppc64:
694          switch (encoding) {
695             case 0: return Dyninst::ppc64::r0;
696             case 1: return Dyninst::ppc64::r1;
697             case 2: return Dyninst::ppc64::r2;
698             case 3: return Dyninst::ppc64::r3;
699             case 4: return Dyninst::ppc64::r4;
700             case 5: return Dyninst::ppc64::r5;
701             case 6: return Dyninst::ppc64::r6;
702             case 7: return Dyninst::ppc64::r7;
703             case 8: return Dyninst::ppc64::r8;
704             case 9: return Dyninst::ppc64::r9;
705             case 10: return Dyninst::ppc64::r10;
706             case 11: return Dyninst::ppc64::r11;
707             case 12: return Dyninst::ppc64::r12;
708             case 13: return Dyninst::ppc64::r13;
709             case 14: return Dyninst::ppc64::r14;
710             case 15: return Dyninst::ppc64::r15;
711             case 16: return Dyninst::ppc64::r16;
712             case 17: return Dyninst::ppc64::r17;
713             case 18: return Dyninst::ppc64::r18;
714             case 19: return Dyninst::ppc64::r19;
715             case 20: return Dyninst::ppc64::r20;
716             case 21: return Dyninst::ppc64::r21;
717             case 22: return Dyninst::ppc64::r22;
718             case 23: return Dyninst::ppc64::r23;
719             case 24: return Dyninst::ppc64::r24;
720             case 25: return Dyninst::ppc64::r25;
721             case 26: return Dyninst::ppc64::r26;
722             case 27: return Dyninst::ppc64::r27;
723             case 28: return Dyninst::ppc64::r28;
724             case 29: return Dyninst::ppc64::r29;
725             case 30: return Dyninst::ppc64::r30;
726             case 31: return Dyninst::ppc64::r31;
727             case 32: return Dyninst::ppc64::fpr0;
728             case 33: return Dyninst::ppc64::fpr1;
729             case 34: return Dyninst::ppc64::fpr2;
730             case 35: return Dyninst::ppc64::fpr3;
731             case 36: return Dyninst::ppc64::fpr4;
732             case 37: return Dyninst::ppc64::fpr5;
733             case 38: return Dyninst::ppc64::fpr6;
734             case 39: return Dyninst::ppc64::fpr7;
735             case 40: return Dyninst::ppc64::fpr8;
736             case 41: return Dyninst::ppc64::fpr9;
737             case 42: return Dyninst::ppc64::fpr10;
738             case 43: return Dyninst::ppc64::fpr11;
739             case 44: return Dyninst::ppc64::fpr12;
740             case 45: return Dyninst::ppc64::fpr13;
741             case 46: return Dyninst::ppc64::fpr14;
742             case 47: return Dyninst::ppc64::fpr15;
743             case 48: return Dyninst::ppc64::fpr16;
744             case 49: return Dyninst::ppc64::fpr17;
745             case 50: return Dyninst::ppc64::fpr18;
746             case 51: return Dyninst::ppc64::fpr19;
747             case 52: return Dyninst::ppc64::fpr20;
748             case 53: return Dyninst::ppc64::fpr21;
749             case 54: return Dyninst::ppc64::fpr22;
750             case 55: return Dyninst::ppc64::fpr23;
751             case 56: return Dyninst::ppc64::fpr24;
752             case 57: return Dyninst::ppc64::fpr25;
753             case 58: return Dyninst::ppc64::fpr26;
754             case 59: return Dyninst::ppc64::fpr27;
755             case 60: return Dyninst::ppc64::fpr28;
756             case 61: return Dyninst::ppc64::fpr29;
757             case 62: return Dyninst::ppc64::fpr30;
758             case 63: return Dyninst::ppc64::fpr31;
759             case 64: return Dyninst::ppc64::cr;
760             case 65: return Dyninst::InvalidReg; //FPSCR
761          }
762          //Seperate switch statements to give compilers an easier time of 
763          // optimizing
764          switch (encoding) {
765             case 100: return Dyninst::ppc64::mq;
766             case 101: return Dyninst::ppc64::xer;
767             case 102: return Dyninst::InvalidReg;
768             case 103: return Dyninst::InvalidReg;
769             case 104: return Dyninst::InvalidReg; //RTCU
770             case 105: return Dyninst::InvalidReg; //RTCL
771             case 106: return Dyninst::InvalidReg;
772             case 107: return Dyninst::InvalidReg;
773             case 108: return Dyninst::ppc64::lr;
774             case 109: return Dyninst::ppc64::ctr;
775             default: return Dyninst::InvalidReg;
776          }
777          break;
778       case Arch_none:
779          return Dyninst::InvalidReg;
780          break;
781    }
782    //Invalid Architecture passed
783    return Dyninst::InvalidReg;
784
785 }
786
787 int MachRegister::getDwarfEnc() const
788 {
789    switch (getArchitecture())
790    {
791       case Arch_x86:
792          switch (val()) {
793             case Dyninst::x86::ieax: return 0;
794             case Dyninst::x86::iecx: return 1;
795             case Dyninst::x86::iedx: return 2;
796             case Dyninst::x86::iebx: return 3;
797             case Dyninst::x86::iesp: return 4;
798             case Dyninst::x86::iebp: return 5;
799             case Dyninst::x86::iesi: return 6;
800             case Dyninst::x86::iedi: return 7;
801             case Dyninst::x86::ieip: return 8;
802             case Dyninst::x86::iflags: return 9;
803             case Dyninst::x86::ixmm0: return 21;
804             case Dyninst::x86::ixmm1: return 22;
805             case Dyninst::x86::ixmm2: return 23;
806             case Dyninst::x86::ixmm3: return 24;
807             case Dyninst::x86::ixmm4: return 25;
808             case Dyninst::x86::ixmm5: return 26;
809             case Dyninst::x86::ixmm6: return 27;
810             case Dyninst::x86::ixmm7: return 28;
811             case Dyninst::x86::imm0: return 29;
812             case Dyninst::x86::imm1: return 30;
813             case Dyninst::x86::imm2: return 31;
814             case Dyninst::x86::imm3: return 32;
815             case Dyninst::x86::imm4: return 33;
816             case Dyninst::x86::imm5: return 34;
817             case Dyninst::x86::imm6: return 35;
818             case Dyninst::x86::imm7: return 36;
819             case Dyninst::x86::ies: return 40;
820             case Dyninst::x86::ics: return 41;
821             case Dyninst::x86::iss: return 42;
822             case Dyninst::x86::ids: return 43;
823             case Dyninst::x86::ifs: return 44;
824             case Dyninst::x86::igs: return 45;
825             default: return -1;
826          }
827          break;
828       case Arch_x86_64:
829          switch (val()) {
830             case Dyninst::x86_64::irax: return 0;
831             case Dyninst::x86_64::irdx: return 1;
832             case Dyninst::x86_64::ircx: return 2;
833             case Dyninst::x86_64::irbx: return 3;
834             case Dyninst::x86_64::irsi: return 4;
835             case Dyninst::x86_64::irdi: return 5;
836             case Dyninst::x86_64::irbp: return 6;
837             case Dyninst::x86_64::irsp: return 7;
838             case Dyninst::x86_64::ir8: return 8;
839             case Dyninst::x86_64::ir9: return 9;
840             case Dyninst::x86_64::ir10: return 10;
841             case Dyninst::x86_64::ir11: return 11;
842             case Dyninst::x86_64::ir12: return 12;
843             case Dyninst::x86_64::ir13: return 13;
844             case Dyninst::x86_64::ir14: return 14;
845             case Dyninst::x86_64::ir15: return 15;
846             case Dyninst::x86_64::irip: return 16;
847             case Dyninst::x86_64::ixmm0: return 17;
848             case Dyninst::x86_64::ixmm1: return 18;
849             case Dyninst::x86_64::ixmm2: return 19;
850             case Dyninst::x86_64::ixmm3: return 20;
851             case Dyninst::x86_64::ixmm4: return 21;
852             case Dyninst::x86_64::ixmm5: return 22;
853             case Dyninst::x86_64::ixmm6: return 23;
854             case Dyninst::x86_64::ixmm7: return 24;
855             case Dyninst::x86_64::ixmm8: return 25;
856             case Dyninst::x86_64::ixmm9: return 26;
857             case Dyninst::x86_64::ixmm10: return 27;
858             case Dyninst::x86_64::ixmm11: return 28;
859             case Dyninst::x86_64::ixmm12: return 29;
860             case Dyninst::x86_64::ixmm13: return 30;
861             case Dyninst::x86_64::ixmm14: return 31;
862             case Dyninst::x86_64::ixmm15: return 32;
863             case Dyninst::x86_64::imm0: return 41;
864             case Dyninst::x86_64::imm1: return 42;
865             case Dyninst::x86_64::imm2: return 43;
866             case Dyninst::x86_64::imm3: return 44;
867             case Dyninst::x86_64::imm4: return 45;
868             case Dyninst::x86_64::imm5: return 46;
869             case Dyninst::x86_64::imm6: return 47;
870             case Dyninst::x86_64::imm7: return 48;
871             case Dyninst::x86_64::iflags: return 49;
872             case Dyninst::x86_64::ies: return 50;
873             case Dyninst::x86_64::ics: return 51;
874             case Dyninst::x86_64::iss: return 52;
875             case Dyninst::x86_64::ids: return 53;
876             case Dyninst::x86_64::ifs: return 54;
877             case Dyninst::x86_64::igs: return 55;
878             case Dyninst::x86_64::ifsbase: return 58;
879             case Dyninst::x86_64::igsbase: return 59;
880             default: return -1;
881          }
882          break;
883       case Arch_ppc32:
884          switch (val()) {
885             case Dyninst::ppc32::ir0: return 0;
886             case Dyninst::ppc32::ir1: return 1;
887             case Dyninst::ppc32::ir2: return 2;
888             case Dyninst::ppc32::ir3: return 3;
889             case Dyninst::ppc32::ir4: return 4;
890             case Dyninst::ppc32::ir5: return 5;
891             case Dyninst::ppc32::ir6: return 6;
892             case Dyninst::ppc32::ir7: return 7;
893             case Dyninst::ppc32::ir8: return 8;
894             case Dyninst::ppc32::ir9: return 9;
895             case Dyninst::ppc32::ir10: return 10;
896             case Dyninst::ppc32::ir11: return 11;
897             case Dyninst::ppc32::ir12: return 12;
898             case Dyninst::ppc32::ir13: return 13;
899             case Dyninst::ppc32::ir14: return 14;
900             case Dyninst::ppc32::ir15: return 15;
901             case Dyninst::ppc32::ir16: return 16;
902             case Dyninst::ppc32::ir17: return 17;
903             case Dyninst::ppc32::ir18: return 18;
904             case Dyninst::ppc32::ir19: return 19;
905             case Dyninst::ppc32::ir20: return 20;
906             case Dyninst::ppc32::ir21: return 21;
907             case Dyninst::ppc32::ir22: return 22;
908             case Dyninst::ppc32::ir23: return 23;
909             case Dyninst::ppc32::ir24: return 24;
910             case Dyninst::ppc32::ir25: return 25;
911             case Dyninst::ppc32::ir26: return 26;
912             case Dyninst::ppc32::ir27: return 27;
913             case Dyninst::ppc32::ir28: return 28;
914             case Dyninst::ppc32::ir29: return 29;
915             case Dyninst::ppc32::ir30: return 30;
916             case Dyninst::ppc32::ir31: return 31;
917             case Dyninst::ppc32::ifpr0: return 32;
918             case Dyninst::ppc32::ifpr1: return 33;
919             case Dyninst::ppc32::ifpr2: return 34;
920             case Dyninst::ppc32::ifpr3: return 35;
921             case Dyninst::ppc32::ifpr4: return 36;
922             case Dyninst::ppc32::ifpr5: return 37;
923             case Dyninst::ppc32::ifpr6: return 38;
924             case Dyninst::ppc32::ifpr7: return 39;
925             case Dyninst::ppc32::ifpr8: return 40;
926             case Dyninst::ppc32::ifpr9: return 41;
927             case Dyninst::ppc32::ifpr10: return 42;
928             case Dyninst::ppc32::ifpr11: return 43;
929             case Dyninst::ppc32::ifpr12: return 44;
930             case Dyninst::ppc32::ifpr13: return 45;
931             case Dyninst::ppc32::ifpr14: return 46;
932             case Dyninst::ppc32::ifpr15: return 47;
933             case Dyninst::ppc32::ifpr16: return 48;
934             case Dyninst::ppc32::ifpr17: return 49;
935             case Dyninst::ppc32::ifpr18: return 50;
936             case Dyninst::ppc32::ifpr19: return 51;
937             case Dyninst::ppc32::ifpr20: return 52;
938             case Dyninst::ppc32::ifpr21: return 53;
939             case Dyninst::ppc32::ifpr22: return 54;
940             case Dyninst::ppc32::ifpr23: return 55;
941             case Dyninst::ppc32::ifpr24: return 56;
942             case Dyninst::ppc32::ifpr25: return 57;
943             case Dyninst::ppc32::ifpr26: return 58;
944             case Dyninst::ppc32::ifpr27: return 59;
945             case Dyninst::ppc32::ifpr28: return 60;
946             case Dyninst::ppc32::ifpr29: return 61;
947             case Dyninst::ppc32::ifpr30: return 62;
948             case Dyninst::ppc32::ifpr31: return 63;
949             case Dyninst::ppc32::icr: return 64;
950             case Dyninst::ppc32::imq: return 100;
951             case Dyninst::ppc32::ixer: return 101;
952             case Dyninst::ppc32::ilr: return 108;
953             case Dyninst::ppc32::ictr: return 109;
954             default: return -1;
955          }
956       case Arch_ppc64:
957          switch (val()) {
958             case Dyninst::ppc64::ir0: return 0;
959             case Dyninst::ppc64::ir1: return 1;
960             case Dyninst::ppc64::ir2: return 2;
961             case Dyninst::ppc64::ir3: return 3;
962             case Dyninst::ppc64::ir4: return 4;
963             case Dyninst::ppc64::ir5: return 5;
964             case Dyninst::ppc64::ir6: return 6;
965             case Dyninst::ppc64::ir7: return 7;
966             case Dyninst::ppc64::ir8: return 8;
967             case Dyninst::ppc64::ir9: return 9;
968             case Dyninst::ppc64::ir10: return 10;
969             case Dyninst::ppc64::ir11: return 11;
970             case Dyninst::ppc64::ir12: return 12;
971             case Dyninst::ppc64::ir13: return 13;
972             case Dyninst::ppc64::ir14: return 14;
973             case Dyninst::ppc64::ir15: return 15;
974             case Dyninst::ppc64::ir16: return 16;
975             case Dyninst::ppc64::ir17: return 17;
976             case Dyninst::ppc64::ir18: return 18;
977             case Dyninst::ppc64::ir19: return 19;
978             case Dyninst::ppc64::ir20: return 20;
979             case Dyninst::ppc64::ir21: return 21;
980             case Dyninst::ppc64::ir22: return 22;
981             case Dyninst::ppc64::ir23: return 23;
982             case Dyninst::ppc64::ir24: return 24;
983             case Dyninst::ppc64::ir25: return 25;
984             case Dyninst::ppc64::ir26: return 26;
985             case Dyninst::ppc64::ir27: return 27;
986             case Dyninst::ppc64::ir28: return 28;
987             case Dyninst::ppc64::ir29: return 29;
988             case Dyninst::ppc64::ir30: return 30;
989             case Dyninst::ppc64::ir31: return 31;
990             case Dyninst::ppc64::ifpr0: return 32;
991             case Dyninst::ppc64::ifpr1: return 33;
992             case Dyninst::ppc64::ifpr2: return 34;
993             case Dyninst::ppc64::ifpr3: return 35;
994             case Dyninst::ppc64::ifpr4: return 36;
995             case Dyninst::ppc64::ifpr5: return 37;
996             case Dyninst::ppc64::ifpr6: return 38;
997             case Dyninst::ppc64::ifpr7: return 39;
998             case Dyninst::ppc64::ifpr8: return 40;
999             case Dyninst::ppc64::ifpr9: return 41;
1000             case Dyninst::ppc64::ifpr10: return 42;
1001             case Dyninst::ppc64::ifpr11: return 43;
1002             case Dyninst::ppc64::ifpr12: return 44;
1003             case Dyninst::ppc64::ifpr13: return 45;
1004             case Dyninst::ppc64::ifpr14: return 46;
1005             case Dyninst::ppc64::ifpr15: return 47;
1006             case Dyninst::ppc64::ifpr16: return 48;
1007             case Dyninst::ppc64::ifpr17: return 49;
1008             case Dyninst::ppc64::ifpr18: return 50;
1009             case Dyninst::ppc64::ifpr19: return 51;
1010             case Dyninst::ppc64::ifpr20: return 52;
1011             case Dyninst::ppc64::ifpr21: return 53;
1012             case Dyninst::ppc64::ifpr22: return 54;
1013             case Dyninst::ppc64::ifpr23: return 55;
1014             case Dyninst::ppc64::ifpr24: return 56;
1015             case Dyninst::ppc64::ifpr25: return 57;
1016             case Dyninst::ppc64::ifpr26: return 58;
1017             case Dyninst::ppc64::ifpr27: return 59;
1018             case Dyninst::ppc64::ifpr28: return 60;
1019             case Dyninst::ppc64::ifpr29: return 61;
1020             case Dyninst::ppc64::ifpr30: return 62;
1021             case Dyninst::ppc64::ifpr31: return 63;
1022             case Dyninst::ppc64::icr: return 64;
1023             case Dyninst::ppc64::imq: return 100;
1024             case Dyninst::ppc64::ixer: return 101;
1025             case Dyninst::ppc64::ilr: return 108;
1026             case Dyninst::ppc64::ictr: return 109;
1027             default: return -1;
1028          }
1029          break;
1030       case Arch_none:
1031          return -1;
1032    }
1033    //Invalid register passed
1034    return -1;
1035 }