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