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