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