Merge branch 'master' 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                 case Arch_aarch32:
88                 case Arch_aarch64:
89                                   //not verified
90                    return *this;
91    }
92    return InvalidReg;
93 }
94
95 Architecture MachRegister::getArchitecture() const {
96    return (Architecture) (reg & 0xff000000);
97 }
98
99 bool MachRegister::isValid() const {
100    return (reg != InvalidReg.reg);
101 }
102
103 MachRegisterVal MachRegister::getSubRegValue(const MachRegister& subreg,
104                                              MachRegisterVal &orig) const
105 {
106   if( getArchitecture() == Arch_aarch64 ){
107     assert(0);//this is not implemented
108   }
109
110    if (subreg.reg == reg ||
111        getArchitecture() == Arch_ppc32 ||
112        getArchitecture() == Arch_ppc64)
113       return orig;
114
115    assert(subreg.getBaseRegister() == getBaseRegister());
116    switch ((subreg.reg & 0x00000f00) >> 8) {
117       case 0x0: return orig;
118       case 0x1: return (orig & 0xff);
119       case 0x2: return (orig & 0xff00) >> 8;
120       case 0x3: return (orig & 0xffff);
121       case 0xf: return (orig & 0xffffffff);
122       default: assert(0); return orig;
123    }
124 }
125
126 std::string MachRegister::name() const {
127         assert(names() != NULL);
128         NameMap::const_iterator iter = names()->find(reg);
129         if (iter != names()->end()) {
130                 return iter->second;
131         }
132         return std::string("<INVALID_REG>");
133 }
134
135 unsigned int MachRegister::size() const {
136    switch (getArchitecture())
137    {
138       case Arch_x86:
139          switch (reg & 0x0000ff00) {
140             case x86::L_REG: //L_REG
141             case x86::H_REG: //H_REG
142                return 1;
143             case x86::W_REG: //W_REG
144                return 2;
145             case x86::FULL: //FULL
146                return 4;
147             case x86::QUAD:
148                return 8;
149             case x86::OCT:
150                return 16;
151             case x86::FPDBL:
152                return 10;
153             case x86::BIT:
154                return 0;
155             default:
156                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
157                assert(0);
158          }
159       case Arch_x86_64:
160          switch (reg & 0x0000ff00) {
161             case x86_64::L_REG: //L_REG
162             case x86_64::H_REG: //H_REG
163                 return 1;
164             case x86_64::W_REG: //W_REG
165                 return 2;
166             case x86_64::FULL: //FULL
167                 return 8;
168             case x86_64::D_REG:
169                return 4;
170             case x86_64::OCT:
171                return 16;
172             case x86_64::FPDBL:
173                return 10;
174             case x86_64::BIT:
175                return 0;
176             default:
177                return 0; // Xiaozhu: do not assert, but return 0 as an indication of parsing junk.
178                assert(0);
179          }
180       case Arch_ppc32: {
181          int reg_class = reg & 0x00ff0000;
182          if (reg_class == ppc32::FPR || reg_class == ppc32::FSR)
183             return 8;
184          return 4;
185       }
186       case Arch_ppc64:
187                 case Arch_aarch64:
188         if((reg & 0x00ff0000) == aarch64::FPR)
189           return 16; //aarch64: 128bit = 16*8bit
190         return 8; //aarch64: 64bit = 8*8
191       case Arch_aarch32:
192         assert(0);
193       case Arch_none:
194          return 0;
195    }
196    return 0; //Unreachable, but disable warnings
197 }
198
199 bool MachRegister::operator<(const MachRegister &a) const {
200    return (reg < a.reg);
201 }
202
203 bool MachRegister::operator==(const MachRegister &a) const {
204    return (reg == a.reg);
205 }
206
207 MachRegister::operator signed int() const {
208    return reg;
209 }
210
211 signed int MachRegister::val() const {
212    return reg;
213 }
214
215
216 MachRegister MachRegister::getPC(Dyninst::Architecture arch)
217 {
218    switch (arch)
219    {
220       case Arch_x86:
221          return x86::eip;
222       case Arch_x86_64:
223          return x86_64::rip;
224       case Arch_ppc32:
225          return ppc32::pc;
226       case Arch_ppc64:
227          return ppc64::pc;
228       case Arch_aarch64:  //aarch64: pc is not writable
229          return aarch64::pc;
230       case Arch_aarch32:
231          assert(0);
232       case Arch_none:
233          return InvalidReg;
234    }
235    return InvalidReg;
236 }
237
238 MachRegister MachRegister::getFramePointer(Dyninst::Architecture arch)
239 {
240    switch (arch)
241    {
242       case Arch_x86:
243          return x86::ebp;
244       case Arch_x86_64:
245          return x86_64::rbp;
246       case Arch_ppc32:
247          return ppc32::r1;
248       case Arch_ppc64:
249          return ppc64::r1;
250       case Arch_aarch64:
251          return aarch64::x29; //aarch64: frame pointer is X29 by convention
252       case Arch_none:
253          return InvalidReg;
254       default:
255          assert(0);
256          return InvalidReg;
257    }
258    return InvalidReg;
259 }
260
261 MachRegister MachRegister::getStackPointer(Dyninst::Architecture arch)
262 {
263    switch (arch)
264    {
265       case Arch_x86:
266          return x86::esp;
267       case Arch_x86_64:
268          return x86_64::rsp;
269       case Arch_ppc32:
270          return ppc32::r1;
271       case Arch_ppc64:
272          return ppc64::r1;
273       case Arch_aarch64:
274          return aarch64::sp; //aarch64: stack pointer is an independent register
275       case Arch_aarch32:
276          assert(0);
277       case Arch_none:
278          return InvalidReg;
279       default:
280          assert(0);
281          return InvalidReg;
282    }
283    return InvalidReg;
284 }
285
286 MachRegister MachRegister::getSyscallNumberReg(Dyninst::Architecture arch)
287 {
288     switch (arch)
289     {
290         case Arch_x86:
291             return x86::eax;
292         case Arch_x86_64:
293             return x86_64::rax;
294         case Arch_ppc32:
295             return ppc32::r0;
296         case Arch_ppc64:
297             return ppc64::r0;
298         case Arch_aarch64:
299             return aarch64::x8;
300         case Arch_aarch32:
301             assert(0);
302         case Arch_none:
303             return InvalidReg;
304       default:
305          assert(0);
306          return InvalidReg;
307     }
308     return InvalidReg;
309 }
310
311 MachRegister MachRegister::getSyscallNumberOReg(Dyninst::Architecture arch)
312 {
313     switch (arch)
314     {
315         case Arch_x86:
316             return x86::oeax;
317         case Arch_x86_64:
318             return x86_64::orax;
319         case Arch_ppc32:
320             return ppc32::r0;
321         case Arch_ppc64:
322             return ppc64::r0;
323         case Arch_aarch64:
324             return aarch64::x8;
325         case Arch_none:
326             return InvalidReg;
327       default:
328          assert(0);
329          return InvalidReg;
330     }
331     return InvalidReg;
332 }
333
334 MachRegister MachRegister::getSyscallReturnValueReg(Dyninst::Architecture arch)
335 {
336     switch (arch)
337     {
338         case Arch_x86:
339             return x86::eax;
340         case Arch_x86_64:
341             return x86_64::rax;
342         case Arch_ppc32:
343             return ppc32::r3;
344         case Arch_ppc64:
345             return ppc64::r3;
346         case Arch_aarch64:
347             return aarch64::x0; //returned value is save in x0
348         case Arch_none:
349             return InvalidReg;
350       default:
351          assert(0);
352          return InvalidReg;
353     }
354     return InvalidReg;
355 }
356
357 bool MachRegister::isPC() const
358 {
359    return (*this == x86_64::rip || *this == x86::eip ||
360            *this == ppc32::pc || *this == ppc64::pc ||
361            *this == aarch64::pc );
362 }
363
364 bool MachRegister::isFramePointer() const
365 {
366    return (*this == x86_64::rbp || *this == x86::ebp ||
367            *this == FrameBase ||
368            *this == aarch64::x29);
369 }
370
371 bool MachRegister::isStackPointer() const
372 {
373    return (*this == x86_64::rsp || *this == x86::esp ||
374            *this == ppc32::r1   || *this == ppc64::r1 ||
375            *this == aarch64::sp);
376 }
377
378 bool MachRegister::isSyscallNumberReg() const
379 {
380    return ( *this == x86_64::orax || *this == x86::oeax ||
381             *this == ppc32::r1    || *this == ppc64::r1 ||
382             *this == aarch64::x8
383             );
384 }
385
386 bool MachRegister::isSyscallReturnValueReg() const
387 {
388    if(getArchitecture() == Arch_aarch64)
389       assert(0);
390     return (*this == x86_64::rax || *this == x86::eax ||
391             *this == ppc32::r1   || *this == ppc64::r1 ||
392             *this == aarch64::x0
393             );
394 }
395
396 COMMON_EXPORT bool Dyninst::isSegmentRegister(int regClass)
397 {
398    return 0 != (regClass & x86::SEG);
399 }
400
401 void MachRegister::getROSERegister(int &c, int &n, int &p)
402 {
403    // Rose: class, number, position
404    // Dyninst: category, base id, subrange
405
406    signed int category = (reg & 0x00ff0000);
407    signed int subrange = (reg & 0x0000ff00);
408    signed int baseID =   (reg & 0x000000ff);
409
410    switch (getArchitecture()) {
411       case Arch_x86:
412          switch (category) {
413             case x86::GPR:
414                c = x86_regclass_gpr;
415                switch (baseID) {
416                   case x86::BASEA:
417                      n = x86_gpr_ax;
418                      break;
419                   case x86::BASEC:
420                      n = x86_gpr_cx;
421                      break;
422                   case x86::BASED:
423                      n = x86_gpr_dx;
424                      break;
425                   case x86::BASEB:
426                      n = x86_gpr_bx;
427                      break;
428                   case x86::BASESP:
429                      n = x86_gpr_sp;
430                      break;
431                   case x86::BASEBP:
432                      n = x86_gpr_bp;
433                      break;
434                   case x86::BASESI:
435                      n = x86_gpr_si;
436                      break;
437                   case x86::BASEDI:
438                      n = x86_gpr_di;
439                      break;
440                   default:
441                      n = 0;
442                      break;
443                }
444                break;
445             case x86::SEG:
446                c = x86_regclass_segment;
447                switch (baseID) {
448                   case 0x0:
449                      n = x86_segreg_ds;
450                      break;
451                   case 0x1:
452                      n = x86_segreg_es;
453                      break;
454                   case 0x2:
455                      n = x86_segreg_fs;
456                      break;
457                   case 0x3:
458                      n = x86_segreg_gs;
459                      break;
460                   case 0x4:
461                      n = x86_segreg_cs;
462                      break;
463                   case 0x5:
464                      n = x86_segreg_ss;
465                      break;
466                   default:
467                      n = 0;
468                      break;
469                }
470                break;
471             case x86::FLAG:
472                c = x86_regclass_flags;
473                switch(baseID) {
474                  case x86::CF:
475                          n = x86_flag_cf;
476                          break;
477                  case x86::PF:
478                          n = x86_flag_pf;
479                          break;
480                  case x86::AF:
481                          n = x86_flag_af;
482                          break;
483                  case x86::ZF:
484                          n = x86_flag_zf;
485                          break;
486                  case x86::SF:
487                          n = x86_flag_sf;
488                          break;
489                  case x86::TF:
490                          n = x86_flag_tf;
491                          break;
492                  case x86::IF:
493                          n = x86_flag_if;
494                          break;
495                  case x86::DF:
496                          n = x86_flag_df;
497                          break;
498                  case x86::OF:
499                          n = x86_flag_of;
500                          break;
501                  default:
502                          assert(0);
503                          break;
504                  }
505          break;
506          case x86::MISC:
507                c = x86_regclass_unknown;
508                break;
509          case x86::XMM:
510             c = x86_regclass_xmm;
511             n = baseID;
512             break;
513          case x86::MMX:
514             c = x86_regclass_mm;
515             n = baseID;
516             break;
517          case x86::CTL:
518             c = x86_regclass_cr;
519             n = baseID;
520             break;
521          case x86::DBG:
522             c = x86_regclass_dr;
523             n = baseID;
524             break;
525          case x86::TST:
526             c = x86_regclass_unknown;
527             break;
528          case 0:
529            switch (baseID) {
530               case 0x10:
531                  c = x86_regclass_ip;
532                  n = 0;
533                  break;
534               default:
535                  c = x86_regclass_unknown;
536                  break;
537            }
538          break;
539          }
540       break;
541     case Arch_x86_64: 
542          switch (category) {
543             case x86_64::GPR:
544                c = x86_regclass_gpr;
545                switch (baseID) {
546                   case x86_64::BASEA:
547                      n = x86_gpr_ax;
548                      break;
549                   case x86_64::BASEC:
550                      n = x86_gpr_cx;
551                      break;
552                   case x86_64::BASED:
553                      n = x86_gpr_dx;
554                      break;
555                   case x86_64::BASEB:
556                      n = x86_gpr_bx;
557                      break;
558                   case x86_64::BASESP:
559                      n = x86_gpr_sp;
560                      break;
561                   case x86_64::BASEBP:
562                      n = x86_gpr_bp;
563                      break;
564                   case x86_64::BASESI:
565                      n = x86_gpr_si;
566                      break;
567                   case x86_64::BASEDI:
568                      n = x86_gpr_di;
569                      break;
570                   case x86_64::BASE8:
571                      n = x86_gpr_r8;
572                      break;
573                   case x86_64::BASE9:
574                      n = x86_gpr_r9;
575                      break;
576                   case x86_64::BASE10:
577                      n = x86_gpr_r10;
578                      break;
579                   case x86_64::BASE11:
580                      n = x86_gpr_r11;
581                      break;
582                   case x86_64::BASE12:
583                      n = x86_gpr_r12;
584                      break;
585                   case x86_64::BASE13:
586                      n = x86_gpr_r13;
587                      break;
588                   case x86_64::BASE14:
589                      n = x86_gpr_r14;
590                      break;
591                   case x86_64::BASE15:
592                      n = x86_gpr_r15;
593                      break;
594                   default:
595                      n = 0;
596                      break;
597                }
598                break;
599             case x86_64::SEG:
600                c = x86_regclass_segment;
601                switch (baseID) {
602                   case 0x0:
603                      n = x86_segreg_ds;
604                      break;
605                   case 0x1:
606                      n = x86_segreg_es;
607                      break;
608                   case 0x2:
609                      n = x86_segreg_fs;
610                      break;
611                   case 0x3:
612                      n = x86_segreg_gs;
613                      break;
614                   case 0x4:
615                      n = x86_segreg_cs;
616                      break;
617                   case 0x5:
618                      n = x86_segreg_ss;
619                      break;
620                   default:
621                      n = 0;
622                      break;
623                }
624                break;
625             case x86_64::FLAG:
626                c = x86_regclass_flags;
627                switch(baseID) {
628                case x86_64::CF:
629                  n = x86_flag_cf;
630                  break;
631                case x86_64::PF:
632                  n = x86_flag_pf;
633                  break;
634                case x86_64::AF:
635                  n = x86_flag_af;
636                  break;
637                case x86_64::ZF:
638                  n = x86_flag_zf;
639                  break;
640                case x86_64::SF:
641                  n = x86_flag_sf;
642                  break;
643                case x86_64::TF:
644                  n = x86_flag_tf;
645                  break;
646                case x86_64::IF:
647                  n = x86_flag_if;
648                  break;
649                case x86_64::DF:
650                  n = x86_flag_df;
651                  break;
652                case x86_64::OF:
653                  n = x86_flag_of;
654                  break;
655                default:
656                  assert(0);
657                  break;
658                }
659                break;
660             case x86_64::MISC:
661                c = x86_regclass_unknown;
662                break;
663             case x86_64::XMM:
664                c = x86_regclass_xmm;
665                n = baseID;
666                break;
667             case x86_64::MMX:
668                c = x86_regclass_mm;
669                n = baseID;
670                break;
671             case x86_64::CTL:
672                c = x86_regclass_cr;
673                n = baseID;
674                break;
675             case x86_64::DBG:
676                c = x86_regclass_dr;
677                n = baseID;
678                break;
679             case x86_64::TST:
680                c = x86_regclass_unknown;
681                break;
682             case 0:
683                switch (baseID) {
684                   case 0x10:
685                      c = x86_regclass_ip;
686                      n = 0;
687                      break;
688                   default:
689                      c = x86_regclass_unknown;
690                      break;
691                }
692                break;
693          }
694          break;
695        case Arch_ppc32:
696        case Arch_ppc64: // 64-bit not supported in ROSE
697        {
698          baseID = reg & 0x0000FFFF;
699            n = baseID;
700            switch(category)
701            {
702                case ppc32::GPR:
703                    c = powerpc_regclass_gpr;
704                    break;
705                case ppc32::FPR:
706                case ppc32::FSR:
707                    c = powerpc_regclass_fpr;
708                    break;
709                case ppc32::SPR:
710                {
711                    if(baseID < 613) {
712                        c = powerpc_regclass_spr;
713                    } else if(baseID < 621 ) {
714                        c = powerpc_regclass_sr; 
715                    } else {
716                        c = powerpc_regclass_cr;
717                        n = baseID - 621;
718                        if(n > 7) {
719                          n = 0;
720                          p = powerpc_condreggranularity_whole;
721                        } else {
722                          p = powerpc_condreggranularity_field;
723                        }
724
725                    }
726                }
727                break;
728                default:
729                    assert(!"unknown register type!");
730                    break;
731            }
732            return;
733        }
734        break;
735       case Arch_aarch64:
736       {
737         assert(0);
738         return;
739       }
740       default:
741          c = x86_regclass_unknown;
742          n = 0;
743          break;
744    }
745
746    switch (getArchitecture()) {
747       case Arch_x86:
748          switch (subrange) {
749             case x86::OCT:
750             case x86::FPDBL:
751                p = x86_regpos_qword;
752                break;
753             case x86::H_REG:
754                p = x86_regpos_high_byte;
755                break;
756             case x86::L_REG:
757                p = x86_regpos_low_byte;
758                break;
759             case x86::W_REG:
760                p = x86_regpos_word;
761                break;
762             case x86::FULL:
763             case x86_64::D_REG:
764                p = x86_regpos_dword;
765                break;
766             case x86::BIT:
767                p = x86_regpos_all;
768                break;
769          }
770          break;
771
772       case Arch_x86_64:
773          switch (subrange) {
774             case x86::FULL:
775             case x86::OCT:
776             case x86::FPDBL:
777                p = x86_regpos_qword;
778                break;
779             case x86::H_REG:
780                p = x86_regpos_high_byte;
781                break;
782             case x86::L_REG:
783                p = x86_regpos_low_byte;
784                break;
785             case x86::W_REG:
786                p = x86_regpos_word;
787                break;
788             case x86_64::D_REG:
789                p = x86_regpos_dword;
790                break;
791                  case x86::BIT:
792                  p = x86_regpos_all;
793                  break;
794          }
795       break;
796       case Arch_aarch64:
797       {
798           assert(0);
799         }
800       default:
801         p = x86_regpos_unknown;
802    }
803 }
804
805 MachRegister MachRegister::DwarfEncToReg(int encoding, Dyninst::Architecture arch)
806 {
807    switch (arch)
808    {
809       case Arch_x86:
810          switch (encoding) {
811             case 0: return Dyninst::x86::eax;
812             case 1: return Dyninst::x86::ecx;
813             case 2: return Dyninst::x86::edx;
814             case 3: return Dyninst::x86::ebx;
815             case 4: return Dyninst::x86::esp;
816             case 5: return Dyninst::x86::ebp;
817             case 6: return Dyninst::x86::esi;
818             case 7: return Dyninst::x86::edi;
819             case 8: return Dyninst::x86::eip;
820             case 9: return Dyninst::x86::flags;
821             case 10: return Dyninst::InvalidReg;
822             case 11: return Dyninst::x86::st0;
823             case 12: return Dyninst::x86::st1;
824             case 13: return Dyninst::x86::st2;
825             case 14: return Dyninst::x86::st3;
826             case 15: return Dyninst::x86::st4;
827             case 16: return Dyninst::x86::st5;
828             case 17: return Dyninst::x86::st6;
829             case 18: return Dyninst::x86::st7;
830             case 19: return Dyninst::InvalidReg;
831             case 20: return Dyninst::InvalidReg;
832             case 21: return Dyninst::x86::xmm0;
833             case 22: return Dyninst::x86::xmm1;
834             case 23: return Dyninst::x86::xmm2;
835             case 24: return Dyninst::x86::xmm3;
836             case 25: return Dyninst::x86::xmm4;
837             case 26: return Dyninst::x86::xmm5;
838             case 27: return Dyninst::x86::xmm6;
839             case 28: return Dyninst::x86::xmm7;
840             case 29: return Dyninst::x86::mm0;
841             case 30: return Dyninst::x86::mm1;
842             case 31: return Dyninst::x86::mm2;
843             case 32: return Dyninst::x86::mm3;
844             case 33: return Dyninst::x86::mm4;
845             case 34: return Dyninst::x86::mm5;
846             case 35: return Dyninst::x86::mm6;
847             case 36: return Dyninst::x86::mm7;
848             case 37: return Dyninst::InvalidReg; //fcw
849             case 38: return Dyninst::InvalidReg; //fsw
850             case 39: return Dyninst::InvalidReg; //mxcsr
851             case 40: return Dyninst::x86::es;
852             case 41: return Dyninst::x86::cs;
853             case 42: return Dyninst::x86::ss;
854             case 43: return Dyninst::x86::ds;
855             case 44: return Dyninst::x86::fs;
856             case 45: return Dyninst::x86::gs;
857             case 46: return Dyninst::InvalidReg;
858             case 47: return Dyninst::InvalidReg;
859             case 48: return Dyninst::InvalidReg; //tr
860             case 49: return Dyninst::InvalidReg; //ldtr
861             default: return Dyninst::InvalidReg;
862          }
863          break;
864       case Arch_x86_64:
865          switch (encoding) {
866             case 0: return Dyninst::x86_64::rax;
867             case 1: return Dyninst::x86_64::rdx;
868             case 2: return Dyninst::x86_64::rcx;
869             case 3: return Dyninst::x86_64::rbx;
870             case 4: return Dyninst::x86_64::rsi;
871             case 5: return Dyninst::x86_64::rdi;
872             case 6: return Dyninst::x86_64::rbp;
873             case 7: return Dyninst::x86_64::rsp;
874             case 8: return Dyninst::x86_64::r8;
875             case 9: return Dyninst::x86_64::r9;
876             case 10: return Dyninst::x86_64::r10;
877             case 11: return Dyninst::x86_64::r11;
878             case 12: return Dyninst::x86_64::r12;
879             case 13: return Dyninst::x86_64::r13;
880             case 14: return Dyninst::x86_64::r14;
881             case 15: return Dyninst::x86_64::r15;
882             case 16: return Dyninst::x86_64::rip;
883             case 17: return Dyninst::x86_64::xmm0;
884             case 18: return Dyninst::x86_64::xmm1;
885             case 19: return Dyninst::x86_64::xmm2;
886             case 20: return Dyninst::x86_64::xmm3;
887             case 21: return Dyninst::x86_64::xmm4;
888             case 22: return Dyninst::x86_64::xmm5;
889             case 23: return Dyninst::x86_64::xmm6;
890             case 24: return Dyninst::x86_64::xmm7;
891             case 25: return Dyninst::x86_64::xmm8;
892             case 26: return Dyninst::x86_64::xmm9;
893             case 27: return Dyninst::x86_64::xmm10;
894             case 28: return Dyninst::x86_64::xmm11;
895             case 29: return Dyninst::x86_64::xmm12;
896             case 30: return Dyninst::x86_64::xmm13;
897             case 31: return Dyninst::x86_64::xmm14;
898             case 32: return Dyninst::x86_64::xmm15;
899             case 33: return Dyninst::x86_64::st0;
900             case 34: return Dyninst::x86_64::st1;
901             case 35: return Dyninst::x86_64::st2;
902             case 36: return Dyninst::x86_64::st3;
903             case 37: return Dyninst::x86_64::st4;
904             case 38: return Dyninst::x86_64::st5;
905             case 39: return Dyninst::x86_64::st6;
906             case 40: return Dyninst::x86_64::st7;
907             case 41: return Dyninst::x86_64::mm0;
908             case 42: return Dyninst::x86_64::mm1;
909             case 43: return Dyninst::x86_64::mm2;
910             case 44: return Dyninst::x86_64::mm3;
911             case 45: return Dyninst::x86_64::mm4;
912             case 46: return Dyninst::x86_64::mm5;
913             case 47: return Dyninst::x86_64::mm6;
914             case 48: return Dyninst::x86_64::mm7;
915             case 49: return Dyninst::x86_64::flags;
916             case 50: return Dyninst::x86_64::es;
917             case 51: return Dyninst::x86_64::cs;
918             case 52: return Dyninst::x86_64::ss;
919             case 53: return Dyninst::x86_64::ds;
920             case 54: return Dyninst::x86_64::fs;
921             case 55: return Dyninst::x86_64::gs;
922             case 56: return Dyninst::InvalidReg;
923             case 57: return Dyninst::InvalidReg;
924             case 58: return Dyninst::x86_64::fsbase;
925             case 59: return Dyninst::x86_64::gsbase;
926             case 60: return Dyninst::InvalidReg;
927             case 61: return Dyninst::InvalidReg;
928             case 62: return Dyninst::InvalidReg; //tr
929             case 63: return Dyninst::InvalidReg; //ldtr
930             case 64: return Dyninst::InvalidReg; //mxcsr
931             case 65: return Dyninst::InvalidReg; //fcw
932             case 66: return Dyninst::InvalidReg; //fsw
933          }
934          break;
935       case Arch_ppc32:
936          switch (encoding) {
937             case 0: return Dyninst::ppc32::r0;
938             case 1: return Dyninst::ppc32::r1;
939             case 2: return Dyninst::ppc32::r2;
940             case 3: return Dyninst::ppc32::r3;
941             case 4: return Dyninst::ppc32::r4;
942             case 5: return Dyninst::ppc32::r5;
943             case 6: return Dyninst::ppc32::r6;
944             case 7: return Dyninst::ppc32::r7;
945             case 8: return Dyninst::ppc32::r8;
946             case 9: return Dyninst::ppc32::r9;
947             case 10: return Dyninst::ppc32::r10;
948             case 11: return Dyninst::ppc32::r11;
949             case 12: return Dyninst::ppc32::r12;
950             case 13: return Dyninst::ppc32::r13;
951             case 14: return Dyninst::ppc32::r14;
952             case 15: return Dyninst::ppc32::r15;
953             case 16: return Dyninst::ppc32::r16;
954             case 17: return Dyninst::ppc32::r17;
955             case 18: return Dyninst::ppc32::r18;
956             case 19: return Dyninst::ppc32::r19;
957             case 20: return Dyninst::ppc32::r20;
958             case 21: return Dyninst::ppc32::r21;
959             case 22: return Dyninst::ppc32::r22;
960             case 23: return Dyninst::ppc32::r23;
961             case 24: return Dyninst::ppc32::r24;
962             case 25: return Dyninst::ppc32::r25;
963             case 26: return Dyninst::ppc32::r26;
964             case 27: return Dyninst::ppc32::r27;
965             case 28: return Dyninst::ppc32::r28;
966             case 29: return Dyninst::ppc32::r29;
967             case 30: return Dyninst::ppc32::r30;
968             case 31: return Dyninst::ppc32::r31;
969             case 32: return Dyninst::ppc32::fpr0;
970             case 33: return Dyninst::ppc32::fpr1;
971             case 34: return Dyninst::ppc32::fpr2;
972             case 35: return Dyninst::ppc32::fpr3;
973             case 36: return Dyninst::ppc32::fpr4;
974             case 37: return Dyninst::ppc32::fpr5;
975             case 38: return Dyninst::ppc32::fpr6;
976             case 39: return Dyninst::ppc32::fpr7;
977             case 40: return Dyninst::ppc32::fpr8;
978             case 41: return Dyninst::ppc32::fpr9;
979             case 42: return Dyninst::ppc32::fpr10;
980             case 43: return Dyninst::ppc32::fpr11;
981             case 44: return Dyninst::ppc32::fpr12;
982             case 45: return Dyninst::ppc32::fpr13;
983             case 46: return Dyninst::ppc32::fpr14;
984             case 47: return Dyninst::ppc32::fpr15;
985             case 48: return Dyninst::ppc32::fpr16;
986             case 49: return Dyninst::ppc32::fpr17;
987             case 50: return Dyninst::ppc32::fpr18;
988             case 51: return Dyninst::ppc32::fpr19;
989             case 52: return Dyninst::ppc32::fpr20;
990             case 53: return Dyninst::ppc32::fpr21;
991             case 54: return Dyninst::ppc32::fpr22;
992             case 55: return Dyninst::ppc32::fpr23;
993             case 56: return Dyninst::ppc32::fpr24;
994             case 57: return Dyninst::ppc32::fpr25;
995             case 58: return Dyninst::ppc32::fpr26;
996             case 59: return Dyninst::ppc32::fpr27;
997             case 60: return Dyninst::ppc32::fpr28;
998             case 61: return Dyninst::ppc32::fpr29;
999             case 62: return Dyninst::ppc32::fpr30;
1000             case 63: return Dyninst::ppc32::fpr31;
1001             case 64: return Dyninst::ppc32::cr;
1002             case 65: return Dyninst::InvalidReg; //FPSCR
1003          }
1004          //Seperate switch statements to give compilers an easier time of
1005          // optimizing
1006          switch (encoding) {
1007             case 100: return Dyninst::ppc32::mq;
1008             case 101: return Dyninst::ppc32::xer;
1009             case 102: return Dyninst::InvalidReg;
1010             case 103: return Dyninst::InvalidReg;
1011             case 104: return Dyninst::InvalidReg; //RTCU
1012             case 105: return Dyninst::InvalidReg; //RTCL
1013             case 106: return Dyninst::InvalidReg;
1014             case 107: return Dyninst::InvalidReg;
1015             case 108: return Dyninst::ppc32::lr;
1016             case 109: return Dyninst::ppc32::ctr;
1017             default: return Dyninst::InvalidReg;
1018          }
1019          break;
1020       case Arch_ppc64:
1021          switch (encoding) {
1022             case 0: return Dyninst::ppc64::r0;
1023             case 1: return Dyninst::ppc64::r1;
1024             case 2: return Dyninst::ppc64::r2;
1025             case 3: return Dyninst::ppc64::r3;
1026             case 4: return Dyninst::ppc64::r4;
1027             case 5: return Dyninst::ppc64::r5;
1028             case 6: return Dyninst::ppc64::r6;
1029             case 7: return Dyninst::ppc64::r7;
1030             case 8: return Dyninst::ppc64::r8;
1031             case 9: return Dyninst::ppc64::r9;
1032             case 10: return Dyninst::ppc64::r10;
1033             case 11: return Dyninst::ppc64::r11;
1034             case 12: return Dyninst::ppc64::r12;
1035             case 13: return Dyninst::ppc64::r13;
1036             case 14: return Dyninst::ppc64::r14;
1037             case 15: return Dyninst::ppc64::r15;
1038             case 16: return Dyninst::ppc64::r16;
1039             case 17: return Dyninst::ppc64::r17;
1040             case 18: return Dyninst::ppc64::r18;
1041             case 19: return Dyninst::ppc64::r19;
1042             case 20: return Dyninst::ppc64::r20;
1043             case 21: return Dyninst::ppc64::r21;
1044             case 22: return Dyninst::ppc64::r22;
1045             case 23: return Dyninst::ppc64::r23;
1046             case 24: return Dyninst::ppc64::r24;
1047             case 25: return Dyninst::ppc64::r25;
1048             case 26: return Dyninst::ppc64::r26;
1049             case 27: return Dyninst::ppc64::r27;
1050             case 28: return Dyninst::ppc64::r28;
1051             case 29: return Dyninst::ppc64::r29;
1052             case 30: return Dyninst::ppc64::r30;
1053             case 31: return Dyninst::ppc64::r31;
1054             case 32: return Dyninst::ppc64::fpr0;
1055             case 33: return Dyninst::ppc64::fpr1;
1056             case 34: return Dyninst::ppc64::fpr2;
1057             case 35: return Dyninst::ppc64::fpr3;
1058             case 36: return Dyninst::ppc64::fpr4;
1059             case 37: return Dyninst::ppc64::fpr5;
1060             case 38: return Dyninst::ppc64::fpr6;
1061             case 39: return Dyninst::ppc64::fpr7;
1062             case 40: return Dyninst::ppc64::fpr8;
1063             case 41: return Dyninst::ppc64::fpr9;
1064             case 42: return Dyninst::ppc64::fpr10;
1065             case 43: return Dyninst::ppc64::fpr11;
1066             case 44: return Dyninst::ppc64::fpr12;
1067             case 45: return Dyninst::ppc64::fpr13;
1068             case 46: return Dyninst::ppc64::fpr14;
1069             case 47: return Dyninst::ppc64::fpr15;
1070             case 48: return Dyninst::ppc64::fpr16;
1071             case 49: return Dyninst::ppc64::fpr17;
1072             case 50: return Dyninst::ppc64::fpr18;
1073             case 51: return Dyninst::ppc64::fpr19;
1074             case 52: return Dyninst::ppc64::fpr20;
1075             case 53: return Dyninst::ppc64::fpr21;
1076             case 54: return Dyninst::ppc64::fpr22;
1077             case 55: return Dyninst::ppc64::fpr23;
1078             case 56: return Dyninst::ppc64::fpr24;
1079             case 57: return Dyninst::ppc64::fpr25;
1080             case 58: return Dyninst::ppc64::fpr26;
1081             case 59: return Dyninst::ppc64::fpr27;
1082             case 60: return Dyninst::ppc64::fpr28;
1083             case 61: return Dyninst::ppc64::fpr29;
1084             case 62: return Dyninst::ppc64::fpr30;
1085             case 63: return Dyninst::ppc64::fpr31;
1086             case 64: return Dyninst::ppc64::cr;
1087             case 65: return Dyninst::InvalidReg; //FPSCR
1088          }
1089          //Seperate switch statements to give compilers an easier time of
1090          // optimizing
1091          switch (encoding) {
1092             case 100: return Dyninst::ppc64::mq;
1093             case 101: return Dyninst::ppc64::xer;
1094             case 102: return Dyninst::InvalidReg;
1095             case 103: return Dyninst::InvalidReg;
1096             case 104: return Dyninst::InvalidReg; //RTCU
1097             case 105: return Dyninst::InvalidReg; //RTCL
1098             case 106: return Dyninst::InvalidReg;
1099             case 107: return Dyninst::InvalidReg;
1100             case 108: return Dyninst::ppc64::lr;
1101             case 109: return Dyninst::ppc64::ctr;
1102             default: return Dyninst::InvalidReg;
1103          }
1104          break;
1105       case Arch_aarch64:
1106          assert(0); //not verified
1107          switch(encoding){
1108             case 0:  return Dyninst::aarch64::x0;
1109             case 1:  return Dyninst::aarch64::x1;
1110             case 2:  return Dyninst::aarch64::x2;
1111             case 3:  return Dyninst::aarch64::x3;
1112             case 4:  return Dyninst::aarch64::x4;
1113             case 5:  return Dyninst::aarch64::x5;
1114             case 6:  return Dyninst::aarch64::x6;
1115             case 7:  return Dyninst::aarch64::x7;
1116             case 8:  return Dyninst::aarch64::x8;
1117             case 9:  return Dyninst::aarch64::x9;
1118             case 10: return Dyninst::aarch64::x10;
1119             case 11: return Dyninst::aarch64::x11;
1120             case 12: return Dyninst::aarch64::x12;
1121             case 13: return Dyninst::aarch64::x13;
1122             case 14: return Dyninst::aarch64::x14;
1123             case 15: return Dyninst::aarch64::x15;
1124             case 16: return Dyninst::aarch64::x16;
1125             case 17: return Dyninst::aarch64::x17;
1126             case 18: return Dyninst::aarch64::x18;
1127             case 19: return Dyninst::aarch64::x19;
1128             case 20: return Dyninst::aarch64::x20;
1129             case 21: return Dyninst::aarch64::x21;
1130             case 22: return Dyninst::aarch64::x22;
1131             case 23: return Dyninst::aarch64::x23;
1132             case 24: return Dyninst::aarch64::x24;
1133             case 25: return Dyninst::aarch64::x25;
1134             case 26: return Dyninst::aarch64::x26;
1135             case 27: return Dyninst::aarch64::x27;
1136             case 28: return Dyninst::aarch64::x28;
1137             case 29: return Dyninst::aarch64::x29;
1138             case 30: return Dyninst::aarch64::x30;
1139             case 32: return Dyninst::aarch64::q0;
1140             case 33: return Dyninst::aarch64::q1;
1141             case 34: return Dyninst::aarch64::q2;
1142             case 35: return Dyninst::aarch64::q3;
1143             case 36: return Dyninst::aarch64::q4;
1144             case 37: return Dyninst::aarch64::q5;
1145             case 38: return Dyninst::aarch64::q6;
1146             case 39: return Dyninst::aarch64::q7;
1147             case 40: return Dyninst::aarch64::q8;
1148             case 41: return Dyninst::aarch64::q9;
1149             case 42: return Dyninst::aarch64::q10;
1150             case 43: return Dyninst::aarch64::q11;
1151             case 44: return Dyninst::aarch64::q12;
1152             case 45: return Dyninst::aarch64::q13;
1153             case 46: return Dyninst::aarch64::q14;
1154             case 47: return Dyninst::aarch64::q15;
1155             case 48: return Dyninst::aarch64::q16;
1156             case 49: return Dyninst::aarch64::q17;
1157             case 50: return Dyninst::aarch64::q18;
1158             case 51: return Dyninst::aarch64::q19;
1159             case 52: return Dyninst::aarch64::q20;
1160             case 53: return Dyninst::aarch64::q21;
1161             case 54: return Dyninst::aarch64::q22;
1162             case 55: return Dyninst::aarch64::q23;
1163             case 56: return Dyninst::aarch64::q24;
1164             case 57: return Dyninst::aarch64::q25;
1165             case 58: return Dyninst::aarch64::q26;
1166             case 59: return Dyninst::aarch64::q27;
1167             case 60: return Dyninst::aarch64::q28;
1168             case 61: return Dyninst::aarch64::q29;
1169             case 62: return Dyninst::aarch64::q30;
1170             case 63: return Dyninst::aarch64::q31;
1171             default: return Dyninst::InvalidReg;
1172             break;
1173          }
1174       case Arch_none:
1175          return Dyninst::InvalidReg;
1176          break;
1177       default:
1178          assert(0);
1179          return InvalidReg;
1180    }
1181    //Invalid Architecture passed
1182    return Dyninst::InvalidReg;
1183
1184 }
1185
1186 int MachRegister::getDwarfEnc() const
1187 {
1188    switch (getArchitecture())
1189    {
1190       case Arch_x86:
1191          switch (val()) {
1192             case Dyninst::x86::ieax: return 0;
1193             case Dyninst::x86::iecx: return 1;
1194             case Dyninst::x86::iedx: return 2;
1195             case Dyninst::x86::iebx: return 3;
1196             case Dyninst::x86::iesp: return 4;
1197             case Dyninst::x86::iebp: return 5;
1198             case Dyninst::x86::iesi: return 6;
1199             case Dyninst::x86::iedi: return 7;
1200             case Dyninst::x86::ieip: return 8;
1201             case Dyninst::x86::iflags: return 9;
1202             case Dyninst::x86::ixmm0: return 21;
1203             case Dyninst::x86::ixmm1: return 22;
1204             case Dyninst::x86::ixmm2: return 23;
1205             case Dyninst::x86::ixmm3: return 24;
1206             case Dyninst::x86::ixmm4: return 25;
1207             case Dyninst::x86::ixmm5: return 26;
1208             case Dyninst::x86::ixmm6: return 27;
1209             case Dyninst::x86::ixmm7: return 28;
1210             case Dyninst::x86::imm0: return 29;
1211             case Dyninst::x86::imm1: return 30;
1212             case Dyninst::x86::imm2: return 31;
1213             case Dyninst::x86::imm3: return 32;
1214             case Dyninst::x86::imm4: return 33;
1215             case Dyninst::x86::imm5: return 34;
1216             case Dyninst::x86::imm6: return 35;
1217             case Dyninst::x86::imm7: return 36;
1218             case Dyninst::x86::ies: return 40;
1219             case Dyninst::x86::ics: return 41;
1220             case Dyninst::x86::iss: return 42;
1221             case Dyninst::x86::ids: return 43;
1222             case Dyninst::x86::ifs: return 44;
1223             case Dyninst::x86::igs: return 45;
1224             default: return -1;
1225          }
1226          break;
1227       case Arch_x86_64:
1228          switch (val()) {
1229             case Dyninst::x86_64::irax: return 0;
1230             case Dyninst::x86_64::irdx: return 1;
1231             case Dyninst::x86_64::ircx: return 2;
1232             case Dyninst::x86_64::irbx: return 3;
1233             case Dyninst::x86_64::irsi: return 4;
1234             case Dyninst::x86_64::irdi: return 5;
1235             case Dyninst::x86_64::irbp: return 6;
1236             case Dyninst::x86_64::irsp: return 7;
1237             case Dyninst::x86_64::ir8: return 8;
1238             case Dyninst::x86_64::ir9: return 9;
1239             case Dyninst::x86_64::ir10: return 10;
1240             case Dyninst::x86_64::ir11: return 11;
1241             case Dyninst::x86_64::ir12: return 12;
1242             case Dyninst::x86_64::ir13: return 13;
1243             case Dyninst::x86_64::ir14: return 14;
1244             case Dyninst::x86_64::ir15: return 15;
1245             case Dyninst::x86_64::irip: return 16;
1246             case Dyninst::x86_64::ixmm0: return 17;
1247             case Dyninst::x86_64::ixmm1: return 18;
1248             case Dyninst::x86_64::ixmm2: return 19;
1249             case Dyninst::x86_64::ixmm3: return 20;
1250             case Dyninst::x86_64::ixmm4: return 21;
1251             case Dyninst::x86_64::ixmm5: return 22;
1252             case Dyninst::x86_64::ixmm6: return 23;
1253             case Dyninst::x86_64::ixmm7: return 24;
1254             case Dyninst::x86_64::ixmm8: return 25;
1255             case Dyninst::x86_64::ixmm9: return 26;
1256             case Dyninst::x86_64::ixmm10: return 27;
1257             case Dyninst::x86_64::ixmm11: return 28;
1258             case Dyninst::x86_64::ixmm12: return 29;
1259             case Dyninst::x86_64::ixmm13: return 30;
1260             case Dyninst::x86_64::ixmm14: return 31;
1261             case Dyninst::x86_64::ixmm15: return 32;
1262             case Dyninst::x86_64::imm0: return 41;
1263             case Dyninst::x86_64::imm1: return 42;
1264             case Dyninst::x86_64::imm2: return 43;
1265             case Dyninst::x86_64::imm3: return 44;
1266             case Dyninst::x86_64::imm4: return 45;
1267             case Dyninst::x86_64::imm5: return 46;
1268             case Dyninst::x86_64::imm6: return 47;
1269             case Dyninst::x86_64::imm7: return 48;
1270             case Dyninst::x86_64::iflags: return 49;
1271             case Dyninst::x86_64::ies: return 50;
1272             case Dyninst::x86_64::ics: return 51;
1273             case Dyninst::x86_64::iss: return 52;
1274             case Dyninst::x86_64::ids: return 53;
1275             case Dyninst::x86_64::ifs: return 54;
1276             case Dyninst::x86_64::igs: return 55;
1277             case Dyninst::x86_64::ifsbase: return 58;
1278             case Dyninst::x86_64::igsbase: return 59;
1279             default: return -1;
1280          }
1281          break;
1282       case Arch_ppc32:
1283          switch (val()) {
1284             case Dyninst::ppc32::ir0: return 0;
1285             case Dyninst::ppc32::ir1: return 1;
1286             case Dyninst::ppc32::ir2: return 2;
1287             case Dyninst::ppc32::ir3: return 3;
1288             case Dyninst::ppc32::ir4: return 4;
1289             case Dyninst::ppc32::ir5: return 5;
1290             case Dyninst::ppc32::ir6: return 6;
1291             case Dyninst::ppc32::ir7: return 7;
1292             case Dyninst::ppc32::ir8: return 8;
1293             case Dyninst::ppc32::ir9: return 9;
1294             case Dyninst::ppc32::ir10: return 10;
1295             case Dyninst::ppc32::ir11: return 11;
1296             case Dyninst::ppc32::ir12: return 12;
1297             case Dyninst::ppc32::ir13: return 13;
1298             case Dyninst::ppc32::ir14: return 14;
1299             case Dyninst::ppc32::ir15: return 15;
1300             case Dyninst::ppc32::ir16: return 16;
1301             case Dyninst::ppc32::ir17: return 17;
1302             case Dyninst::ppc32::ir18: return 18;
1303             case Dyninst::ppc32::ir19: return 19;
1304             case Dyninst::ppc32::ir20: return 20;
1305             case Dyninst::ppc32::ir21: return 21;
1306             case Dyninst::ppc32::ir22: return 22;
1307             case Dyninst::ppc32::ir23: return 23;
1308             case Dyninst::ppc32::ir24: return 24;
1309             case Dyninst::ppc32::ir25: return 25;
1310             case Dyninst::ppc32::ir26: return 26;
1311             case Dyninst::ppc32::ir27: return 27;
1312             case Dyninst::ppc32::ir28: return 28;
1313             case Dyninst::ppc32::ir29: return 29;
1314             case Dyninst::ppc32::ir30: return 30;
1315             case Dyninst::ppc32::ir31: return 31;
1316             case Dyninst::ppc32::ifpr0: return 32;
1317             case Dyninst::ppc32::ifpr1: return 33;
1318             case Dyninst::ppc32::ifpr2: return 34;
1319             case Dyninst::ppc32::ifpr3: return 35;
1320             case Dyninst::ppc32::ifpr4: return 36;
1321             case Dyninst::ppc32::ifpr5: return 37;
1322             case Dyninst::ppc32::ifpr6: return 38;
1323             case Dyninst::ppc32::ifpr7: return 39;
1324             case Dyninst::ppc32::ifpr8: return 40;
1325             case Dyninst::ppc32::ifpr9: return 41;
1326             case Dyninst::ppc32::ifpr10: return 42;
1327             case Dyninst::ppc32::ifpr11: return 43;
1328             case Dyninst::ppc32::ifpr12: return 44;
1329             case Dyninst::ppc32::ifpr13: return 45;
1330             case Dyninst::ppc32::ifpr14: return 46;
1331             case Dyninst::ppc32::ifpr15: return 47;
1332             case Dyninst::ppc32::ifpr16: return 48;
1333             case Dyninst::ppc32::ifpr17: return 49;
1334             case Dyninst::ppc32::ifpr18: return 50;
1335             case Dyninst::ppc32::ifpr19: return 51;
1336             case Dyninst::ppc32::ifpr20: return 52;
1337             case Dyninst::ppc32::ifpr21: return 53;
1338             case Dyninst::ppc32::ifpr22: return 54;
1339             case Dyninst::ppc32::ifpr23: return 55;
1340             case Dyninst::ppc32::ifpr24: return 56;
1341             case Dyninst::ppc32::ifpr25: return 57;
1342             case Dyninst::ppc32::ifpr26: return 58;
1343             case Dyninst::ppc32::ifpr27: return 59;
1344             case Dyninst::ppc32::ifpr28: return 60;
1345             case Dyninst::ppc32::ifpr29: return 61;
1346             case Dyninst::ppc32::ifpr30: return 62;
1347             case Dyninst::ppc32::ifpr31: return 63;
1348             case Dyninst::ppc32::icr: return 64;
1349             case Dyninst::ppc32::imq: return 100;
1350             case Dyninst::ppc32::ixer: return 101;
1351             case Dyninst::ppc32::ilr: return 108;
1352             case Dyninst::ppc32::ictr: return 109;
1353             default: return -1;
1354          }
1355       case Arch_ppc64:
1356          switch (val()) {
1357             case Dyninst::ppc64::ir0: return 0;
1358             case Dyninst::ppc64::ir1: return 1;
1359             case Dyninst::ppc64::ir2: return 2;
1360             case Dyninst::ppc64::ir3: return 3;
1361             case Dyninst::ppc64::ir4: return 4;
1362             case Dyninst::ppc64::ir5: return 5;
1363             case Dyninst::ppc64::ir6: return 6;
1364             case Dyninst::ppc64::ir7: return 7;
1365             case Dyninst::ppc64::ir8: return 8;
1366             case Dyninst::ppc64::ir9: return 9;
1367             case Dyninst::ppc64::ir10: return 10;
1368             case Dyninst::ppc64::ir11: return 11;
1369             case Dyninst::ppc64::ir12: return 12;
1370             case Dyninst::ppc64::ir13: return 13;
1371             case Dyninst::ppc64::ir14: return 14;
1372             case Dyninst::ppc64::ir15: return 15;
1373             case Dyninst::ppc64::ir16: return 16;
1374             case Dyninst::ppc64::ir17: return 17;
1375             case Dyninst::ppc64::ir18: return 18;
1376             case Dyninst::ppc64::ir19: return 19;
1377             case Dyninst::ppc64::ir20: return 20;
1378             case Dyninst::ppc64::ir21: return 21;
1379             case Dyninst::ppc64::ir22: return 22;
1380             case Dyninst::ppc64::ir23: return 23;
1381             case Dyninst::ppc64::ir24: return 24;
1382             case Dyninst::ppc64::ir25: return 25;
1383             case Dyninst::ppc64::ir26: return 26;
1384             case Dyninst::ppc64::ir27: return 27;
1385             case Dyninst::ppc64::ir28: return 28;
1386             case Dyninst::ppc64::ir29: return 29;
1387             case Dyninst::ppc64::ir30: return 30;
1388             case Dyninst::ppc64::ir31: return 31;
1389             case Dyninst::ppc64::ifpr0: return 32;
1390             case Dyninst::ppc64::ifpr1: return 33;
1391             case Dyninst::ppc64::ifpr2: return 34;
1392             case Dyninst::ppc64::ifpr3: return 35;
1393             case Dyninst::ppc64::ifpr4: return 36;
1394             case Dyninst::ppc64::ifpr5: return 37;
1395             case Dyninst::ppc64::ifpr6: return 38;
1396             case Dyninst::ppc64::ifpr7: return 39;
1397             case Dyninst::ppc64::ifpr8: return 40;
1398             case Dyninst::ppc64::ifpr9: return 41;
1399             case Dyninst::ppc64::ifpr10: return 42;
1400             case Dyninst::ppc64::ifpr11: return 43;
1401             case Dyninst::ppc64::ifpr12: return 44;
1402             case Dyninst::ppc64::ifpr13: return 45;
1403             case Dyninst::ppc64::ifpr14: return 46;
1404             case Dyninst::ppc64::ifpr15: return 47;
1405             case Dyninst::ppc64::ifpr16: return 48;
1406             case Dyninst::ppc64::ifpr17: return 49;
1407             case Dyninst::ppc64::ifpr18: return 50;
1408             case Dyninst::ppc64::ifpr19: return 51;
1409             case Dyninst::ppc64::ifpr20: return 52;
1410             case Dyninst::ppc64::ifpr21: return 53;
1411             case Dyninst::ppc64::ifpr22: return 54;
1412             case Dyninst::ppc64::ifpr23: return 55;
1413             case Dyninst::ppc64::ifpr24: return 56;
1414             case Dyninst::ppc64::ifpr25: return 57;
1415             case Dyninst::ppc64::ifpr26: return 58;
1416             case Dyninst::ppc64::ifpr27: return 59;
1417             case Dyninst::ppc64::ifpr28: return 60;
1418             case Dyninst::ppc64::ifpr29: return 61;
1419             case Dyninst::ppc64::ifpr30: return 62;
1420             case Dyninst::ppc64::ifpr31: return 63;
1421             case Dyninst::ppc64::icr: return 64;
1422             case Dyninst::ppc64::imq: return 100;
1423             case Dyninst::ppc64::ixer: return 101;
1424             case Dyninst::ppc64::ilr: return 108;
1425             case Dyninst::ppc64::ictr: return 109;
1426             default: return -1;
1427          }
1428          break;
1429       case Arch_aarch64:
1430          switch (val()) {
1431              /*
1432             case Dyninst::aarch64::x0:  return 0;
1433             case Dyninst::aarch64::x1:  return 1;
1434             case Dyninst::aarch64::x2:  return 2;
1435             case Dyninst::aarch64::x3:  return 3;
1436             case Dyninst::aarch64::x4:  return 4;
1437             case Dyninst::aarch64::x5:  return 5;
1438             case Dyninst::aarch64::x6:  return 6;
1439             case Dyninst::aarch64::x7:  return 7;
1440             case Dyninst::aarch64::x8:  return 8;
1441             case Dyninst::aarch64::x9:  return 9;
1442             case Dyninst::aarch64::x10:         return 10;
1443             case Dyninst::aarch64::x11:         return 11;
1444             case Dyninst::aarch64::x12:         return 12;
1445             case Dyninst::aarch64::x13:         return 13;
1446             case Dyninst::aarch64::x14:         return 14;
1447             case Dyninst::aarch64::x15:         return 15;
1448             case Dyninst::aarch64::x16:         return 16;
1449             case Dyninst::aarch64::x17:         return 17;
1450             case Dyninst::aarch64::x18:         return 18;
1451             case Dyninst::aarch64::x19:         return 19;
1452             case Dyninst::aarch64::x20:         return 20;
1453             case Dyninst::aarch64::x21:         return 21;
1454             case Dyninst::aarch64::x22:         return 22;
1455             case Dyninst::aarch64::x23:         return 23;
1456             case Dyninst::aarch64::x24:         return 24;
1457             case Dyninst::aarch64::x25:         return 25;
1458             case Dyninst::aarch64::x26:         return 26;
1459             case Dyninst::aarch64::x27:         return 27;
1460             case Dyninst::aarch64::x28:         return 28;
1461             case Dyninst::aarch64::x29:         return 29;
1462             case Dyninst::aarch64::x30:         return 30;
1463
1464             case Dyninst::aarch64::sp       return 100;
1465             case Dyninst::aarch64::pc       return 101;
1466             case Dyninst::aarch64::pstate   return 102;
1467
1468             */
1469             default: return -1;
1470          }
1471          break;
1472       case Arch_none:
1473          assert(0);
1474          return -1;
1475       default:
1476         assert(0);
1477         return -1;
1478    }
1479    //Invalid register passed
1480    return -1;
1481 }
1482
1483 unsigned Dyninst::getArchAddressWidth(Dyninst::Architecture arch)
1484 {
1485    switch (arch) {
1486       case Arch_none:
1487          return 0;
1488       case Arch_x86:
1489       case Arch_ppc32:
1490          return 4;
1491       case Arch_x86_64:
1492       case Arch_ppc64:
1493       case Arch_aarch64:
1494          return 8;
1495       default:
1496          assert(0);
1497          return InvalidReg;
1498    }
1499    return 0;
1500 }
1501
1502 MachRegister MachRegister::getArchReg(unsigned int regNum, Dyninst::Architecture arch){
1503     switch(arch){
1504       case Arch_aarch64:
1505          switch(regNum){
1506             case 0:  return Dyninst::aarch64::x0;
1507             case 1:  return Dyninst::aarch64::x1;
1508             case 2:  return Dyninst::aarch64::x2;
1509             case 3:  return Dyninst::aarch64::x3;
1510             case 4:  return Dyninst::aarch64::x4;
1511             case 5:  return Dyninst::aarch64::x5;
1512             case 6:  return Dyninst::aarch64::x6;
1513             case 7:  return Dyninst::aarch64::x7;
1514             case 8:  return Dyninst::aarch64::x8;
1515             case 9:  return Dyninst::aarch64::x9;
1516             case 10: return Dyninst::aarch64::x10;
1517             case 11: return Dyninst::aarch64::x11;
1518             case 12: return Dyninst::aarch64::x12;
1519             case 13: return Dyninst::aarch64::x13;
1520             case 14: return Dyninst::aarch64::x14;
1521             case 15: return Dyninst::aarch64::x15;
1522             case 16: return Dyninst::aarch64::x16;
1523             case 17: return Dyninst::aarch64::x17;
1524             case 18: return Dyninst::aarch64::x18;
1525             case 19: return Dyninst::aarch64::x19;
1526             case 20: return Dyninst::aarch64::x20;
1527             case 21: return Dyninst::aarch64::x21;
1528             case 22: return Dyninst::aarch64::x22;
1529             case 23: return Dyninst::aarch64::x23;
1530             case 24: return Dyninst::aarch64::x24;
1531             case 25: return Dyninst::aarch64::x25;
1532             case 26: return Dyninst::aarch64::x26;
1533             case 27: return Dyninst::aarch64::x27;
1534             case 28: return Dyninst::aarch64::x28;
1535             case 29: return Dyninst::aarch64::x29;
1536             case 30: return Dyninst::aarch64::x30;
1537
1538             case 100: return Dyninst::aarch64::sp;
1539             case 101: return Dyninst::aarch64::pc;
1540             case 102: return Dyninst::aarch64::pstate;
1541          }
1542       default:
1543          return InvalidReg;
1544     }
1545     return InvalidReg;
1546 }