Merge branch 'IndirectControlFlow' into parsing
[dyninst.git] / common / src / dyn_regs.C
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #define DYN_DEFINE_REGS
32 #include "common/h/dyn_regs.h"
33
34 #include "external/rose/rose-compat.h"
35 #include "external/rose/powerpcInstructionEnum.h"
36
37 #include <iostream>
38
39 using namespace Dyninst;
40
41 boost::shared_ptr<MachRegister::NameMap> MachRegister::names()
42 {
43     static boost::shared_ptr<MachRegister::NameMap> store = 
44        boost::shared_ptr<MachRegister::NameMap>(new MachRegister::NameMap);
45     return store;
46 }
47
48 MachRegister::MachRegister() :
49    reg(0)
50
51 }
52
53 MachRegister::MachRegister(signed int r) :
54    reg(r)
55 {
56 }
57  
58 MachRegister::MachRegister(signed int r, const char *n) :
59    reg(r)
60 {
61         (*names())[r] = std::string(n);
62 }
63
64 MachRegister::MachRegister(signed int r, std::string n) :
65 reg(r)
66 {
67         (*names())[r] = n;
68 }
69
70 unsigned int MachRegister::regClass() const
71 {
72     return reg & 0x00ff0000;
73 }
74
75 MachRegister MachRegister::getBaseRegister() const { 
76    switch (getArchitecture()) {
77       case Arch_x86:
78          if (reg & x86::GPR) return MachRegister(reg & 0xfffff0ff);
79          else return *this;
80       case Arch_x86_64:
81          if (reg & x86_64::GPR) return MachRegister(reg & 0xfffff0ff);
82          else return *this;
83       case Arch_ppc32:
84       case Arch_ppc64:
85       case Arch_none:
86          return *this;
87    }
88    return InvalidReg;
89 }
90    
91 Architecture MachRegister::getArchitecture() const { 
92    return (Architecture) (reg & 0xff000000);
93 }
94
95 bool MachRegister::isValid() const {
96    return (reg != InvalidReg.reg);
97 }
98
99 MachRegisterVal MachRegister::getSubRegValue(const MachRegister& subreg, 
100                                              MachRegisterVal &orig) const
101 {
102    if (subreg.reg == reg || 
103        getArchitecture() == Arch_ppc32 ||
104        getArchitecture() == Arch_ppc64)
105       return orig;
106
107    assert(subreg.getBaseRegister() == getBaseRegister());
108    switch ((subreg.reg & 0x00000f00) >> 8) {
109       case 0x0: return orig;
110       case 0x1: return (orig & 0xff);
111       case 0x2: return (orig & 0xff00) >> 8;              
112       case 0x3: return (orig & 0xffff);
113       case 0xf: return (orig & 0xffffffff);
114       default: assert(0); return orig;
115    }
116 }
117
118 std::string MachRegister::name() const { 
119         assert(names() != NULL);
120         NameMap::const_iterator iter = names()->find(reg);
121         if (iter != names()->end()) {
122                 return iter->second;
123         }
124         return std::string("<INVALID_REG>");
125 }
126
127 unsigned int MachRegister::size() const {
128    switch (getArchitecture())
129    {
130       case Arch_x86:
131          switch (reg & 0x0000ff00) {
132             case x86::L_REG: //L_REG
133             case x86::H_REG: //H_REG
134                return 1;
135             case x86::W_REG: //W_REG
136                return 2;
137             case x86::FULL: //FULL
138                return 4;
139             case x86::QUAD:
140                return 8;
141             case x86::OCT:
142                return 16;
143             case x86::FPDBL:
144                return 10;
145             case x86::BIT:
146                return 0;
147             default:
148                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
149                assert(0);
150          }
151       case Arch_x86_64:
152          switch (reg & 0x0000ff00) {
153             case x86_64::L_REG: //L_REG
154             case x86_64::H_REG: //H_REG
155                 return 1;
156             case x86_64::W_REG: //W_REG
157                 return 2;
158             case x86_64::FULL: //FULL
159                 return 8;
160             case x86_64::D_REG:
161                return 4;
162             case x86_64::OCT:
163                return 16;
164             case x86_64::FPDBL:
165                return 10;
166             case x86_64::BIT:
167                return 0;
168             default:
169                return 0; // Xiaozhu: do not assert, but return 0 as an indication of parsing junk.
170                assert(0);
171          }
172       case Arch_ppc32: {
173          int reg_class = reg & 0x00ff0000;
174          if (reg_class == ppc32::FPR || reg_class == ppc32::FSR)
175             return 8;
176          return 4;
177       }
178       case Arch_ppc64:
179          return 8;
180       case Arch_none:
181          return 0;
182    }
183    return 0; //Unreachable, but disable warnings
184 }
185    
186 bool MachRegister::operator<(const MachRegister &a) const { 
187    return (reg < a.reg);
188 }
189  
190 bool MachRegister::operator==(const MachRegister &a) const { 
191    return (reg == a.reg);
192 }
193  
194 MachRegister::operator signed int() const {
195    return reg;
196 }
197
198 signed int MachRegister::val() const {
199    return reg;
200 }
201
202
203 MachRegister MachRegister::getPC(Dyninst::Architecture arch)
204 {
205    switch (arch)
206    {
207       case Arch_x86:
208          return x86::eip;
209       case Arch_x86_64:
210          return x86_64::rip;
211       case Arch_ppc32:
212          return ppc32::pc;
213       case Arch_ppc64:
214          return ppc64::pc;
215       case Arch_none:
216          return InvalidReg;
217    }
218    return InvalidReg;
219 }
220
221 MachRegister MachRegister::getFramePointer(Dyninst::Architecture arch)
222 {
223    switch (arch)
224    {
225       case Arch_x86:
226          return x86::ebp;
227       case Arch_x86_64:
228          return x86_64::rbp;
229       case Arch_ppc32:
230          return ppc32::r1;
231       case Arch_ppc64:
232          return ppc64::r1;
233       case Arch_none:
234          return InvalidReg;
235    }
236    return InvalidReg;
237 }
238
239 MachRegister MachRegister::getStackPointer(Dyninst::Architecture arch)
240 {
241    switch (arch)
242    {
243       case Arch_x86:
244          return x86::esp;
245       case Arch_x86_64:
246          return x86_64::rsp;
247       case Arch_ppc32:
248          return ppc32::r1;
249       case Arch_ppc64:
250          return ppc64::r1;
251       case Arch_none:
252          return InvalidReg;
253    }
254    return InvalidReg;
255 }
256
257 MachRegister MachRegister::getSyscallNumberReg(Dyninst::Architecture arch)
258 {
259     switch (arch)
260     {
261         case Arch_x86:
262             return x86::eax;
263         case Arch_x86_64:
264             return x86_64::rax;
265         case Arch_ppc32:
266             return ppc32::r0;
267         case Arch_ppc64:
268             return ppc64::r0;
269         case Arch_none:
270             return InvalidReg;
271     }
272     return InvalidReg;
273 }
274
275 MachRegister MachRegister::getSyscallNumberOReg(Dyninst::Architecture arch)
276 {
277     switch (arch)
278     {
279         case Arch_x86:
280             return x86::oeax;
281         case Arch_x86_64:
282             return x86_64::orax;
283         case Arch_ppc32: 
284             return ppc32::r0;
285         case Arch_ppc64:
286             return ppc64::r0;
287         case Arch_none:
288             return InvalidReg;
289     }
290     return InvalidReg;
291 }
292
293 MachRegister MachRegister::getSyscallReturnValueReg(Dyninst::Architecture arch)
294 {
295     switch (arch)
296     {
297         case Arch_x86:
298             return x86::eax;
299         case Arch_x86_64:
300             return x86_64::rax;
301         case Arch_ppc32: 
302             return ppc32::r3;
303         case Arch_ppc64:
304             return ppc64::r3;
305         case Arch_none:
306             return InvalidReg;
307     }
308     return InvalidReg;
309 }
310
311 bool MachRegister::isPC() const
312 {
313    return (*this == x86_64::rip || *this == x86::eip ||
314            *this == ppc32::pc || *this == ppc64::pc);
315 }
316
317 bool MachRegister::isFramePointer() const
318 {
319    return (*this == x86_64::rbp || *this == x86::ebp ||
320            *this == FrameBase);
321 }
322
323 bool MachRegister::isStackPointer() const
324 {
325    return (*this == x86_64::rsp || *this == x86::esp ||
326            *this == ppc32::r1 || *this == ppc64::r1);
327 }
328
329 bool MachRegister::isSyscallNumberReg() const
330 {
331     return (*this == x86_64::orax || *this == x86::oeax ||
332             *this == ppc32::r1 || *this == ppc64::r1);
333 }
334
335 bool MachRegister::isSyscallReturnValueReg() const
336 {
337     return (*this == x86_64::rax || *this == x86::eax ||
338             *this == ppc32::r1 || *this == ppc64::r1);
339 }
340
341 COMMON_EXPORT bool Dyninst::isSegmentRegister(int regClass)
342 {
343    return 0 != (regClass & x86::SEG);
344 }
345
346 void MachRegister::getROSERegister(int &c, int &n, int &p)
347 {
348    // Rose: class, number, position
349    // Dyninst: category, base id, subrange
350
351    signed int category = (reg & 0x00ff0000);
352    signed int subrange = (reg & 0x0000ff00);
353    signed int baseID =   (reg & 0x000000ff);
354
355    switch (getArchitecture()) {
356       case Arch_x86:
357          switch (category) {
358             case x86::GPR:
359                c = x86_regclass_gpr;
360                switch (baseID) {
361                   case x86::BASEA:
362                      n = x86_gpr_ax;
363                      break;
364                   case x86::BASEC:
365                      n = x86_gpr_cx;
366                      break;
367                   case x86::BASED:
368                      n = x86_gpr_dx;
369                      break;
370                   case x86::BASEB:
371                      n = x86_gpr_bx;
372                      break;
373                   case x86::BASESP:
374                      n = x86_gpr_sp;
375                      break;
376                   case x86::BASEBP:
377                      n = x86_gpr_bp;
378                      break;
379                   case x86::BASESI:
380                      n = x86_gpr_si;
381                      break;
382                   case x86::BASEDI:
383                      n = x86_gpr_di;
384                      break;
385                   default:
386                      n = 0;
387                      break;
388                }
389                break;
390             case x86::SEG:
391                c = x86_regclass_segment;
392                switch (baseID) {
393                   case 0x0:
394                      n = x86_segreg_ds;
395                      break;
396                   case 0x1:
397                      n = x86_segreg_es;
398                      break;
399                   case 0x2:
400                      n = x86_segreg_fs;
401                      break;
402                   case 0x3:
403                      n = x86_segreg_gs;
404                      break;
405                   case 0x4:
406                      n = x86_segreg_cs;
407                      break;
408                   case 0x5:
409                      n = x86_segreg_ss;
410                      break;
411                   default:
412                      n = 0;
413                      break;
414                }
415                break;
416             case x86::FLAG:
417                c = x86_regclass_flags;
418                switch(baseID) {
419                case x86::CF:
420                  n = x86_flag_cf;
421                  break;
422                case x86::PF:
423                  n = x86_flag_pf;
424                  break;
425                case x86::AF:
426                  n = x86_flag_af;
427                  break;
428                case x86::ZF:
429                  n = x86_flag_zf;
430                  break;
431                case x86::SF:
432                  n = x86_flag_sf;
433                  break;
434                case x86::TF:
435                  n = x86_flag_tf;
436                  break;
437                case x86::IF:
438                  n = x86_flag_if;
439                  break;
440                case x86::DF:
441                  n = x86_flag_df;
442                  break;
443                case x86::OF:
444                  n = x86_flag_of;
445                  break;
446                default:
447                  assert(0);
448                  break;
449                }
450                break;
451             case x86::MISC:
452                c = x86_regclass_unknown;
453                break;
454             case x86::XMM:
455                c = x86_regclass_xmm;
456                n = baseID;
457                break;
458             case x86::MMX:
459                c = x86_regclass_mm;
460                n = baseID;
461                break;
462             case x86::CTL:
463                c = x86_regclass_cr;
464                n = baseID;
465                break;
466             case x86::DBG:
467                c = x86_regclass_dr;
468                n = baseID;
469                break;
470             case x86::TST:
471                c = x86_regclass_unknown;
472                break;
473             case 0:
474                switch (baseID) {
475                   case 0x10:
476                      c = x86_regclass_ip;
477                      n = 0;
478                      break;
479                   default:
480                      c = x86_regclass_unknown;
481                      break;
482                }
483                break;
484          }
485          break;
486      case Arch_x86_64:
487          switch (category) {
488             case x86_64::GPR:
489                c = x86_regclass_gpr;
490                switch (baseID) {
491                   case x86_64::BASEA:
492                      n = x86_gpr_ax;
493                      break;
494                   case x86_64::BASEC:
495                      n = x86_gpr_cx;
496                      break;
497                   case x86_64::BASED:
498                      n = x86_gpr_dx;
499                      break;
500                   case x86_64::BASEB:
501                      n = x86_gpr_bx;
502                      break;
503                   case x86_64::BASESP:
504                      n = x86_gpr_sp;
505                      break;
506                   case x86_64::BASEBP:
507                      n = x86_gpr_bp;
508                      break;
509                   case x86_64::BASESI:
510                      n = x86_gpr_si;
511                      break;
512                   case x86_64::BASEDI:
513                      n = x86_gpr_di;
514                      break;
515                   case x86_64::BASE8:
516                      n = x86_gpr_r8;
517                      break;
518                   case x86_64::BASE9:
519                      n = x86_gpr_r9;
520                      break;
521                   case x86_64::BASE10:
522                      n = x86_gpr_r10;
523                      break;
524                   case x86_64::BASE11:
525                      n = x86_gpr_r11;
526                      break;
527                   case x86_64::BASE12:
528                      n = x86_gpr_r12;
529                      break;
530                   case x86_64::BASE13:
531                      n = x86_gpr_r13;
532                      break;
533                   case x86_64::BASE14:
534                      n = x86_gpr_r14;
535                      break;
536                   case x86_64::BASE15:
537                      n = x86_gpr_r15;
538                      break;
539                   default:
540                      n = 0;
541                      break;
542                }
543                break;
544             case x86_64::SEG:
545                c = x86_regclass_segment;
546                switch (baseID) {
547                   case 0x0:
548                      n = x86_segreg_ds;
549                      break;
550                   case 0x1:
551                      n = x86_segreg_es;
552                      break;
553                   case 0x2:
554                      n = x86_segreg_fs;
555                      break;
556                   case 0x3:
557                      n = x86_segreg_gs;
558                      break;
559                   case 0x4:
560                      n = x86_segreg_cs;
561                      break;
562                   case 0x5:
563                      n = x86_segreg_ss;
564                      break;
565                   default:
566                      n = 0;
567                      break;
568                }
569                break;
570             case x86_64::FLAG:
571                c = x86_regclass_flags;
572                switch(baseID) {
573                case x86_64::CF:
574                  n = x86_flag_cf;
575                  break;
576                case x86_64::PF:
577                  n = x86_flag_pf;
578                  break;
579                case x86_64::AF:
580                  n = x86_flag_af;
581                  break;
582                case x86_64::ZF:
583                  n = x86_flag_zf;
584                  break;
585                case x86_64::SF:
586                  n = x86_flag_sf;
587                  break;
588                case x86_64::TF:
589                  n = x86_flag_tf;
590                  break;
591                case x86_64::IF:
592                  n = x86_flag_if;
593                  break;
594                case x86_64::DF:
595                  n = x86_flag_df;
596                  break;
597                case x86_64::OF:
598                  n = x86_flag_of;
599                  break;
600                default:
601                  assert(0);
602                  break;
603                }
604                break;
605             case x86_64::MISC:
606                c = x86_regclass_unknown;
607                break;
608             case x86_64::XMM:
609                c = x86_regclass_xmm;
610                n = baseID;
611                break;
612             case x86_64::MMX:
613                c = x86_regclass_mm;
614                n = baseID;
615                break;
616             case x86_64::CTL:
617                c = x86_regclass_cr;
618                n = baseID;
619                break;
620             case x86_64::DBG:
621                c = x86_regclass_dr;
622                n = baseID;
623                break;
624             case x86_64::TST:
625                c = x86_regclass_unknown;
626                break;
627             case 0:
628                switch (baseID) {
629                   case 0x10:
630                      c = x86_regclass_ip;
631                      n = 0;
632                      break;
633                   default:
634                      c = x86_regclass_unknown;
635                      break;
636                }
637                break;
638          }
639          break;
640  
641        case Arch_ppc32:
642        case Arch_ppc64: // 64-bit not supported in ROSE
643        {
644          baseID = reg & 0x0000FFFF;
645            n = baseID;
646            switch(category)
647            {
648                case ppc32::GPR:
649                    c = powerpc_regclass_gpr;
650                    break;
651                case ppc32::FPR:
652                case ppc32::FSR:
653                    c = powerpc_regclass_fpr;
654                    break;
655                case ppc32::SPR:
656                {
657                    if(baseID < 613) {
658                        c = powerpc_regclass_spr;
659                    } else if(baseID < 621 ) {
660                        c = powerpc_regclass_sr; 
661                    } else {
662                        c = powerpc_regclass_cr;
663                        n = baseID - 621;
664                        if(n > 7) {
665                          n = 0;
666                          p = powerpc_condreggranularity_whole;
667                        } else {
668                          p = powerpc_condreggranularity_field;
669                        }
670
671                    }
672                }
673                break;
674                default:
675                    assert(!"unknown register type!");
676                    break;
677            }
678            return;
679        }
680        default:
681          c = x86_regclass_unknown;
682          n = 0;
683          break;
684    }
685
686    switch (getArchitecture()) {
687       case Arch_x86:
688          switch (subrange) {
689             case x86::OCT:
690             case x86::FPDBL:
691                p = x86_regpos_qword;
692                break;
693             case x86::H_REG:
694                p = x86_regpos_high_byte;
695                break;
696             case x86::L_REG:
697                p = x86_regpos_low_byte;
698                break;
699             case x86::W_REG:
700                p = x86_regpos_word;
701                break;
702             case x86::FULL:
703             case x86_64::D_REG:
704                p = x86_regpos_dword;
705                break;
706             case x86::BIT:
707                p = x86_regpos_all;
708                break;
709          }
710          break;
711
712       case Arch_x86_64:
713          switch (subrange) {
714             case x86::FULL:
715             case x86::OCT:
716             case x86::FPDBL:
717                p = x86_regpos_qword;
718                break;
719             case x86::H_REG:
720                p = x86_regpos_high_byte;
721                break;
722             case x86::L_REG:
723                p = x86_regpos_low_byte;
724                break;
725             case x86::W_REG:
726                p = x86_regpos_word;
727                break;
728             case x86_64::D_REG:
729                p = x86_regpos_dword;
730                break;
731             case x86::BIT:
732                p = x86_regpos_all;
733                break;
734          }
735          break;
736       default:
737         p = x86_regpos_unknown;
738    }
739 }
740
741 MachRegister MachRegister::DwarfEncToReg(int encoding, Dyninst::Architecture arch)
742 {
743    switch (arch)
744    {
745       case Arch_x86:
746          switch (encoding) {
747             case 0: return Dyninst::x86::eax;
748             case 1: return Dyninst::x86::ecx;
749             case 2: return Dyninst::x86::edx;
750             case 3: return Dyninst::x86::ebx;
751             case 4: return Dyninst::x86::esp;
752             case 5: return Dyninst::x86::ebp;
753             case 6: return Dyninst::x86::esi;
754             case 7: return Dyninst::x86::edi;
755             case 8: return Dyninst::x86::eip;
756             case 9: return Dyninst::x86::flags;
757             case 10: return Dyninst::InvalidReg;
758             case 11: return Dyninst::x86::st0;
759             case 12: return Dyninst::x86::st1;
760             case 13: return Dyninst::x86::st2;
761             case 14: return Dyninst::x86::st3;
762             case 15: return Dyninst::x86::st4;
763             case 16: return Dyninst::x86::st5;
764             case 17: return Dyninst::x86::st6;
765             case 18: return Dyninst::x86::st7;
766             case 19: return Dyninst::InvalidReg;
767             case 20: return Dyninst::InvalidReg;
768             case 21: return Dyninst::x86::xmm0;
769             case 22: return Dyninst::x86::xmm1;
770             case 23: return Dyninst::x86::xmm2;
771             case 24: return Dyninst::x86::xmm3;
772             case 25: return Dyninst::x86::xmm4;
773             case 26: return Dyninst::x86::xmm5;
774             case 27: return Dyninst::x86::xmm6;
775             case 28: return Dyninst::x86::xmm7;
776             case 29: return Dyninst::x86::mm0;
777             case 30: return Dyninst::x86::mm1;
778             case 31: return Dyninst::x86::mm2;
779             case 32: return Dyninst::x86::mm3;
780             case 33: return Dyninst::x86::mm4;
781             case 34: return Dyninst::x86::mm5;
782             case 35: return Dyninst::x86::mm6;
783             case 36: return Dyninst::x86::mm7;
784             case 37: return Dyninst::InvalidReg; //fcw
785             case 38: return Dyninst::InvalidReg; //fsw
786             case 39: return Dyninst::InvalidReg; //mxcsr
787             case 40: return Dyninst::x86::es;
788             case 41: return Dyninst::x86::cs;
789             case 42: return Dyninst::x86::ss;
790             case 43: return Dyninst::x86::ds;
791             case 44: return Dyninst::x86::fs;
792             case 45: return Dyninst::x86::gs;
793             case 46: return Dyninst::InvalidReg;
794             case 47: return Dyninst::InvalidReg;
795             case 48: return Dyninst::InvalidReg; //tr
796             case 49: return Dyninst::InvalidReg; //ldtr
797             default: return Dyninst::InvalidReg;
798          }
799          break;
800       case Arch_x86_64:
801          switch (encoding) {
802             case 0: return Dyninst::x86_64::rax;
803             case 1: return Dyninst::x86_64::rdx;
804             case 2: return Dyninst::x86_64::rcx;
805             case 3: return Dyninst::x86_64::rbx;
806             case 4: return Dyninst::x86_64::rsi;
807             case 5: return Dyninst::x86_64::rdi;
808             case 6: return Dyninst::x86_64::rbp;
809             case 7: return Dyninst::x86_64::rsp;
810             case 8: return Dyninst::x86_64::r8;
811             case 9: return Dyninst::x86_64::r9;
812             case 10: return Dyninst::x86_64::r10;
813             case 11: return Dyninst::x86_64::r11;
814             case 12: return Dyninst::x86_64::r12;
815             case 13: return Dyninst::x86_64::r13;
816             case 14: return Dyninst::x86_64::r14;
817             case 15: return Dyninst::x86_64::r15;
818             case 16: return Dyninst::x86_64::rip;
819             case 17: return Dyninst::x86_64::xmm0;
820             case 18: return Dyninst::x86_64::xmm1;
821             case 19: return Dyninst::x86_64::xmm2;
822             case 20: return Dyninst::x86_64::xmm3;
823             case 21: return Dyninst::x86_64::xmm4;
824             case 22: return Dyninst::x86_64::xmm5;
825             case 23: return Dyninst::x86_64::xmm6;
826             case 24: return Dyninst::x86_64::xmm7;
827             case 25: return Dyninst::x86_64::xmm8;
828             case 26: return Dyninst::x86_64::xmm9;
829             case 27: return Dyninst::x86_64::xmm10;
830             case 28: return Dyninst::x86_64::xmm11;
831             case 29: return Dyninst::x86_64::xmm12;
832             case 30: return Dyninst::x86_64::xmm13;
833             case 31: return Dyninst::x86_64::xmm14;
834             case 32: return Dyninst::x86_64::xmm15;
835             case 33: return Dyninst::x86_64::st0;
836             case 34: return Dyninst::x86_64::st1;
837             case 35: return Dyninst::x86_64::st2;
838             case 36: return Dyninst::x86_64::st3;
839             case 37: return Dyninst::x86_64::st4;
840             case 38: return Dyninst::x86_64::st5;
841             case 39: return Dyninst::x86_64::st6;
842             case 40: return Dyninst::x86_64::st7;
843             case 41: return Dyninst::x86_64::mm0;
844             case 42: return Dyninst::x86_64::mm1;
845             case 43: return Dyninst::x86_64::mm2;
846             case 44: return Dyninst::x86_64::mm3;
847             case 45: return Dyninst::x86_64::mm4;
848             case 46: return Dyninst::x86_64::mm5;
849             case 47: return Dyninst::x86_64::mm6;
850             case 48: return Dyninst::x86_64::mm7;
851             case 49: return Dyninst::x86_64::flags;
852             case 50: return Dyninst::x86_64::es;
853             case 51: return Dyninst::x86_64::cs;
854             case 52: return Dyninst::x86_64::ss;
855             case 53: return Dyninst::x86_64::ds;
856             case 54: return Dyninst::x86_64::fs;
857             case 55: return Dyninst::x86_64::gs;
858             case 56: return Dyninst::InvalidReg;
859             case 57: return Dyninst::InvalidReg;
860             case 58: return Dyninst::x86_64::fsbase;
861             case 59: return Dyninst::x86_64::gsbase;
862             case 60: return Dyninst::InvalidReg; 
863             case 61: return Dyninst::InvalidReg; 
864             case 62: return Dyninst::InvalidReg; //tr
865             case 63: return Dyninst::InvalidReg; //ldtr
866             case 64: return Dyninst::InvalidReg; //mxcsr
867             case 65: return Dyninst::InvalidReg; //fcw
868             case 66: return Dyninst::InvalidReg; //fsw
869          }
870          break;
871       case Arch_ppc32:
872          switch (encoding) {
873             case 0: return Dyninst::ppc32::r0;
874             case 1: return Dyninst::ppc32::r1;
875             case 2: return Dyninst::ppc32::r2;
876             case 3: return Dyninst::ppc32::r3;
877             case 4: return Dyninst::ppc32::r4;
878             case 5: return Dyninst::ppc32::r5;
879             case 6: return Dyninst::ppc32::r6;
880             case 7: return Dyninst::ppc32::r7;
881             case 8: return Dyninst::ppc32::r8;
882             case 9: return Dyninst::ppc32::r9;
883             case 10: return Dyninst::ppc32::r10;
884             case 11: return Dyninst::ppc32::r11;
885             case 12: return Dyninst::ppc32::r12;
886             case 13: return Dyninst::ppc32::r13;
887             case 14: return Dyninst::ppc32::r14;
888             case 15: return Dyninst::ppc32::r15;
889             case 16: return Dyninst::ppc32::r16;
890             case 17: return Dyninst::ppc32::r17;
891             case 18: return Dyninst::ppc32::r18;
892             case 19: return Dyninst::ppc32::r19;
893             case 20: return Dyninst::ppc32::r20;
894             case 21: return Dyninst::ppc32::r21;
895             case 22: return Dyninst::ppc32::r22;
896             case 23: return Dyninst::ppc32::r23;
897             case 24: return Dyninst::ppc32::r24;
898             case 25: return Dyninst::ppc32::r25;
899             case 26: return Dyninst::ppc32::r26;
900             case 27: return Dyninst::ppc32::r27;
901             case 28: return Dyninst::ppc32::r28;
902             case 29: return Dyninst::ppc32::r29;
903             case 30: return Dyninst::ppc32::r30;
904             case 31: return Dyninst::ppc32::r31;
905             case 32: return Dyninst::ppc32::fpr0;
906             case 33: return Dyninst::ppc32::fpr1;
907             case 34: return Dyninst::ppc32::fpr2;
908             case 35: return Dyninst::ppc32::fpr3;
909             case 36: return Dyninst::ppc32::fpr4;
910             case 37: return Dyninst::ppc32::fpr5;
911             case 38: return Dyninst::ppc32::fpr6;
912             case 39: return Dyninst::ppc32::fpr7;
913             case 40: return Dyninst::ppc32::fpr8;
914             case 41: return Dyninst::ppc32::fpr9;
915             case 42: return Dyninst::ppc32::fpr10;
916             case 43: return Dyninst::ppc32::fpr11;
917             case 44: return Dyninst::ppc32::fpr12;
918             case 45: return Dyninst::ppc32::fpr13;
919             case 46: return Dyninst::ppc32::fpr14;
920             case 47: return Dyninst::ppc32::fpr15;
921             case 48: return Dyninst::ppc32::fpr16;
922             case 49: return Dyninst::ppc32::fpr17;
923             case 50: return Dyninst::ppc32::fpr18;
924             case 51: return Dyninst::ppc32::fpr19;
925             case 52: return Dyninst::ppc32::fpr20;
926             case 53: return Dyninst::ppc32::fpr21;
927             case 54: return Dyninst::ppc32::fpr22;
928             case 55: return Dyninst::ppc32::fpr23;
929             case 56: return Dyninst::ppc32::fpr24;
930             case 57: return Dyninst::ppc32::fpr25;
931             case 58: return Dyninst::ppc32::fpr26;
932             case 59: return Dyninst::ppc32::fpr27;
933             case 60: return Dyninst::ppc32::fpr28;
934             case 61: return Dyninst::ppc32::fpr29;
935             case 62: return Dyninst::ppc32::fpr30;
936             case 63: return Dyninst::ppc32::fpr31;
937             case 64: return Dyninst::ppc32::cr;
938             case 65: return Dyninst::InvalidReg; //FPSCR
939          }
940          //Seperate switch statements to give compilers an easier time of 
941          // optimizing
942          switch (encoding) {
943             case 100: return Dyninst::ppc32::mq;
944             case 101: return Dyninst::ppc32::xer;
945             case 102: return Dyninst::InvalidReg;
946             case 103: return Dyninst::InvalidReg;
947             case 104: return Dyninst::InvalidReg; //RTCU
948             case 105: return Dyninst::InvalidReg; //RTCL
949             case 106: return Dyninst::InvalidReg;
950             case 107: return Dyninst::InvalidReg;
951             case 108: return Dyninst::ppc32::lr;
952             case 109: return Dyninst::ppc32::ctr;
953             default: return Dyninst::InvalidReg;
954          }
955          break;
956       case Arch_ppc64:
957          switch (encoding) {
958             case 0: return Dyninst::ppc64::r0;
959             case 1: return Dyninst::ppc64::r1;
960             case 2: return Dyninst::ppc64::r2;
961             case 3: return Dyninst::ppc64::r3;
962             case 4: return Dyninst::ppc64::r4;
963             case 5: return Dyninst::ppc64::r5;
964             case 6: return Dyninst::ppc64::r6;
965             case 7: return Dyninst::ppc64::r7;
966             case 8: return Dyninst::ppc64::r8;
967             case 9: return Dyninst::ppc64::r9;
968             case 10: return Dyninst::ppc64::r10;
969             case 11: return Dyninst::ppc64::r11;
970             case 12: return Dyninst::ppc64::r12;
971             case 13: return Dyninst::ppc64::r13;
972             case 14: return Dyninst::ppc64::r14;
973             case 15: return Dyninst::ppc64::r15;
974             case 16: return Dyninst::ppc64::r16;
975             case 17: return Dyninst::ppc64::r17;
976             case 18: return Dyninst::ppc64::r18;
977             case 19: return Dyninst::ppc64::r19;
978             case 20: return Dyninst::ppc64::r20;
979             case 21: return Dyninst::ppc64::r21;
980             case 22: return Dyninst::ppc64::r22;
981             case 23: return Dyninst::ppc64::r23;
982             case 24: return Dyninst::ppc64::r24;
983             case 25: return Dyninst::ppc64::r25;
984             case 26: return Dyninst::ppc64::r26;
985             case 27: return Dyninst::ppc64::r27;
986             case 28: return Dyninst::ppc64::r28;
987             case 29: return Dyninst::ppc64::r29;
988             case 30: return Dyninst::ppc64::r30;
989             case 31: return Dyninst::ppc64::r31;
990             case 32: return Dyninst::ppc64::fpr0;
991             case 33: return Dyninst::ppc64::fpr1;
992             case 34: return Dyninst::ppc64::fpr2;
993             case 35: return Dyninst::ppc64::fpr3;
994             case 36: return Dyninst::ppc64::fpr4;
995             case 37: return Dyninst::ppc64::fpr5;
996             case 38: return Dyninst::ppc64::fpr6;
997             case 39: return Dyninst::ppc64::fpr7;
998             case 40: return Dyninst::ppc64::fpr8;
999             case 41: return Dyninst::ppc64::fpr9;
1000             case 42: return Dyninst::ppc64::fpr10;
1001             case 43: return Dyninst::ppc64::fpr11;
1002             case 44: return Dyninst::ppc64::fpr12;
1003             case 45: return Dyninst::ppc64::fpr13;
1004             case 46: return Dyninst::ppc64::fpr14;
1005             case 47: return Dyninst::ppc64::fpr15;
1006             case 48: return Dyninst::ppc64::fpr16;
1007             case 49: return Dyninst::ppc64::fpr17;
1008             case 50: return Dyninst::ppc64::fpr18;
1009             case 51: return Dyninst::ppc64::fpr19;
1010             case 52: return Dyninst::ppc64::fpr20;
1011             case 53: return Dyninst::ppc64::fpr21;
1012             case 54: return Dyninst::ppc64::fpr22;
1013             case 55: return Dyninst::ppc64::fpr23;
1014             case 56: return Dyninst::ppc64::fpr24;
1015             case 57: return Dyninst::ppc64::fpr25;
1016             case 58: return Dyninst::ppc64::fpr26;
1017             case 59: return Dyninst::ppc64::fpr27;
1018             case 60: return Dyninst::ppc64::fpr28;
1019             case 61: return Dyninst::ppc64::fpr29;
1020             case 62: return Dyninst::ppc64::fpr30;
1021             case 63: return Dyninst::ppc64::fpr31;
1022             case 64: return Dyninst::ppc64::cr;
1023             case 65: return Dyninst::InvalidReg; //FPSCR
1024          }
1025          //Seperate switch statements to give compilers an easier time of 
1026          // optimizing
1027          switch (encoding) {
1028             case 100: return Dyninst::ppc64::mq;
1029             case 101: return Dyninst::ppc64::xer;
1030             case 102: return Dyninst::InvalidReg;
1031             case 103: return Dyninst::InvalidReg;
1032             case 104: return Dyninst::InvalidReg; //RTCU
1033             case 105: return Dyninst::InvalidReg; //RTCL
1034             case 106: return Dyninst::InvalidReg;
1035             case 107: return Dyninst::InvalidReg;
1036             case 108: return Dyninst::ppc64::lr;
1037             case 109: return Dyninst::ppc64::ctr;
1038             default: return Dyninst::InvalidReg;
1039          }
1040          break;
1041       case Arch_none:
1042          return Dyninst::InvalidReg;
1043          break;
1044    }
1045    //Invalid Architecture passed
1046    return Dyninst::InvalidReg;
1047
1048 }
1049
1050 int MachRegister::getDwarfEnc() const
1051 {
1052    switch (getArchitecture())
1053    {
1054       case Arch_x86:
1055          switch (val()) {
1056             case Dyninst::x86::ieax: return 0;
1057             case Dyninst::x86::iecx: return 1;
1058             case Dyninst::x86::iedx: return 2;
1059             case Dyninst::x86::iebx: return 3;
1060             case Dyninst::x86::iesp: return 4;
1061             case Dyninst::x86::iebp: return 5;
1062             case Dyninst::x86::iesi: return 6;
1063             case Dyninst::x86::iedi: return 7;
1064             case Dyninst::x86::ieip: return 8;
1065             case Dyninst::x86::iflags: return 9;
1066             case Dyninst::x86::ixmm0: return 21;
1067             case Dyninst::x86::ixmm1: return 22;
1068             case Dyninst::x86::ixmm2: return 23;
1069             case Dyninst::x86::ixmm3: return 24;
1070             case Dyninst::x86::ixmm4: return 25;
1071             case Dyninst::x86::ixmm5: return 26;
1072             case Dyninst::x86::ixmm6: return 27;
1073             case Dyninst::x86::ixmm7: return 28;
1074             case Dyninst::x86::imm0: return 29;
1075             case Dyninst::x86::imm1: return 30;
1076             case Dyninst::x86::imm2: return 31;
1077             case Dyninst::x86::imm3: return 32;
1078             case Dyninst::x86::imm4: return 33;
1079             case Dyninst::x86::imm5: return 34;
1080             case Dyninst::x86::imm6: return 35;
1081             case Dyninst::x86::imm7: return 36;
1082             case Dyninst::x86::ies: return 40;
1083             case Dyninst::x86::ics: return 41;
1084             case Dyninst::x86::iss: return 42;
1085             case Dyninst::x86::ids: return 43;
1086             case Dyninst::x86::ifs: return 44;
1087             case Dyninst::x86::igs: return 45;
1088             default: return -1;
1089          }
1090          break;
1091       case Arch_x86_64:
1092          switch (val()) {
1093             case Dyninst::x86_64::irax: return 0;
1094             case Dyninst::x86_64::irdx: return 1;
1095             case Dyninst::x86_64::ircx: return 2;
1096             case Dyninst::x86_64::irbx: return 3;
1097             case Dyninst::x86_64::irsi: return 4;
1098             case Dyninst::x86_64::irdi: return 5;
1099             case Dyninst::x86_64::irbp: return 6;
1100             case Dyninst::x86_64::irsp: return 7;
1101             case Dyninst::x86_64::ir8: return 8;
1102             case Dyninst::x86_64::ir9: return 9;
1103             case Dyninst::x86_64::ir10: return 10;
1104             case Dyninst::x86_64::ir11: return 11;
1105             case Dyninst::x86_64::ir12: return 12;
1106             case Dyninst::x86_64::ir13: return 13;
1107             case Dyninst::x86_64::ir14: return 14;
1108             case Dyninst::x86_64::ir15: return 15;
1109             case Dyninst::x86_64::irip: return 16;
1110             case Dyninst::x86_64::ixmm0: return 17;
1111             case Dyninst::x86_64::ixmm1: return 18;
1112             case Dyninst::x86_64::ixmm2: return 19;
1113             case Dyninst::x86_64::ixmm3: return 20;
1114             case Dyninst::x86_64::ixmm4: return 21;
1115             case Dyninst::x86_64::ixmm5: return 22;
1116             case Dyninst::x86_64::ixmm6: return 23;
1117             case Dyninst::x86_64::ixmm7: return 24;
1118             case Dyninst::x86_64::ixmm8: return 25;
1119             case Dyninst::x86_64::ixmm9: return 26;
1120             case Dyninst::x86_64::ixmm10: return 27;
1121             case Dyninst::x86_64::ixmm11: return 28;
1122             case Dyninst::x86_64::ixmm12: return 29;
1123             case Dyninst::x86_64::ixmm13: return 30;
1124             case Dyninst::x86_64::ixmm14: return 31;
1125             case Dyninst::x86_64::ixmm15: return 32;
1126             case Dyninst::x86_64::imm0: return 41;
1127             case Dyninst::x86_64::imm1: return 42;
1128             case Dyninst::x86_64::imm2: return 43;
1129             case Dyninst::x86_64::imm3: return 44;
1130             case Dyninst::x86_64::imm4: return 45;
1131             case Dyninst::x86_64::imm5: return 46;
1132             case Dyninst::x86_64::imm6: return 47;
1133             case Dyninst::x86_64::imm7: return 48;
1134             case Dyninst::x86_64::iflags: return 49;
1135             case Dyninst::x86_64::ies: return 50;
1136             case Dyninst::x86_64::ics: return 51;
1137             case Dyninst::x86_64::iss: return 52;
1138             case Dyninst::x86_64::ids: return 53;
1139             case Dyninst::x86_64::ifs: return 54;
1140             case Dyninst::x86_64::igs: return 55;
1141             case Dyninst::x86_64::ifsbase: return 58;
1142             case Dyninst::x86_64::igsbase: return 59;
1143             default: return -1;
1144          }
1145          break;
1146       case Arch_ppc32:
1147          switch (val()) {
1148             case Dyninst::ppc32::ir0: return 0;
1149             case Dyninst::ppc32::ir1: return 1;
1150             case Dyninst::ppc32::ir2: return 2;
1151             case Dyninst::ppc32::ir3: return 3;
1152             case Dyninst::ppc32::ir4: return 4;
1153             case Dyninst::ppc32::ir5: return 5;
1154             case Dyninst::ppc32::ir6: return 6;
1155             case Dyninst::ppc32::ir7: return 7;
1156             case Dyninst::ppc32::ir8: return 8;
1157             case Dyninst::ppc32::ir9: return 9;
1158             case Dyninst::ppc32::ir10: return 10;
1159             case Dyninst::ppc32::ir11: return 11;
1160             case Dyninst::ppc32::ir12: return 12;
1161             case Dyninst::ppc32::ir13: return 13;
1162             case Dyninst::ppc32::ir14: return 14;
1163             case Dyninst::ppc32::ir15: return 15;
1164             case Dyninst::ppc32::ir16: return 16;
1165             case Dyninst::ppc32::ir17: return 17;
1166             case Dyninst::ppc32::ir18: return 18;
1167             case Dyninst::ppc32::ir19: return 19;
1168             case Dyninst::ppc32::ir20: return 20;
1169             case Dyninst::ppc32::ir21: return 21;
1170             case Dyninst::ppc32::ir22: return 22;
1171             case Dyninst::ppc32::ir23: return 23;
1172             case Dyninst::ppc32::ir24: return 24;
1173             case Dyninst::ppc32::ir25: return 25;
1174             case Dyninst::ppc32::ir26: return 26;
1175             case Dyninst::ppc32::ir27: return 27;
1176             case Dyninst::ppc32::ir28: return 28;
1177             case Dyninst::ppc32::ir29: return 29;
1178             case Dyninst::ppc32::ir30: return 30;
1179             case Dyninst::ppc32::ir31: return 31;
1180             case Dyninst::ppc32::ifpr0: return 32;
1181             case Dyninst::ppc32::ifpr1: return 33;
1182             case Dyninst::ppc32::ifpr2: return 34;
1183             case Dyninst::ppc32::ifpr3: return 35;
1184             case Dyninst::ppc32::ifpr4: return 36;
1185             case Dyninst::ppc32::ifpr5: return 37;
1186             case Dyninst::ppc32::ifpr6: return 38;
1187             case Dyninst::ppc32::ifpr7: return 39;
1188             case Dyninst::ppc32::ifpr8: return 40;
1189             case Dyninst::ppc32::ifpr9: return 41;
1190             case Dyninst::ppc32::ifpr10: return 42;
1191             case Dyninst::ppc32::ifpr11: return 43;
1192             case Dyninst::ppc32::ifpr12: return 44;
1193             case Dyninst::ppc32::ifpr13: return 45;
1194             case Dyninst::ppc32::ifpr14: return 46;
1195             case Dyninst::ppc32::ifpr15: return 47;
1196             case Dyninst::ppc32::ifpr16: return 48;
1197             case Dyninst::ppc32::ifpr17: return 49;
1198             case Dyninst::ppc32::ifpr18: return 50;
1199             case Dyninst::ppc32::ifpr19: return 51;
1200             case Dyninst::ppc32::ifpr20: return 52;
1201             case Dyninst::ppc32::ifpr21: return 53;
1202             case Dyninst::ppc32::ifpr22: return 54;
1203             case Dyninst::ppc32::ifpr23: return 55;
1204             case Dyninst::ppc32::ifpr24: return 56;
1205             case Dyninst::ppc32::ifpr25: return 57;
1206             case Dyninst::ppc32::ifpr26: return 58;
1207             case Dyninst::ppc32::ifpr27: return 59;
1208             case Dyninst::ppc32::ifpr28: return 60;
1209             case Dyninst::ppc32::ifpr29: return 61;
1210             case Dyninst::ppc32::ifpr30: return 62;
1211             case Dyninst::ppc32::ifpr31: return 63;
1212             case Dyninst::ppc32::icr: return 64;
1213             case Dyninst::ppc32::imq: return 100;
1214             case Dyninst::ppc32::ixer: return 101;
1215             case Dyninst::ppc32::ilr: return 108;
1216             case Dyninst::ppc32::ictr: return 109;
1217             default: return -1;
1218          }
1219       case Arch_ppc64:
1220          switch (val()) {
1221             case Dyninst::ppc64::ir0: return 0;
1222             case Dyninst::ppc64::ir1: return 1;
1223             case Dyninst::ppc64::ir2: return 2;
1224             case Dyninst::ppc64::ir3: return 3;
1225             case Dyninst::ppc64::ir4: return 4;
1226             case Dyninst::ppc64::ir5: return 5;
1227             case Dyninst::ppc64::ir6: return 6;
1228             case Dyninst::ppc64::ir7: return 7;
1229             case Dyninst::ppc64::ir8: return 8;
1230             case Dyninst::ppc64::ir9: return 9;
1231             case Dyninst::ppc64::ir10: return 10;
1232             case Dyninst::ppc64::ir11: return 11;
1233             case Dyninst::ppc64::ir12: return 12;
1234             case Dyninst::ppc64::ir13: return 13;
1235             case Dyninst::ppc64::ir14: return 14;
1236             case Dyninst::ppc64::ir15: return 15;
1237             case Dyninst::ppc64::ir16: return 16;
1238             case Dyninst::ppc64::ir17: return 17;
1239             case Dyninst::ppc64::ir18: return 18;
1240             case Dyninst::ppc64::ir19: return 19;
1241             case Dyninst::ppc64::ir20: return 20;
1242             case Dyninst::ppc64::ir21: return 21;
1243             case Dyninst::ppc64::ir22: return 22;
1244             case Dyninst::ppc64::ir23: return 23;
1245             case Dyninst::ppc64::ir24: return 24;
1246             case Dyninst::ppc64::ir25: return 25;
1247             case Dyninst::ppc64::ir26: return 26;
1248             case Dyninst::ppc64::ir27: return 27;
1249             case Dyninst::ppc64::ir28: return 28;
1250             case Dyninst::ppc64::ir29: return 29;
1251             case Dyninst::ppc64::ir30: return 30;
1252             case Dyninst::ppc64::ir31: return 31;
1253             case Dyninst::ppc64::ifpr0: return 32;
1254             case Dyninst::ppc64::ifpr1: return 33;
1255             case Dyninst::ppc64::ifpr2: return 34;
1256             case Dyninst::ppc64::ifpr3: return 35;
1257             case Dyninst::ppc64::ifpr4: return 36;
1258             case Dyninst::ppc64::ifpr5: return 37;
1259             case Dyninst::ppc64::ifpr6: return 38;
1260             case Dyninst::ppc64::ifpr7: return 39;
1261             case Dyninst::ppc64::ifpr8: return 40;
1262             case Dyninst::ppc64::ifpr9: return 41;
1263             case Dyninst::ppc64::ifpr10: return 42;
1264             case Dyninst::ppc64::ifpr11: return 43;
1265             case Dyninst::ppc64::ifpr12: return 44;
1266             case Dyninst::ppc64::ifpr13: return 45;
1267             case Dyninst::ppc64::ifpr14: return 46;
1268             case Dyninst::ppc64::ifpr15: return 47;
1269             case Dyninst::ppc64::ifpr16: return 48;
1270             case Dyninst::ppc64::ifpr17: return 49;
1271             case Dyninst::ppc64::ifpr18: return 50;
1272             case Dyninst::ppc64::ifpr19: return 51;
1273             case Dyninst::ppc64::ifpr20: return 52;
1274             case Dyninst::ppc64::ifpr21: return 53;
1275             case Dyninst::ppc64::ifpr22: return 54;
1276             case Dyninst::ppc64::ifpr23: return 55;
1277             case Dyninst::ppc64::ifpr24: return 56;
1278             case Dyninst::ppc64::ifpr25: return 57;
1279             case Dyninst::ppc64::ifpr26: return 58;
1280             case Dyninst::ppc64::ifpr27: return 59;
1281             case Dyninst::ppc64::ifpr28: return 60;
1282             case Dyninst::ppc64::ifpr29: return 61;
1283             case Dyninst::ppc64::ifpr30: return 62;
1284             case Dyninst::ppc64::ifpr31: return 63;
1285             case Dyninst::ppc64::icr: return 64;
1286             case Dyninst::ppc64::imq: return 100;
1287             case Dyninst::ppc64::ixer: return 101;
1288             case Dyninst::ppc64::ilr: return 108;
1289             case Dyninst::ppc64::ictr: return 109;
1290             default: return -1;
1291          }
1292          break;
1293       case Arch_none:
1294          return -1;
1295    }
1296    //Invalid register passed
1297    return -1;
1298 }
1299
1300 unsigned Dyninst::getArchAddressWidth(Dyninst::Architecture arch)
1301 {
1302    switch (arch) {
1303       case Arch_none: 
1304          return 0;
1305       case Arch_x86:
1306       case Arch_ppc32:
1307          return 4;
1308       case Arch_x86_64:
1309       case Arch_ppc64:
1310          return 8;
1311    }
1312    return 0;
1313 }
1314