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