Prevent corruption to rax during stack alignment on x86-64 (#670)
[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 #include "external/rose/armv8InstructionEnum.h"
37
38 #include <iostream>
39
40 using namespace Dyninst;
41
42 boost::shared_ptr<MachRegister::NameMap> MachRegister::names()
43 {
44     static boost::shared_ptr<MachRegister::NameMap> store =
45        boost::shared_ptr<MachRegister::NameMap>(new MachRegister::NameMap);
46     return store;
47 }
48
49 MachRegister::MachRegister() :
50    reg(0)
51 {
52 }
53
54 MachRegister::MachRegister(signed int r) :
55    reg(r)
56 {
57 }
58
59 MachRegister::MachRegister(signed int r, const char *n) :
60    reg(r)
61 {
62         (*names())[r] = std::string(n);
63 }
64
65 MachRegister::MachRegister(signed int r, std::string n) :
66 reg(r)
67 {
68         (*names())[r] = n;
69 }
70
71 unsigned int MachRegister::regClass() const
72 {
73     return reg & 0x00ff0000;
74 }
75
76 MachRegister MachRegister::getBaseRegister() const {
77    signed int category = (reg & 0x00ff0000);
78    switch (getArchitecture()) {
79       case Arch_x86:
80          if (category == x86::GPR) return MachRegister(reg & 0xfffff0ff);
81          else if (category == x86::FLAG) return x86::flags;
82          else return *this;
83       case Arch_x86_64:
84          if (category == x86_64::GPR) return MachRegister(reg & 0xfffff0ff);
85          else if (category == x86_64::FLAG) return x86_64::flags;
86          else return *this;
87       case Arch_ppc32:
88       case Arch_ppc64:
89       case Arch_none:
90          return *this;
91       case Arch_cuda:
92          assert(0);
93                 case Arch_aarch32:
94                 case Arch_aarch64:
95                                   //not verified
96                    return *this;
97    }
98    return InvalidReg;
99 }
100
101 Architecture MachRegister::getArchitecture() const {
102    return (Architecture) (reg & 0xff000000);
103 }
104
105 bool MachRegister::isValid() const {
106    return (reg != InvalidReg.reg);
107 }
108
109 MachRegisterVal MachRegister::getSubRegValue(const MachRegister& subreg,
110                                              MachRegisterVal &orig) const
111 {
112    if (subreg.reg == reg ||
113        getArchitecture() == Arch_ppc32 ||
114        getArchitecture() == Arch_ppc64)
115       return orig;
116
117    assert(subreg.getBaseRegister() == getBaseRegister());
118    switch ((subreg.reg & 0x00000f00) >> 8) {
119       case 0x0: return orig;
120       case 0x1: return (orig & 0xff);
121       case 0x2: return (orig & 0xff00) >> 8;
122       case 0x3: return (orig & 0xffff);
123       case 0xf: return (orig & 0xffffffff);
124       default: assert(0); return orig;
125    }
126 }
127
128 std::string MachRegister::name() const {
129         assert(names() != NULL);
130         NameMap::const_iterator iter = names()->find(reg);
131         if (iter != names()->end()) {
132                 return iter->second;
133         }
134         return std::string("<INVALID_REG>");
135 }
136
137 unsigned int MachRegister::size() const {
138    switch (getArchitecture())
139    {
140       case Arch_x86:
141          switch (reg & 0x0000ff00) {
142             case x86::L_REG: //L_REG
143             case x86::H_REG: //H_REG
144                return 1;
145             case x86::W_REG: //W_REG
146                return 2;
147             case x86::FULL: //FULL
148                return 4;
149             // Commented out because no register
150             // is defined with this size type
151             //case x86::QUAD:
152             //   return 8;
153             case x86::OCT:
154                return 16;
155             case x86::FPDBL:
156                return 10;
157             case x86::BIT:
158                return 0;
159             case x86::YMMS:
160                return 32;
161             case x86::ZMMS:
162                return 64;
163             default:
164                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
165                assert(0);
166          }
167       case Arch_x86_64:
168          switch (reg & 0x0000ff00) {
169             case x86_64::L_REG: //L_REG
170             case x86_64::H_REG: //H_REG
171                 return 1;
172             case x86_64::W_REG: //W_REG
173                 return 2;
174             case x86_64::FULL: //FULL
175                 return 8;
176             case x86_64::D_REG:
177                return 4;
178             case x86_64::OCT:
179                return 16;
180             case x86_64::FPDBL:
181                return 10;
182             case x86_64::BIT:
183                return 0;
184             case x86_64::YMMS:
185                return 32;
186             case x86_64::ZMMS:
187                return 64;
188
189             default:
190                return 0; // Xiaozhu: do not assert, but return 0 as an indication of parsing junk.
191                assert(0);
192          }
193       case Arch_ppc32: {
194          int reg_class = reg & 0x00ff0000;
195          if (reg_class == ppc32::FPR || reg_class == ppc32::FSR)
196             return 8;
197          return 4;
198       }
199       case Arch_ppc64:
200         if((reg & 0x00ff0000) == aarch64::FPR)
201           return 16;
202         return 8;
203       case Arch_aarch32:
204       case Arch_cuda:
205         assert(0);
206       case Arch_aarch64:
207                 if((reg & 0x00ff0000) == aarch64::FPR)
208                 {
209                     switch(reg & 0x0000ff00)
210                     {
211                         case aarch64::B_REG: return 1;
212                         case aarch64::W_REG: return 2;
213                         case aarch64::D_REG: return 4;
214                         case aarch64::FULL: 
215                         case aarch64::HQ_REG: return 8;
216                         case aarch64::Q_REG: return 16;
217                         default:
218                             assert(0);
219                             return 0;
220                     }
221                 }
222                 else if((reg & 0x00ff0000) == aarch64::GPR || (reg & 0x00ff0000) == aarch64::SPR ||
223                 (reg & 0x00ff0000) == aarch64::SYSREG || (reg & 0x00ff0000) == aarch64::FLAG)
224                         switch(reg & 0x0000ff00)
225                         {
226                                 case aarch64::FULL : return 8;
227                                 case aarch64::D_REG: return 4;
228                 case aarch64::BIT:   return 0;
229                                 default: return 0;
230                         }
231                 else
232                         return 4;
233       case Arch_none:
234          return 0;
235    }
236    return 0; //Unreachable, but disable warnings
237 }
238
239 bool MachRegister::operator<(const MachRegister &a) const {
240    return (reg < a.reg);
241 }
242
243 bool MachRegister::operator==(const MachRegister &a) const {
244    return (reg == a.reg);
245 }
246
247 MachRegister::operator signed int() const {
248    return reg;
249 }
250
251 signed int MachRegister::val() const {
252    return reg;
253 }
254
255
256 MachRegister MachRegister::getPC(Dyninst::Architecture arch)
257 {
258    switch (arch)
259    {
260       case Arch_x86:
261          return x86::eip;
262       case Arch_x86_64:
263          return x86_64::rip;
264       case Arch_ppc32:
265          return ppc32::pc;
266       case Arch_ppc64:
267          return ppc64::pc;
268       case Arch_aarch64:  //aarch64: pc is not writable
269          return aarch64::pc;
270       case Arch_aarch32:
271       case Arch_cuda:
272          assert(0);
273       case Arch_none:
274          return InvalidReg;
275    }
276    return InvalidReg;
277 }
278
279
280 MachRegister MachRegister::getReturnAddress(Dyninst::Architecture arch)
281 {
282    switch (arch)
283    {
284       case Arch_x86:
285           assert(0); //not implemented
286       case Arch_x86_64:
287           assert(0); //not implemented
288       case Arch_ppc32:
289           assert(0); //not implemented
290       case Arch_ppc64:
291           assert(0); //not implemented
292       case Arch_aarch64:  //aarch64: x30 stores the RA for current frame
293          return aarch64::x30;
294       case Arch_aarch32:
295       case Arch_cuda:
296          assert(0);
297       case Arch_none:
298          return InvalidReg;
299    }
300    return InvalidReg;
301 }
302
303 MachRegister MachRegister::getFramePointer(Dyninst::Architecture arch)
304 {
305    switch (arch)
306    {
307       case Arch_x86:
308          return x86::ebp;
309       case Arch_x86_64:
310          return x86_64::rbp;
311       case Arch_ppc32:
312          return ppc32::r1;
313       case Arch_ppc64:
314          return ppc64::r1;
315       case Arch_aarch64:
316          return aarch64::x29; //aarch64: frame pointer is X29 by convention
317       case Arch_none:
318          return InvalidReg;
319       default:
320          assert(0);
321          return InvalidReg;
322    }
323    return InvalidReg;
324 }
325
326 MachRegister MachRegister::getStackPointer(Dyninst::Architecture arch)
327 {
328    switch (arch)
329    {
330       case Arch_x86:
331          return x86::esp;
332       case Arch_x86_64:
333          return x86_64::rsp;
334       case Arch_ppc32:
335          return ppc32::r1;
336       case Arch_ppc64:
337          return ppc64::r1;
338       case Arch_aarch64:
339          return aarch64::sp; //aarch64: stack pointer is an independent register
340       case Arch_aarch32:
341       case Arch_cuda:
342          assert(0);
343       case Arch_none:
344          return InvalidReg;
345       default:
346          assert(0);
347          return InvalidReg;
348    }
349    return InvalidReg;
350 }
351
352 MachRegister MachRegister::getSyscallNumberReg(Dyninst::Architecture arch)
353 {
354     switch (arch)
355     {
356         case Arch_x86:
357             return x86::eax;
358         case Arch_x86_64:
359             return x86_64::rax;
360         case Arch_ppc32:
361             return ppc32::r0;
362         case Arch_ppc64:
363             return ppc64::r0;
364         case Arch_aarch64:
365             return aarch64::x8;
366         case Arch_aarch32:
367         case Arch_cuda:
368             assert(0);
369         case Arch_none:
370             return InvalidReg;
371       default:
372          assert(0);
373          return InvalidReg;
374     }
375     return InvalidReg;
376 }
377
378 MachRegister MachRegister::getSyscallNumberOReg(Dyninst::Architecture arch)
379 {
380     switch (arch)
381     {
382         case Arch_x86:
383             return x86::oeax;
384         case Arch_x86_64:
385             return x86_64::orax;
386         case Arch_ppc32:
387             return ppc32::r0;
388         case Arch_ppc64:
389             return ppc64::r0;
390         case Arch_aarch64:
391             return aarch64::x8;
392         case Arch_none:
393             return InvalidReg;
394       default:
395          assert(0);
396          return InvalidReg;
397     }
398     return InvalidReg;
399 }
400
401 MachRegister MachRegister::getSyscallReturnValueReg(Dyninst::Architecture arch)
402 {
403     switch (arch)
404     {
405         case Arch_x86:
406             return x86::eax;
407         case Arch_x86_64:
408             return x86_64::rax;
409         case Arch_ppc32:
410             return ppc32::r3;
411         case Arch_ppc64:
412             return ppc64::r3;
413         case Arch_aarch64:
414             return aarch64::x0; //returned value is save in x0
415         case Arch_none:
416             return InvalidReg;
417       default:
418          assert(0);
419          return InvalidReg;
420     }
421     return InvalidReg;
422 }
423
424 MachRegister MachRegister::getArchRegFromAbstractReg(MachRegister abstract,
425         Dyninst::Architecture arch) {
426     switch(arch){
427         case Arch_aarch64:
428             if( abstract == ReturnAddr)
429                     return aarch64::x30;
430             if( abstract == FrameBase)
431                     return aarch64::x29;
432             if( abstract == StackTop)
433                     return aarch64::sp;
434             if( abstract == CFA)
435                 assert(0); //don't know what to do
436             //not abstract, return arch reg
437             return abstract;
438         default:
439             assert(0);
440     }
441
442     return Dyninst::InvalidReg;
443 }
444
445 MachRegister MachRegister::getZeroFlag(Dyninst::Architecture arch)
446 {
447    switch (arch)
448    {
449       case Arch_x86:
450          return x86::zf;
451       case Arch_x86_64:
452          return x86_64::zf;
453       case Arch_aarch64: 
454          return aarch64::z;
455       case Arch_aarch32:
456          assert(!"Not implemented");
457       case Arch_ppc32:
458          return ppc32::cr0e;
459       case Arch_ppc64:
460          return ppc64::cr0e;
461       case Arch_cuda:
462          assert(0);
463       case Arch_none:
464          return InvalidReg;
465       default:
466          return InvalidReg;
467    }
468
469    return InvalidReg;
470 }
471
472
473 bool MachRegister::isPC() const
474 {
475    return (*this == x86_64::rip || *this == x86::eip ||
476            *this == ppc32::pc || *this == ppc64::pc ||
477            *this == aarch64::pc );
478 }
479
480 bool MachRegister::isFramePointer() const
481 {
482    return (*this == x86_64::rbp || *this == x86::ebp ||
483            *this == FrameBase ||
484            *this == aarch64::x29);
485 }
486
487 bool MachRegister::isStackPointer() const
488 {
489    return (*this == x86_64::rsp || *this == x86::esp ||
490            *this == ppc32::r1   || *this == ppc64::r1 ||
491            *this == aarch64::sp);
492 }
493
494 bool MachRegister::isSyscallNumberReg() const
495 {
496    return ( *this == x86_64::orax || *this == x86::oeax ||
497             *this == ppc32::r1    || *this == ppc64::r1 ||
498             *this == aarch64::x8
499             );
500 }
501
502 bool MachRegister::isSyscallReturnValueReg() const
503 {
504    if(getArchitecture() == Arch_aarch64)
505       assert(0);
506     return (*this == x86_64::rax || *this == x86::eax ||
507             *this == ppc32::r1   || *this == ppc64::r1 ||
508             *this == aarch64::x0
509             );
510 }
511
512 bool MachRegister::isFlag() const
513 {
514     int regC = regClass();
515     switch (getArchitecture())
516     {
517       case Arch_x86:
518          return regC == x86::FLAG;
519       case Arch_x86_64:
520          return regC == x86_64::FLAG;
521       case Arch_aarch64:
522          return regC == aarch64::FLAG;
523       case Arch_ppc32: 
524       case Arch_ppc64:{
525          // For power, we have a different register representation.
526          // We do not use the subrange field for MachReigsters
527          // and all lower 32 bits are base ID
528          int baseID = reg & 0x0000FFFF;
529          return (baseID <= 731 && baseID >= 700) || (baseID <= 629 && baseID >= 621); 
530       }
531       default:
532          assert(!"Not implemented!");
533    }
534    return false;
535 }
536
537 bool MachRegister::isZeroFlag() const
538 {
539     switch (getArchitecture())
540     {
541       case Arch_x86:
542          return *this == x86::zf;
543       case Arch_x86_64:
544          return *this == x86_64::zf;
545       case Arch_aarch64:
546          return *this == aarch64::z;
547       case Arch_ppc32: 
548       case Arch_ppc64:{
549          // For power, we have a different register representation.
550          // We do not use the subrange field for MachReigsters
551          // and all lower 32 bits are base ID
552          int baseID = reg & 0x0000FFFF;
553          return (baseID <= 731 && baseID >= 700 && baseID % 4 == 2) || (baseID <= 628 && baseID >= 621); 
554       }
555       default:
556          assert(!"Not implemented!");
557    }
558    return false;
559 }
560
561 COMMON_EXPORT bool Dyninst::isSegmentRegister(int regClass)
562 {
563    return 0 != (regClass & x86::SEG);
564 }
565
566
567 /* This function should has a boolean return value
568  * to indicate whether there is a corresponding
569  * ROSE register.
570  *
571  * Since historically, this function does not 
572  * have a return value. We set c to -1 to represent
573  * error cases
574  */
575
576 void MachRegister::getROSERegister(int &c, int &n, int &p)
577 {
578    // Rose: class, number, position
579    // Dyninst: category, base id, subrange
580
581    signed int category = (reg & 0x00ff0000);
582    signed int subrange = (reg & 0x0000ff00);
583    signed int baseID =   (reg & 0x000000ff);
584
585    switch (getArchitecture()) {
586       case Arch_x86:
587          switch (category) {
588             case x86::GPR:
589                c = x86_regclass_gpr;
590                switch (baseID) {
591                   case x86::BASEA:
592                      n = x86_gpr_ax;
593                      break;
594                   case x86::BASEC:
595                      n = x86_gpr_cx;
596                      break;
597                   case x86::BASED:
598                      n = x86_gpr_dx;
599                      break;
600                   case x86::BASEB:
601                      n = x86_gpr_bx;
602                      break;
603                   case x86::BASESP:
604                      n = x86_gpr_sp;
605                      break;
606                   case x86::BASEBP:
607                      n = x86_gpr_bp;
608                      break;
609                   case x86::BASESI:
610                      n = x86_gpr_si;
611                      break;
612                   case x86::BASEDI:
613                      n = x86_gpr_di;
614                      break;
615                   default:
616                      n = 0;
617                      break;
618                }
619                break;
620             case x86::SEG:
621                c = x86_regclass_segment;
622                switch (baseID) {
623                   case 0x0:
624                      n = x86_segreg_ds;
625                      break;
626                   case 0x1:
627                      n = x86_segreg_es;
628                      break;
629                   case 0x2:
630                      n = x86_segreg_fs;
631                      break;
632                   case 0x3:
633                      n = x86_segreg_gs;
634                      break;
635                   case 0x4:
636                      n = x86_segreg_cs;
637                      break;
638                   case 0x5:
639                      n = x86_segreg_ss;
640                      break;
641                   default:
642                      n = 0;
643                      break;
644                }
645                break;
646             case x86::FLAG:
647                c = x86_regclass_flags;
648                switch(baseID) {
649                  case x86::CF:
650                          n = x86_flag_cf;
651                          break;
652                  case x86::PF:
653                          n = x86_flag_pf;
654                          break;
655                  case x86::AF:
656                          n = x86_flag_af;
657                          break;
658                  case x86::ZF:
659                          n = x86_flag_zf;
660                          break;
661                  case x86::SF:
662                          n = x86_flag_sf;
663                          break;
664                  case x86::TF:
665                          n = x86_flag_tf;
666                          break;
667                  case x86::IF:
668                          n = x86_flag_if;
669                          break;
670                  case x86::DF:
671                          n = x86_flag_df;
672                          break;
673                  case x86::OF:
674                          n = x86_flag_of;
675                          break;
676                  default:
677                          assert(0);
678                          break;
679                  }
680          break;
681          case x86::MISC:
682                c = x86_regclass_unknown;
683                break;
684          case x86::XMM:
685             c = x86_regclass_xmm;
686             n = baseID;
687             break;
688          case x86::MMX:
689             c = x86_regclass_mm;
690             n = baseID;
691             break;
692          case x86::CTL:
693             c = x86_regclass_cr;
694             n = baseID;
695             break;
696          case x86::DBG:
697             c = x86_regclass_dr;
698             n = baseID;
699             break;
700          case x86::TST:
701             c = x86_regclass_unknown;
702             break;
703          case 0:
704            switch (baseID) {
705               case 0x10:
706                  c = x86_regclass_ip;
707                  n = 0;
708                  break;
709               default:
710                  c = x86_regclass_unknown;
711                  break;
712            }
713          break;
714          }
715       break;
716     case Arch_x86_64:
717          switch (category) {
718             case x86_64::GPR:
719                c = x86_regclass_gpr;
720                switch (baseID) {
721                   case x86_64::BASEA:
722                      n = x86_gpr_ax;
723                      break;
724                   case x86_64::BASEC:
725                      n = x86_gpr_cx;
726                      break;
727                   case x86_64::BASED:
728                      n = x86_gpr_dx;
729                      break;
730                   case x86_64::BASEB:
731                      n = x86_gpr_bx;
732                      break;
733                   case x86_64::BASESP:
734                      n = x86_gpr_sp;
735                      break;
736                   case x86_64::BASEBP:
737                      n = x86_gpr_bp;
738                      break;
739                   case x86_64::BASESI:
740                      n = x86_gpr_si;
741                      break;
742                   case x86_64::BASEDI:
743                      n = x86_gpr_di;
744                      break;
745                   case x86_64::BASE8:
746                      n = x86_gpr_r8;
747                      break;
748                   case x86_64::BASE9:
749                      n = x86_gpr_r9;
750                      break;
751                   case x86_64::BASE10:
752                      n = x86_gpr_r10;
753                      break;
754                   case x86_64::BASE11:
755                      n = x86_gpr_r11;
756                      break;
757                   case x86_64::BASE12:
758                      n = x86_gpr_r12;
759                      break;
760                   case x86_64::BASE13:
761                      n = x86_gpr_r13;
762                      break;
763                   case x86_64::BASE14:
764                      n = x86_gpr_r14;
765                      break;
766                   case x86_64::BASE15:
767                      n = x86_gpr_r15;
768                      break;
769                   default:
770                      n = 0;
771                      break;
772                }
773                break;
774             case x86_64::SEG:
775                c = x86_regclass_segment;
776                switch (baseID) {
777                   case 0x0:
778                      n = x86_segreg_ds;
779                      break;
780                   case 0x1:
781                      n = x86_segreg_es;
782                      break;
783                   case 0x2:
784                      n = x86_segreg_fs;
785                      break;
786                   case 0x3:
787                      n = x86_segreg_gs;
788                      break;
789                   case 0x4:
790                      n = x86_segreg_cs;
791                      break;
792                   case 0x5:
793                      n = x86_segreg_ss;
794                      break;
795                   default:
796                      n = 0;
797                      break;
798                }
799                break;
800             case x86_64::FLAG:
801                c = x86_regclass_flags;
802                switch(baseID) {
803                case x86_64::CF:
804                  n = x86_flag_cf;
805                  break;
806                case x86_64::PF:
807                  n = x86_flag_pf;
808                  break;
809                case x86_64::AF:
810                  n = x86_flag_af;
811                  break;
812                case x86_64::ZF:
813                  n = x86_flag_zf;
814                  break;
815                case x86_64::SF:
816                  n = x86_flag_sf;
817                  break;
818                case x86_64::TF:
819                  n = x86_flag_tf;
820                  break;
821                case x86_64::IF:
822                  n = x86_flag_if;
823                  break;
824                case x86_64::DF:
825                  n = x86_flag_df;
826                  break;
827                case x86_64::OF:
828                  n = x86_flag_of;
829                  break;
830                default:
831                  c = -1;
832                  return; 
833                  break;
834       }
835                break;
836             case x86_64::MISC:
837                c = x86_regclass_unknown;
838                break;
839             case x86_64::KMASK:
840                c = x86_regclass_kmask;
841                n = baseID;
842                break;
843             case x86_64::ZMM:
844                c = x86_regclass_zmm;
845                n = baseID;
846                break;
847             case x86_64::YMM:
848                c = x86_regclass_ymm;
849                n = baseID;
850                break;
851             case x86_64::XMM:
852                c = x86_regclass_xmm;
853                n = baseID;
854                break;
855             case x86_64::MMX:
856                c = x86_regclass_mm;
857                n = baseID;
858                break;
859             case x86_64::CTL:
860                c = x86_regclass_cr;
861                n = baseID;
862                break;
863             case x86_64::DBG:
864                c = x86_regclass_dr;
865                n = baseID;
866                break;
867             case x86_64::TST:
868                c = x86_regclass_unknown;
869                break;
870             case 0:
871                switch (baseID) {
872                   case 0x10:
873                      c = x86_regclass_ip;
874                      n = 0;
875                      break;
876                   default:
877                      c = x86_regclass_unknown;
878                      break;
879                }
880                break;
881          }
882          break;
883        case Arch_ppc32:
884        case Arch_ppc64: // 64-bit not supported in ROSE
885        {
886          baseID = reg & 0x0000FFFF;
887            n = baseID;
888            switch(category)
889            {
890                case ppc32::GPR:
891                    c = powerpc_regclass_gpr;
892                    break;
893                case ppc32::FPR:
894                case ppc32::FSR:
895                    c = powerpc_regclass_fpr;
896                    break;
897                case ppc32::SPR:
898                {
899                    if(baseID < 613) {
900                        c = powerpc_regclass_spr;
901                    } else if(baseID < 621 ) {
902                        c = powerpc_regclass_sr;
903                    } else {
904                        c = powerpc_regclass_cr;
905                        n = 0;
906                        p = baseID - 621;
907 /*                       n = baseID - 621;
908                        if(n > 7) {
909                          n = 0;
910                          p = powerpc_condreggranularity_whole;
911                        } else {
912                          p = powerpc_condreggranularity_field;
913                        }
914 */
915                    }
916                }
917                break;
918                default:
919                    c = -1;
920                    return;
921            }
922            return;
923        }
924        break;
925        case Arch_aarch64: {
926            p = 0;
927            switch (category) {
928                case aarch64::GPR: {
929                    c = armv8_regclass_gpr;
930                    int regnum = baseID - (aarch64::x0 & 0xFF);
931                    n = armv8_gpr_r0 + regnum;
932                }
933                    break;
934                case aarch64::SPR: {
935                    n = 0;
936                    if (baseID == (aarch64::pstate & 0xFF)) {
937                        c = armv8_regclass_pstate;
938                    } else if(baseID == (aarch64::xzr & 0xFF) || baseID == (aarch64::wzr & 0xFF)) {
939                        c = armv8_regclass_gpr;
940                        n = armv8_gpr_zr;
941                    } else if (baseID == (aarch64::pc & 0xFF)) {
942                        c = armv8_regclass_pc;
943                    } else if (baseID == (aarch64::sp & 0xFF) || baseID == (aarch64::wsp & 0xFF)) {
944                        c = armv8_regclass_sp;
945                    }
946                }
947                    break;
948                case aarch64::FPR: {
949                    c = armv8_regclass_simd_fpr;
950
951                    int firstRegId;
952                    switch(reg & 0xFF00) {
953                        case aarch64::Q_REG: firstRegId = (aarch64::q0 & 0xFF);
954                            break;
955                        case aarch64::HQ_REG: firstRegId = (aarch64::hq0 & 0xFF);
956                            p = 64;
957                            break;
958                        case aarch64::FULL: firstRegId = (aarch64::d0 & 0xFF);
959                            break;
960                        case aarch64::D_REG: firstRegId = (aarch64::s0 & 0xFF);
961                            break;
962                        case aarch64::W_REG: firstRegId = (aarch64::h0 & 0xFF);
963                            break;
964                        case aarch64::B_REG: firstRegId = (aarch64::b0 & 0xFF);
965                            break;
966                        default:assert(!"invalid register subcategory for ARM64!");
967                            break;
968                    }
969                    n = armv8_simdfpr_v0 + (baseID - firstRegId);
970                }
971                    break;
972                case aarch64::FLAG: {
973                    c = armv8_regclass_pstate;
974                    n = 0;
975                    switch (baseID) {
976                        case aarch64::N_FLAG:
977                            p = armv8_pstatefield_n;
978                            break;
979                        case aarch64::Z_FLAG:
980                            p = armv8_pstatefield_z;
981                            break;
982                        case aarch64::V_FLAG:
983                            p = armv8_pstatefield_v;
984                            break;
985                        case aarch64::C_FLAG:
986                            p = armv8_pstatefield_c;
987                            break;
988                        default:
989                            c = -1;
990                            return;
991                    }
992                }
993                    break;
994                default:
995                    // We do not want to assert here.
996                    // Set these output variable to invalid values and let the
997                    // semantics code to throw exceptions
998                    p = -1;
999                    c = -1;
1000                    n = -1;
1001 //                   assert(!"unknown register type!");
1002                    break;
1003            }
1004            return;
1005        }
1006
1007       break;
1008       default:
1009          c = x86_regclass_unknown;
1010          n = 0;
1011          break;
1012    }
1013
1014    switch (getArchitecture()) {
1015       case Arch_x86:
1016          switch (subrange) {
1017             case x86::OCT:
1018             case x86::FPDBL:
1019                p = x86_regpos_qword;
1020                break;
1021             case x86::H_REG:
1022                p = x86_regpos_high_byte;
1023                break;
1024             case x86::L_REG:
1025                p = x86_regpos_low_byte;
1026                break;
1027             case x86::W_REG:
1028                p = x86_regpos_word;
1029                break;
1030             case x86::FULL:
1031             case x86_64::D_REG:
1032                p = x86_regpos_dword;
1033                break;
1034             case x86::BIT:
1035                p = x86_regpos_all;
1036                break;
1037          }
1038          break;
1039
1040       case Arch_x86_64:
1041          switch (subrange) {
1042             case x86::FULL:
1043             case x86::OCT:
1044             case x86::FPDBL:
1045                p = x86_regpos_qword;
1046                break;
1047             case x86::H_REG:
1048                p = x86_regpos_high_byte;
1049                break;
1050             case x86::L_REG:
1051                p = x86_regpos_low_byte;
1052                break;
1053             case x86::W_REG:
1054                p = x86_regpos_word;
1055                break;
1056             case x86_64::D_REG:
1057                p = x86_regpos_dword;
1058                break;
1059                  case x86::BIT:
1060                  p = x86_regpos_all;
1061                  break;
1062          }
1063       break;
1064       case Arch_aarch64:
1065       {
1066           c = -1;
1067           return;
1068         }
1069       default:
1070         p = x86_regpos_unknown;
1071    }
1072 }
1073
1074 MachRegister MachRegister::DwarfEncToReg(int encoding, Dyninst::Architecture arch)
1075 {
1076    switch (arch)
1077    {
1078       case Arch_x86:
1079          switch (encoding) {
1080             case 0: return Dyninst::x86::eax;
1081             case 1: return Dyninst::x86::ecx;
1082             case 2: return Dyninst::x86::edx;
1083             case 3: return Dyninst::x86::ebx;
1084             case 4: return Dyninst::x86::esp;
1085             case 5: return Dyninst::x86::ebp;
1086             case 6: return Dyninst::x86::esi;
1087             case 7: return Dyninst::x86::edi;
1088             case 8: return Dyninst::x86::eip;
1089             case 9: return Dyninst::x86::flags;
1090             case 10: return Dyninst::InvalidReg;
1091             case 11: return Dyninst::x86::st0;
1092             case 12: return Dyninst::x86::st1;
1093             case 13: return Dyninst::x86::st2;
1094             case 14: return Dyninst::x86::st3;
1095             case 15: return Dyninst::x86::st4;
1096             case 16: return Dyninst::x86::st5;
1097             case 17: return Dyninst::x86::st6;
1098             case 18: return Dyninst::x86::st7;
1099             case 19: return Dyninst::InvalidReg;
1100             case 20: return Dyninst::InvalidReg;
1101             case 21: return Dyninst::x86::xmm0;
1102             case 22: return Dyninst::x86::xmm1;
1103             case 23: return Dyninst::x86::xmm2;
1104             case 24: return Dyninst::x86::xmm3;
1105             case 25: return Dyninst::x86::xmm4;
1106             case 26: return Dyninst::x86::xmm5;
1107             case 27: return Dyninst::x86::xmm6;
1108             case 28: return Dyninst::x86::xmm7;
1109             case 29: return Dyninst::x86::mm0;
1110             case 30: return Dyninst::x86::mm1;
1111             case 31: return Dyninst::x86::mm2;
1112             case 32: return Dyninst::x86::mm3;
1113             case 33: return Dyninst::x86::mm4;
1114             case 34: return Dyninst::x86::mm5;
1115             case 35: return Dyninst::x86::mm6;
1116             case 36: return Dyninst::x86::mm7;
1117             case 37: return Dyninst::InvalidReg; //fcw
1118             case 38: return Dyninst::InvalidReg; //fsw
1119             case 39: return Dyninst::InvalidReg; //mxcsr
1120             case 40: return Dyninst::x86::es;
1121             case 41: return Dyninst::x86::cs;
1122             case 42: return Dyninst::x86::ss;
1123             case 43: return Dyninst::x86::ds;
1124             case 44: return Dyninst::x86::fs;
1125             case 45: return Dyninst::x86::gs;
1126             case 46: return Dyninst::InvalidReg;
1127             case 47: return Dyninst::InvalidReg;
1128             case 48: return Dyninst::InvalidReg; //tr
1129             case 49: return Dyninst::InvalidReg; //ldtr
1130             default: return Dyninst::InvalidReg;
1131          }
1132          break;
1133       case Arch_x86_64:
1134          switch (encoding) {
1135             case 0: return Dyninst::x86_64::rax;
1136             case 1: return Dyninst::x86_64::rdx;
1137             case 2: return Dyninst::x86_64::rcx;
1138             case 3: return Dyninst::x86_64::rbx;
1139             case 4: return Dyninst::x86_64::rsi;
1140             case 5: return Dyninst::x86_64::rdi;
1141             case 6: return Dyninst::x86_64::rbp;
1142             case 7: return Dyninst::x86_64::rsp;
1143             case 8: return Dyninst::x86_64::r8;
1144             case 9: return Dyninst::x86_64::r9;
1145             case 10: return Dyninst::x86_64::r10;
1146             case 11: return Dyninst::x86_64::r11;
1147             case 12: return Dyninst::x86_64::r12;
1148             case 13: return Dyninst::x86_64::r13;
1149             case 14: return Dyninst::x86_64::r14;
1150             case 15: return Dyninst::x86_64::r15;
1151             case 16: return Dyninst::x86_64::rip;
1152             case 17: return Dyninst::x86_64::k0;
1153             case 18: return Dyninst::x86_64::k1;
1154             case 19: return Dyninst::x86_64::k2;
1155             case 20: return Dyninst::x86_64::k3;
1156             case 21: return Dyninst::x86_64::k4;
1157             case 22: return Dyninst::x86_64::k5;
1158             case 23: return Dyninst::x86_64::k6;
1159             case 24: return Dyninst::x86_64::k7;
1160             case 25: return Dyninst::x86_64::zmm0;
1161             case 26: return Dyninst::x86_64::zmm1;
1162             case 27: return Dyninst::x86_64::zmm2;
1163             case 28: return Dyninst::x86_64::zmm3;
1164             case 29: return Dyninst::x86_64::zmm4;
1165             case 30: return Dyninst::x86_64::zmm5;
1166             case 31: return Dyninst::x86_64::zmm6;
1167             case 32: return Dyninst::x86_64::zmm7;
1168             case 33: return Dyninst::x86_64::zmm8;
1169             case 34: return Dyninst::x86_64::zmm9;
1170             case 35: return Dyninst::x86_64::zmm10;
1171             case 36: return Dyninst::x86_64::zmm11;
1172             case 37: return Dyninst::x86_64::zmm12;
1173             case 38: return Dyninst::x86_64::zmm13;
1174             case 39: return Dyninst::x86_64::zmm14;
1175             case 40: return Dyninst::x86_64::zmm15;
1176             case 41: return Dyninst::x86_64::zmm16;
1177             case 42: return Dyninst::x86_64::zmm17;
1178             case 43: return Dyninst::x86_64::zmm18;
1179             case 44: return Dyninst::x86_64::zmm19;
1180             case 45: return Dyninst::x86_64::zmm20;
1181             case 46: return Dyninst::x86_64::zmm21;
1182             case 47: return Dyninst::x86_64::zmm22;
1183             case 48: return Dyninst::x86_64::zmm23;
1184             case 49: return Dyninst::x86_64::zmm24;
1185             case 50: return Dyninst::x86_64::zmm25;
1186             case 51: return Dyninst::x86_64::zmm26;
1187             case 52: return Dyninst::x86_64::zmm27;
1188             case 53: return Dyninst::x86_64::zmm28;
1189             case 54: return Dyninst::x86_64::zmm29;
1190             case 55: return Dyninst::x86_64::zmm30;
1191             case 56: return Dyninst::x86_64::zmm31;
1192             case 57: return Dyninst::x86_64::ymm0;
1193             case 58: return Dyninst::x86_64::ymm1;
1194             case 59: return Dyninst::x86_64::ymm2;
1195             case 60: return Dyninst::x86_64::ymm3;
1196             case 61: return Dyninst::x86_64::ymm4;
1197             case 62: return Dyninst::x86_64::ymm5;
1198             case 63: return Dyninst::x86_64::ymm6;
1199             case 64: return Dyninst::x86_64::ymm7;
1200             case 65: return Dyninst::x86_64::ymm8;
1201             case 66: return Dyninst::x86_64::ymm9;
1202             case 67: return Dyninst::x86_64::ymm10;
1203             case 68: return Dyninst::x86_64::ymm11;
1204             case 69: return Dyninst::x86_64::ymm12;
1205             case 70: return Dyninst::x86_64::ymm13;
1206             case 71: return Dyninst::x86_64::ymm14;
1207             case 72: return Dyninst::x86_64::ymm15;
1208             case 73: return Dyninst::x86_64::ymm16;
1209             case 74: return Dyninst::x86_64::ymm17;
1210             case 75: return Dyninst::x86_64::ymm18;
1211             case 76: return Dyninst::x86_64::ymm19;
1212             case 77: return Dyninst::x86_64::ymm20;
1213             case 78: return Dyninst::x86_64::ymm21;
1214             case 79: return Dyninst::x86_64::ymm22;
1215             case 80: return Dyninst::x86_64::ymm23;
1216             case 81: return Dyninst::x86_64::ymm24;
1217             case 82: return Dyninst::x86_64::ymm25;
1218             case 83: return Dyninst::x86_64::ymm26;
1219             case 84: return Dyninst::x86_64::ymm27;
1220             case 85: return Dyninst::x86_64::ymm28;
1221             case 86: return Dyninst::x86_64::ymm29;
1222             case 87: return Dyninst::x86_64::ymm30;
1223             case 88: return Dyninst::x86_64::ymm31;
1224             case 89: return Dyninst::x86_64::xmm0;
1225             case 90: return Dyninst::x86_64::xmm1;
1226             case 91: return Dyninst::x86_64::xmm2;
1227             case 92: return Dyninst::x86_64::xmm3;
1228             case 93: return Dyninst::x86_64::xmm4;
1229             case 94: return Dyninst::x86_64::xmm5;
1230             case 95: return Dyninst::x86_64::xmm6;
1231             case 96: return Dyninst::x86_64::xmm7;
1232             case 97: return Dyninst::x86_64::xmm8;
1233             case 98: return Dyninst::x86_64::xmm9;
1234             case 99: return Dyninst::x86_64::xmm10;
1235             case 100: return Dyninst::x86_64::xmm11;
1236             case 101: return Dyninst::x86_64::xmm12;
1237             case 102: return Dyninst::x86_64::xmm13;
1238             case 103: return Dyninst::x86_64::xmm14;
1239             case 104: return Dyninst::x86_64::xmm15;
1240             case 105: return Dyninst::x86_64::xmm16;
1241             case 106: return Dyninst::x86_64::xmm17;
1242             case 107: return Dyninst::x86_64::xmm18;
1243             case 108: return Dyninst::x86_64::xmm19;
1244             case 109: return Dyninst::x86_64::xmm20;
1245             case 110: return Dyninst::x86_64::xmm21;
1246             case 111: return Dyninst::x86_64::xmm22;
1247             case 112: return Dyninst::x86_64::xmm23;
1248             case 113: return Dyninst::x86_64::xmm24;
1249             case 114: return Dyninst::x86_64::xmm25;
1250             case 115: return Dyninst::x86_64::xmm26;
1251             case 116: return Dyninst::x86_64::xmm27;
1252             case 117: return Dyninst::x86_64::xmm28;
1253             case 118: return Dyninst::x86_64::xmm29;
1254             case 119: return Dyninst::x86_64::xmm30;
1255             case 120: return Dyninst::x86_64::xmm31;
1256             case 121: return Dyninst::x86_64::st0;
1257             case 122: return Dyninst::x86_64::st1;
1258             case 123: return Dyninst::x86_64::st2;
1259             case 124: return Dyninst::x86_64::st3;
1260             case 125: return Dyninst::x86_64::st4;
1261             case 126: return Dyninst::x86_64::st5;
1262             case 127: return Dyninst::x86_64::st6;
1263             case 128: return Dyninst::x86_64::st7;
1264             case 129: return Dyninst::x86_64::mm0;
1265             case 130: return Dyninst::x86_64::mm1;
1266             case 131: return Dyninst::x86_64::mm2;
1267             case 132: return Dyninst::x86_64::mm3;
1268             case 133: return Dyninst::x86_64::mm4;
1269             case 134: return Dyninst::x86_64::mm5;
1270             case 135: return Dyninst::x86_64::mm6;
1271             case 136: return Dyninst::x86_64::mm7;
1272             case 137: return Dyninst::x86_64::flags;
1273             case 138: return Dyninst::x86_64::es;
1274             case 139: return Dyninst::x86_64::cs;
1275             case 140: return Dyninst::x86_64::ss;
1276             case 141: return Dyninst::x86_64::ds;
1277             case 142: return Dyninst::x86_64::fs;
1278             case 143: return Dyninst::x86_64::gs;
1279             case 144: return Dyninst::InvalidReg;
1280             case 145: return Dyninst::InvalidReg;
1281             case 146: return Dyninst::x86_64::fsbase;
1282             case 147: return Dyninst::x86_64::gsbase;
1283             case 148: return Dyninst::InvalidReg;
1284             case 149: return Dyninst::InvalidReg;
1285             case 150: return Dyninst::InvalidReg; //tr
1286             case 151: return Dyninst::InvalidReg; //ldtr
1287             case 152: return Dyninst::InvalidReg; //mxcsr
1288             case 153: return Dyninst::InvalidReg; //fcw
1289             case 154: return Dyninst::InvalidReg; //fsw
1290          }
1291          break;
1292       case Arch_ppc32:
1293          switch (encoding) {
1294             case 0: return Dyninst::ppc32::r0;
1295             case 1: return Dyninst::ppc32::r1;
1296             case 2: return Dyninst::ppc32::r2;
1297             case 3: return Dyninst::ppc32::r3;
1298             case 4: return Dyninst::ppc32::r4;
1299             case 5: return Dyninst::ppc32::r5;
1300             case 6: return Dyninst::ppc32::r6;
1301             case 7: return Dyninst::ppc32::r7;
1302             case 8: return Dyninst::ppc32::r8;
1303             case 9: return Dyninst::ppc32::r9;
1304             case 10: return Dyninst::ppc32::r10;
1305             case 11: return Dyninst::ppc32::r11;
1306             case 12: return Dyninst::ppc32::r12;
1307             case 13: return Dyninst::ppc32::r13;
1308             case 14: return Dyninst::ppc32::r14;
1309             case 15: return Dyninst::ppc32::r15;
1310             case 16: return Dyninst::ppc32::r16;
1311             case 17: return Dyninst::ppc32::r17;
1312             case 18: return Dyninst::ppc32::r18;
1313             case 19: return Dyninst::ppc32::r19;
1314             case 20: return Dyninst::ppc32::r20;
1315             case 21: return Dyninst::ppc32::r21;
1316             case 22: return Dyninst::ppc32::r22;
1317             case 23: return Dyninst::ppc32::r23;
1318             case 24: return Dyninst::ppc32::r24;
1319             case 25: return Dyninst::ppc32::r25;
1320             case 26: return Dyninst::ppc32::r26;
1321             case 27: return Dyninst::ppc32::r27;
1322             case 28: return Dyninst::ppc32::r28;
1323             case 29: return Dyninst::ppc32::r29;
1324             case 30: return Dyninst::ppc32::r30;
1325             case 31: return Dyninst::ppc32::r31;
1326             case 32: return Dyninst::ppc32::fpr0;
1327             case 33: return Dyninst::ppc32::fpr1;
1328             case 34: return Dyninst::ppc32::fpr2;
1329             case 35: return Dyninst::ppc32::fpr3;
1330             case 36: return Dyninst::ppc32::fpr4;
1331             case 37: return Dyninst::ppc32::fpr5;
1332             case 38: return Dyninst::ppc32::fpr6;
1333             case 39: return Dyninst::ppc32::fpr7;
1334             case 40: return Dyninst::ppc32::fpr8;
1335             case 41: return Dyninst::ppc32::fpr9;
1336             case 42: return Dyninst::ppc32::fpr10;
1337             case 43: return Dyninst::ppc32::fpr11;
1338             case 44: return Dyninst::ppc32::fpr12;
1339             case 45: return Dyninst::ppc32::fpr13;
1340             case 46: return Dyninst::ppc32::fpr14;
1341             case 47: return Dyninst::ppc32::fpr15;
1342             case 48: return Dyninst::ppc32::fpr16;
1343             case 49: return Dyninst::ppc32::fpr17;
1344             case 50: return Dyninst::ppc32::fpr18;
1345             case 51: return Dyninst::ppc32::fpr19;
1346             case 52: return Dyninst::ppc32::fpr20;
1347             case 53: return Dyninst::ppc32::fpr21;
1348             case 54: return Dyninst::ppc32::fpr22;
1349             case 55: return Dyninst::ppc32::fpr23;
1350             case 56: return Dyninst::ppc32::fpr24;
1351             case 57: return Dyninst::ppc32::fpr25;
1352             case 58: return Dyninst::ppc32::fpr26;
1353             case 59: return Dyninst::ppc32::fpr27;
1354             case 60: return Dyninst::ppc32::fpr28;
1355             case 61: return Dyninst::ppc32::fpr29;
1356             case 62: return Dyninst::ppc32::fpr30;
1357             case 63: return Dyninst::ppc32::fpr31;
1358             case 64: return Dyninst::ppc32::cr;
1359             case 65: return Dyninst::InvalidReg; //FPSCR
1360          }
1361          //Seperate switch statements to give compilers an easier time of
1362          // optimizing
1363          switch (encoding) {
1364             case 100: return Dyninst::ppc32::mq;
1365             case 101: return Dyninst::ppc32::xer;
1366             case 102: return Dyninst::InvalidReg;
1367             case 103: return Dyninst::InvalidReg;
1368             case 104: return Dyninst::InvalidReg; //RTCU
1369             case 105: return Dyninst::InvalidReg; //RTCL
1370             case 106: return Dyninst::InvalidReg;
1371             case 107: return Dyninst::InvalidReg;
1372             case 108: return Dyninst::ppc32::lr;
1373             case 109: return Dyninst::ppc32::ctr;
1374             default: return Dyninst::InvalidReg;
1375          }
1376          break;
1377       case Arch_ppc64:
1378          switch (encoding) {
1379             case 0: return Dyninst::ppc64::r0;
1380             case 1: return Dyninst::ppc64::r1;
1381             case 2: return Dyninst::ppc64::r2;
1382             case 3: return Dyninst::ppc64::r3;
1383             case 4: return Dyninst::ppc64::r4;
1384             case 5: return Dyninst::ppc64::r5;
1385             case 6: return Dyninst::ppc64::r6;
1386             case 7: return Dyninst::ppc64::r7;
1387             case 8: return Dyninst::ppc64::r8;
1388             case 9: return Dyninst::ppc64::r9;
1389             case 10: return Dyninst::ppc64::r10;
1390             case 11: return Dyninst::ppc64::r11;
1391             case 12: return Dyninst::ppc64::r12;
1392             case 13: return Dyninst::ppc64::r13;
1393             case 14: return Dyninst::ppc64::r14;
1394             case 15: return Dyninst::ppc64::r15;
1395             case 16: return Dyninst::ppc64::r16;
1396             case 17: return Dyninst::ppc64::r17;
1397             case 18: return Dyninst::ppc64::r18;
1398             case 19: return Dyninst::ppc64::r19;
1399             case 20: return Dyninst::ppc64::r20;
1400             case 21: return Dyninst::ppc64::r21;
1401             case 22: return Dyninst::ppc64::r22;
1402             case 23: return Dyninst::ppc64::r23;
1403             case 24: return Dyninst::ppc64::r24;
1404             case 25: return Dyninst::ppc64::r25;
1405             case 26: return Dyninst::ppc64::r26;
1406             case 27: return Dyninst::ppc64::r27;
1407             case 28: return Dyninst::ppc64::r28;
1408             case 29: return Dyninst::ppc64::r29;
1409             case 30: return Dyninst::ppc64::r30;
1410             case 31: return Dyninst::ppc64::r31;
1411             case 32: return Dyninst::ppc64::fpr0;
1412             case 33: return Dyninst::ppc64::fpr1;
1413             case 34: return Dyninst::ppc64::fpr2;
1414             case 35: return Dyninst::ppc64::fpr3;
1415             case 36: return Dyninst::ppc64::fpr4;
1416             case 37: return Dyninst::ppc64::fpr5;
1417             case 38: return Dyninst::ppc64::fpr6;
1418             case 39: return Dyninst::ppc64::fpr7;
1419             case 40: return Dyninst::ppc64::fpr8;
1420             case 41: return Dyninst::ppc64::fpr9;
1421             case 42: return Dyninst::ppc64::fpr10;
1422             case 43: return Dyninst::ppc64::fpr11;
1423             case 44: return Dyninst::ppc64::fpr12;
1424             case 45: return Dyninst::ppc64::fpr13;
1425             case 46: return Dyninst::ppc64::fpr14;
1426             case 47: return Dyninst::ppc64::fpr15;
1427             case 48: return Dyninst::ppc64::fpr16;
1428             case 49: return Dyninst::ppc64::fpr17;
1429             case 50: return Dyninst::ppc64::fpr18;
1430             case 51: return Dyninst::ppc64::fpr19;
1431             case 52: return Dyninst::ppc64::fpr20;
1432             case 53: return Dyninst::ppc64::fpr21;
1433             case 54: return Dyninst::ppc64::fpr22;
1434             case 55: return Dyninst::ppc64::fpr23;
1435             case 56: return Dyninst::ppc64::fpr24;
1436             case 57: return Dyninst::ppc64::fpr25;
1437             case 58: return Dyninst::ppc64::fpr26;
1438             case 59: return Dyninst::ppc64::fpr27;
1439             case 60: return Dyninst::ppc64::fpr28;
1440             case 61: return Dyninst::ppc64::fpr29;
1441             case 62: return Dyninst::ppc64::fpr30;
1442             case 63: return Dyninst::ppc64::fpr31;
1443             case 64: return Dyninst::ppc64::cr;
1444             case 65: return Dyninst::InvalidReg; //FPSCR
1445          }
1446          //Seperate switch statements to give compilers an easier time of
1447          // optimizing
1448          switch (encoding) {
1449             case 100: return Dyninst::ppc64::mq;
1450             case 101: return Dyninst::ppc64::xer;
1451             case 102: return Dyninst::InvalidReg;
1452             case 103: return Dyninst::InvalidReg;
1453             case 104: return Dyninst::InvalidReg; //RTCU
1454             case 105: return Dyninst::InvalidReg; //RTCL
1455             case 106: return Dyninst::InvalidReg;
1456             case 107: return Dyninst::InvalidReg;
1457             case 108: return Dyninst::ppc64::lr;
1458             case 109: return Dyninst::ppc64::ctr;
1459             default: return Dyninst::InvalidReg;
1460          }
1461          break;
1462       case Arch_aarch64:
1463          {
1464          // this info can be found in
1465          // DWARF for the ARM ® 64-bit Architecture (AArch64)
1466          switch(encoding){
1467             case 0:  return Dyninst::aarch64::x0;
1468             case 1:  return Dyninst::aarch64::x1;
1469             case 2:  return Dyninst::aarch64::x2;
1470             case 3:  return Dyninst::aarch64::x3;
1471             case 4:  return Dyninst::aarch64::x4;
1472             case 5:  return Dyninst::aarch64::x5;
1473             case 6:  return Dyninst::aarch64::x6;
1474             case 7:  return Dyninst::aarch64::x7;
1475             case 8:  return Dyninst::aarch64::x8;
1476             case 9:  return Dyninst::aarch64::x9;
1477             case 10: return Dyninst::aarch64::x10;
1478             case 11: return Dyninst::aarch64::x11;
1479             case 12: return Dyninst::aarch64::x12;
1480             case 13: return Dyninst::aarch64::x13;
1481             case 14: return Dyninst::aarch64::x14;
1482             case 15: return Dyninst::aarch64::x15;
1483             case 16: return Dyninst::aarch64::x16;
1484             case 17: return Dyninst::aarch64::x17;
1485             case 18: return Dyninst::aarch64::x18;
1486             case 19: return Dyninst::aarch64::x19;
1487             case 20: return Dyninst::aarch64::x20;
1488             case 21: return Dyninst::aarch64::x21;
1489             case 22: return Dyninst::aarch64::x22;
1490             case 23: return Dyninst::aarch64::x23;
1491             case 24: return Dyninst::aarch64::x24;
1492             case 25: return Dyninst::aarch64::x25;
1493             case 26: return Dyninst::aarch64::x26;
1494             case 27: return Dyninst::aarch64::x27;
1495             case 28: return Dyninst::aarch64::x28;
1496             case 29: return Dyninst::aarch64::x29;
1497             case 30: return Dyninst::aarch64::x30;
1498             case 31: return Dyninst::aarch64::sp;
1499             case 32: return Dyninst::InvalidReg;
1500          }
1501          switch(encoding){
1502             case 64: return Dyninst::aarch64::q0;
1503             case 65: return Dyninst::aarch64::q1;
1504             case 66: return Dyninst::aarch64::q2;
1505             case 67: return Dyninst::aarch64::q3;
1506             case 68: return Dyninst::aarch64::q4;
1507             case 69: return Dyninst::aarch64::q5;
1508             case 70: return Dyninst::aarch64::q6;
1509             case 71: return Dyninst::aarch64::q7;
1510             case 72: return Dyninst::aarch64::q8;
1511             case 73: return Dyninst::aarch64::q9;
1512             case 74: return Dyninst::aarch64::q10;
1513             case 75: return Dyninst::aarch64::q11;
1514             case 76: return Dyninst::aarch64::q12;
1515             case 77: return Dyninst::aarch64::q13;
1516             case 78: return Dyninst::aarch64::q14;
1517             case 79: return Dyninst::aarch64::q15;
1518             case 80: return Dyninst::aarch64::q16;
1519             case 81: return Dyninst::aarch64::q17;
1520             case 82: return Dyninst::aarch64::q18;
1521             case 83: return Dyninst::aarch64::q19;
1522             case 84: return Dyninst::aarch64::q20;
1523             case 85: return Dyninst::aarch64::q21;
1524             case 86: return Dyninst::aarch64::q22;
1525             case 87: return Dyninst::aarch64::q23;
1526             case 88: return Dyninst::aarch64::q24;
1527             case 89: return Dyninst::aarch64::q25;
1528             case 90: return Dyninst::aarch64::q26;
1529             case 91: return Dyninst::aarch64::q27;
1530             case 92: return Dyninst::aarch64::q28;
1531             case 93: return Dyninst::aarch64::q29;
1532             case 94: return Dyninst::aarch64::q30;
1533             case 95: return Dyninst::aarch64::q31;
1534
1535             default: return Dyninst::InvalidReg;
1536             break;
1537          }
1538          return Dyninst::InvalidReg;
1539          }
1540       case Arch_cuda:
1541          // ignore CUDA register encodings for now
1542          return Dyninst::InvalidReg;
1543          break;
1544       case Arch_none:
1545          return Dyninst::InvalidReg;
1546          break;
1547       default:
1548          assert(0);
1549          return InvalidReg;
1550    }
1551    //Invalid Architecture passed
1552    return Dyninst::InvalidReg;
1553
1554 }
1555
1556 int MachRegister::getDwarfEnc() const
1557 {
1558    switch (getArchitecture())
1559    {
1560       case Arch_x86:
1561          switch (val()) {
1562             case Dyninst::x86::ieax: return 0;
1563             case Dyninst::x86::iecx: return 1;
1564             case Dyninst::x86::iedx: return 2;
1565             case Dyninst::x86::iebx: return 3;
1566             case Dyninst::x86::iesp: return 4;
1567             case Dyninst::x86::iebp: return 5;
1568             case Dyninst::x86::iesi: return 6;
1569             case Dyninst::x86::iedi: return 7;
1570             case Dyninst::x86::ieip: return 8;
1571             case Dyninst::x86::iflags: return 9;
1572             case Dyninst::x86::ixmm0: return 21;
1573             case Dyninst::x86::ixmm1: return 22;
1574             case Dyninst::x86::ixmm2: return 23;
1575             case Dyninst::x86::ixmm3: return 24;
1576             case Dyninst::x86::ixmm4: return 25;
1577             case Dyninst::x86::ixmm5: return 26;
1578             case Dyninst::x86::ixmm6: return 27;
1579             case Dyninst::x86::ixmm7: return 28;
1580             case Dyninst::x86::imm0: return 29;
1581             case Dyninst::x86::imm1: return 30;
1582             case Dyninst::x86::imm2: return 31;
1583             case Dyninst::x86::imm3: return 32;
1584             case Dyninst::x86::imm4: return 33;
1585             case Dyninst::x86::imm5: return 34;
1586             case Dyninst::x86::imm6: return 35;
1587             case Dyninst::x86::imm7: return 36;
1588             case Dyninst::x86::ies: return 40;
1589             case Dyninst::x86::ics: return 41;
1590             case Dyninst::x86::iss: return 42;
1591             case Dyninst::x86::ids: return 43;
1592             case Dyninst::x86::ifs: return 44;
1593             case Dyninst::x86::igs: return 45;
1594             default: return -1;
1595          }
1596          break;
1597       case Arch_x86_64:
1598          switch (val()) {
1599             case Dyninst::x86_64::irax: return 0;
1600             case Dyninst::x86_64::irdx: return 1;
1601             case Dyninst::x86_64::ircx: return 2;
1602             case Dyninst::x86_64::irbx: return 3;
1603             case Dyninst::x86_64::irsi: return 4;
1604             case Dyninst::x86_64::irdi: return 5;
1605             case Dyninst::x86_64::irbp: return 6;
1606             case Dyninst::x86_64::irsp: return 7;
1607             case Dyninst::x86_64::ir8: return 8;
1608             case Dyninst::x86_64::ir9: return 9;
1609             case Dyninst::x86_64::ir10: return 10;
1610             case Dyninst::x86_64::ir11: return 11;
1611             case Dyninst::x86_64::ir12: return 12;
1612             case Dyninst::x86_64::ir13: return 13;
1613             case Dyninst::x86_64::ir14: return 14;
1614             case Dyninst::x86_64::ir15: return 15;
1615             case Dyninst::x86_64::irip: return 16;
1616             case Dyninst::x86_64::ik0: return 17;
1617             case Dyninst::x86_64::ik1: return 18;
1618             case Dyninst::x86_64::ik2: return 19;
1619             case Dyninst::x86_64::ik3: return 20;
1620             case Dyninst::x86_64::ik4: return 21;
1621             case Dyninst::x86_64::ik5: return 22;
1622             case Dyninst::x86_64::ik6: return 23;
1623             case Dyninst::x86_64::ik7: return 24;
1624             case Dyninst::x86_64::izmm0: return 25;
1625             case Dyninst::x86_64::izmm1: return 26;
1626             case Dyninst::x86_64::izmm2: return 27;
1627             case Dyninst::x86_64::izmm3: return 28;
1628             case Dyninst::x86_64::izmm4: return 29;
1629             case Dyninst::x86_64::izmm5: return 30;
1630             case Dyninst::x86_64::izmm6: return 31;
1631             case Dyninst::x86_64::izmm7: return 32;
1632             case Dyninst::x86_64::izmm8: return 33;
1633             case Dyninst::x86_64::izmm9: return 34;
1634             case Dyninst::x86_64::izmm10: return 35;
1635             case Dyninst::x86_64::izmm11: return 36;
1636             case Dyninst::x86_64::izmm12: return 37;
1637             case Dyninst::x86_64::izmm13: return 38;
1638             case Dyninst::x86_64::izmm14: return 39;
1639             case Dyninst::x86_64::izmm15: return 40;
1640             case Dyninst::x86_64::izmm16: return 41;
1641             case Dyninst::x86_64::izmm17: return 42;
1642             case Dyninst::x86_64::izmm18: return 43;
1643             case Dyninst::x86_64::izmm19: return 44;
1644             case Dyninst::x86_64::izmm20: return 45;
1645             case Dyninst::x86_64::izmm21: return 46;
1646             case Dyninst::x86_64::izmm22: return 47;
1647             case Dyninst::x86_64::izmm23: return 48;
1648             case Dyninst::x86_64::izmm24: return 49;
1649             case Dyninst::x86_64::izmm25: return 50;
1650             case Dyninst::x86_64::izmm26: return 51;
1651             case Dyninst::x86_64::izmm27: return 52;
1652             case Dyninst::x86_64::izmm28: return 53;
1653             case Dyninst::x86_64::izmm29: return 54;
1654             case Dyninst::x86_64::izmm30: return 55;
1655             case Dyninst::x86_64::izmm31: return 56;
1656             case Dyninst::x86_64::iymm0: return 57;
1657             case Dyninst::x86_64::iymm1: return 58;
1658             case Dyninst::x86_64::iymm2: return 59;
1659             case Dyninst::x86_64::iymm3: return 60;
1660             case Dyninst::x86_64::iymm4: return 61;
1661             case Dyninst::x86_64::iymm5: return 62;
1662             case Dyninst::x86_64::iymm6: return 63;
1663             case Dyninst::x86_64::iymm7: return 64;
1664             case Dyninst::x86_64::iymm8: return 65;
1665             case Dyninst::x86_64::iymm9: return 66;
1666             case Dyninst::x86_64::iymm10: return 67;
1667             case Dyninst::x86_64::iymm11: return 68;
1668             case Dyninst::x86_64::iymm12: return 69;
1669             case Dyninst::x86_64::iymm13: return 70;
1670             case Dyninst::x86_64::iymm14: return 71;
1671             case Dyninst::x86_64::iymm15: return 72;
1672             case Dyninst::x86_64::iymm16: return 73;
1673             case Dyninst::x86_64::iymm17: return 74;
1674             case Dyninst::x86_64::iymm18: return 75;
1675             case Dyninst::x86_64::iymm19: return 76;
1676             case Dyninst::x86_64::iymm20: return 77;
1677             case Dyninst::x86_64::iymm21: return 78;
1678             case Dyninst::x86_64::iymm22: return 79;
1679             case Dyninst::x86_64::iymm23: return 80;
1680             case Dyninst::x86_64::iymm24: return 81;
1681             case Dyninst::x86_64::iymm25: return 82;
1682             case Dyninst::x86_64::iymm26: return 83;
1683             case Dyninst::x86_64::iymm27: return 84;
1684             case Dyninst::x86_64::iymm28: return 85;
1685             case Dyninst::x86_64::iymm29: return 86;
1686             case Dyninst::x86_64::iymm30: return 87;
1687             case Dyninst::x86_64::iymm31: return 88;
1688             case Dyninst::x86_64::ixmm0: return 89;
1689             case Dyninst::x86_64::ixmm1: return 90;
1690             case Dyninst::x86_64::ixmm2: return 91;
1691             case Dyninst::x86_64::ixmm3: return 92;
1692             case Dyninst::x86_64::ixmm4: return 93;
1693             case Dyninst::x86_64::ixmm5: return 94;
1694             case Dyninst::x86_64::ixmm6: return 95;
1695             case Dyninst::x86_64::ixmm7: return 96;
1696             case Dyninst::x86_64::ixmm8: return 97;
1697             case Dyninst::x86_64::ixmm9: return 98;
1698             case Dyninst::x86_64::ixmm10: return 99;
1699             case Dyninst::x86_64::ixmm11: return 100;
1700             case Dyninst::x86_64::ixmm12: return 101;
1701             case Dyninst::x86_64::ixmm13: return 102;
1702             case Dyninst::x86_64::ixmm14: return 103;
1703             case Dyninst::x86_64::ixmm15: return 104;
1704             case Dyninst::x86_64::ixmm16: return 105;
1705             case Dyninst::x86_64::ixmm17: return 106;
1706             case Dyninst::x86_64::ixmm18: return 107;
1707             case Dyninst::x86_64::ixmm19: return 108;
1708             case Dyninst::x86_64::ixmm20: return 109;
1709             case Dyninst::x86_64::ixmm21: return 110;
1710             case Dyninst::x86_64::ixmm22: return 111;
1711             case Dyninst::x86_64::ixmm23: return 112;
1712             case Dyninst::x86_64::ixmm24: return 113;
1713             case Dyninst::x86_64::ixmm25: return 114;
1714             case Dyninst::x86_64::ixmm26: return 115;
1715             case Dyninst::x86_64::ixmm27: return 116;
1716             case Dyninst::x86_64::ixmm28: return 117;
1717             case Dyninst::x86_64::ixmm29: return 118;
1718             case Dyninst::x86_64::ixmm30: return 119;
1719             case Dyninst::x86_64::ixmm31: return 120;
1720             //case Dyninst::x86_64::ist0: return 121;
1721             //case Dyninst::x86_64::ist1: return 122;
1722             //case Dyninst::x86_64::ist2: return 123;
1723             //case Dyninst::x86_64::ist3: return 124;
1724             //case Dyninst::x86_64::ist4: return 125;
1725             //case Dyninst::x86_64::ist5: return 126;
1726             //case Dyninst::x86_64::ist6: return 127;
1727             //case Dyninst::x86_64::ist7: return 128;
1728             case Dyninst::x86_64::imm0: return 129;
1729             case Dyninst::x86_64::imm1: return 130;
1730             case Dyninst::x86_64::imm2: return 131;
1731             case Dyninst::x86_64::imm3: return 132;
1732             case Dyninst::x86_64::imm4: return 133;
1733             case Dyninst::x86_64::imm5: return 134;
1734             case Dyninst::x86_64::imm6: return 135;
1735             case Dyninst::x86_64::imm7: return 136;
1736             case Dyninst::x86_64::iflags: return 137;
1737             case Dyninst::x86_64::ies: return 138;
1738             case Dyninst::x86_64::ics: return 139;
1739             case Dyninst::x86_64::iss: return 140;
1740             case Dyninst::x86_64::ids: return 141;
1741             case Dyninst::x86_64::ifs: return 142;
1742             case Dyninst::x86_64::igs: return 143;
1743             // INVALID REG 144
1744             // INVALID REG 145
1745             case Dyninst::x86_64::ifsbase: return 146;
1746             case Dyninst::x86_64::igsbase: return 147;
1747             default: return -1;
1748          }
1749          break;
1750       case Arch_ppc32:
1751          switch (val()) {
1752             case Dyninst::ppc32::ir0: return 0;
1753             case Dyninst::ppc32::ir1: return 1;
1754             case Dyninst::ppc32::ir2: return 2;
1755             case Dyninst::ppc32::ir3: return 3;
1756             case Dyninst::ppc32::ir4: return 4;
1757             case Dyninst::ppc32::ir5: return 5;
1758             case Dyninst::ppc32::ir6: return 6;
1759             case Dyninst::ppc32::ir7: return 7;
1760             case Dyninst::ppc32::ir8: return 8;
1761             case Dyninst::ppc32::ir9: return 9;
1762             case Dyninst::ppc32::ir10: return 10;
1763             case Dyninst::ppc32::ir11: return 11;
1764             case Dyninst::ppc32::ir12: return 12;
1765             case Dyninst::ppc32::ir13: return 13;
1766             case Dyninst::ppc32::ir14: return 14;
1767             case Dyninst::ppc32::ir15: return 15;
1768             case Dyninst::ppc32::ir16: return 16;
1769             case Dyninst::ppc32::ir17: return 17;
1770             case Dyninst::ppc32::ir18: return 18;
1771             case Dyninst::ppc32::ir19: return 19;
1772             case Dyninst::ppc32::ir20: return 20;
1773             case Dyninst::ppc32::ir21: return 21;
1774             case Dyninst::ppc32::ir22: return 22;
1775             case Dyninst::ppc32::ir23: return 23;
1776             case Dyninst::ppc32::ir24: return 24;
1777             case Dyninst::ppc32::ir25: return 25;
1778             case Dyninst::ppc32::ir26: return 26;
1779             case Dyninst::ppc32::ir27: return 27;
1780             case Dyninst::ppc32::ir28: return 28;
1781             case Dyninst::ppc32::ir29: return 29;
1782             case Dyninst::ppc32::ir30: return 30;
1783             case Dyninst::ppc32::ir31: return 31;
1784             case Dyninst::ppc32::ifpr0: return 32;
1785             case Dyninst::ppc32::ifpr1: return 33;
1786             case Dyninst::ppc32::ifpr2: return 34;
1787             case Dyninst::ppc32::ifpr3: return 35;
1788             case Dyninst::ppc32::ifpr4: return 36;
1789             case Dyninst::ppc32::ifpr5: return 37;
1790             case Dyninst::ppc32::ifpr6: return 38;
1791             case Dyninst::ppc32::ifpr7: return 39;
1792             case Dyninst::ppc32::ifpr8: return 40;
1793             case Dyninst::ppc32::ifpr9: return 41;
1794             case Dyninst::ppc32::ifpr10: return 42;
1795             case Dyninst::ppc32::ifpr11: return 43;
1796             case Dyninst::ppc32::ifpr12: return 44;
1797             case Dyninst::ppc32::ifpr13: return 45;
1798             case Dyninst::ppc32::ifpr14: return 46;
1799             case Dyninst::ppc32::ifpr15: return 47;
1800             case Dyninst::ppc32::ifpr16: return 48;
1801             case Dyninst::ppc32::ifpr17: return 49;
1802             case Dyninst::ppc32::ifpr18: return 50;
1803             case Dyninst::ppc32::ifpr19: return 51;
1804             case Dyninst::ppc32::ifpr20: return 52;
1805             case Dyninst::ppc32::ifpr21: return 53;
1806             case Dyninst::ppc32::ifpr22: return 54;
1807             case Dyninst::ppc32::ifpr23: return 55;
1808             case Dyninst::ppc32::ifpr24: return 56;
1809             case Dyninst::ppc32::ifpr25: return 57;
1810             case Dyninst::ppc32::ifpr26: return 58;
1811             case Dyninst::ppc32::ifpr27: return 59;
1812             case Dyninst::ppc32::ifpr28: return 60;
1813             case Dyninst::ppc32::ifpr29: return 61;
1814             case Dyninst::ppc32::ifpr30: return 62;
1815             case Dyninst::ppc32::ifpr31: return 63;
1816             case Dyninst::ppc32::icr: return 64;
1817             case Dyninst::ppc32::imq: return 100;
1818             case Dyninst::ppc32::ixer: return 101;
1819             case Dyninst::ppc32::ilr: return 108;
1820             case Dyninst::ppc32::ictr: return 109;
1821             default: return -1;
1822          }
1823       case Arch_ppc64:
1824          switch (val()) {
1825             case Dyninst::ppc64::ir0: return 0;
1826             case Dyninst::ppc64::ir1: return 1;
1827             case Dyninst::ppc64::ir2: return 2;
1828             case Dyninst::ppc64::ir3: return 3;
1829             case Dyninst::ppc64::ir4: return 4;
1830             case Dyninst::ppc64::ir5: return 5;
1831             case Dyninst::ppc64::ir6: return 6;
1832             case Dyninst::ppc64::ir7: return 7;
1833             case Dyninst::ppc64::ir8: return 8;
1834             case Dyninst::ppc64::ir9: return 9;
1835             case Dyninst::ppc64::ir10: return 10;
1836             case Dyninst::ppc64::ir11: return 11;
1837             case Dyninst::ppc64::ir12: return 12;
1838             case Dyninst::ppc64::ir13: return 13;
1839             case Dyninst::ppc64::ir14: return 14;
1840             case Dyninst::ppc64::ir15: return 15;
1841             case Dyninst::ppc64::ir16: return 16;
1842             case Dyninst::ppc64::ir17: return 17;
1843             case Dyninst::ppc64::ir18: return 18;
1844             case Dyninst::ppc64::ir19: return 19;
1845             case Dyninst::ppc64::ir20: return 20;
1846             case Dyninst::ppc64::ir21: return 21;
1847             case Dyninst::ppc64::ir22: return 22;
1848             case Dyninst::ppc64::ir23: return 23;
1849             case Dyninst::ppc64::ir24: return 24;
1850             case Dyninst::ppc64::ir25: return 25;
1851             case Dyninst::ppc64::ir26: return 26;
1852             case Dyninst::ppc64::ir27: return 27;
1853             case Dyninst::ppc64::ir28: return 28;
1854             case Dyninst::ppc64::ir29: return 29;
1855             case Dyninst::ppc64::ir30: return 30;
1856             case Dyninst::ppc64::ir31: return 31;
1857             case Dyninst::ppc64::ifpr0: return 32;
1858             case Dyninst::ppc64::ifpr1: return 33;
1859             case Dyninst::ppc64::ifpr2: return 34;
1860             case Dyninst::ppc64::ifpr3: return 35;
1861             case Dyninst::ppc64::ifpr4: return 36;
1862             case Dyninst::ppc64::ifpr5: return 37;
1863             case Dyninst::ppc64::ifpr6: return 38;
1864             case Dyninst::ppc64::ifpr7: return 39;
1865             case Dyninst::ppc64::ifpr8: return 40;
1866             case Dyninst::ppc64::ifpr9: return 41;
1867             case Dyninst::ppc64::ifpr10: return 42;
1868             case Dyninst::ppc64::ifpr11: return 43;
1869             case Dyninst::ppc64::ifpr12: return 44;
1870             case Dyninst::ppc64::ifpr13: return 45;
1871             case Dyninst::ppc64::ifpr14: return 46;
1872             case Dyninst::ppc64::ifpr15: return 47;
1873             case Dyninst::ppc64::ifpr16: return 48;
1874             case Dyninst::ppc64::ifpr17: return 49;
1875             case Dyninst::ppc64::ifpr18: return 50;
1876             case Dyninst::ppc64::ifpr19: return 51;
1877             case Dyninst::ppc64::ifpr20: return 52;
1878             case Dyninst::ppc64::ifpr21: return 53;
1879             case Dyninst::ppc64::ifpr22: return 54;
1880             case Dyninst::ppc64::ifpr23: return 55;
1881             case Dyninst::ppc64::ifpr24: return 56;
1882             case Dyninst::ppc64::ifpr25: return 57;
1883             case Dyninst::ppc64::ifpr26: return 58;
1884             case Dyninst::ppc64::ifpr27: return 59;
1885             case Dyninst::ppc64::ifpr28: return 60;
1886             case Dyninst::ppc64::ifpr29: return 61;
1887             case Dyninst::ppc64::ifpr30: return 62;
1888             case Dyninst::ppc64::ifpr31: return 63;
1889             case Dyninst::ppc64::icr: return 64;
1890             case Dyninst::ppc64::imq: return 100;
1891             case Dyninst::ppc64::ixer: return 101;
1892             case Dyninst::ppc64::ilr: return 108;
1893             case Dyninst::ppc64::ictr: return 109;
1894             default: return -1;
1895          }
1896          break;
1897       case Arch_aarch64:
1898          switch (val()) {
1899             case Dyninst::aarch64::ix0:             return 0;
1900             case Dyninst::aarch64::ix1:             return 1;
1901             case Dyninst::aarch64::ix2:             return 2;
1902             case Dyninst::aarch64::ix3:             return 3;
1903             case Dyninst::aarch64::ix4:             return 4;
1904             case Dyninst::aarch64::ix5:             return 5;
1905             case Dyninst::aarch64::ix6:             return 6;
1906             case Dyninst::aarch64::ix7:             return 7;
1907             case Dyninst::aarch64::ix8:             return 8;
1908             case Dyninst::aarch64::ix9:             return 9;
1909             case Dyninst::aarch64::ix10:        return 10;
1910             case Dyninst::aarch64::ix11:        return 11;
1911             case Dyninst::aarch64::ix12:        return 12;
1912             case Dyninst::aarch64::ix13:        return 13;
1913             case Dyninst::aarch64::ix14:        return 14;
1914             case Dyninst::aarch64::ix15:        return 15;
1915             case Dyninst::aarch64::ix16:        return 16;
1916             case Dyninst::aarch64::ix17:        return 17;
1917             case Dyninst::aarch64::ix18:        return 18;
1918             case Dyninst::aarch64::ix19:        return 19;
1919             case Dyninst::aarch64::ix20:        return 20;
1920             case Dyninst::aarch64::ix21:        return 21;
1921             case Dyninst::aarch64::ix22:        return 22;
1922             case Dyninst::aarch64::ix23:        return 23;
1923             case Dyninst::aarch64::ix24:        return 24;
1924             case Dyninst::aarch64::ix25:        return 25;
1925             case Dyninst::aarch64::ix26:        return 26;
1926             case Dyninst::aarch64::ix27:        return 27;
1927             case Dyninst::aarch64::ix28:        return 28;
1928             case Dyninst::aarch64::ix29:        return 29;
1929             case Dyninst::aarch64::ix30:        return 30;
1930             case Dyninst::aarch64::isp:      return 31;
1931
1932             case Dyninst::aarch64::iq0:      return 64;
1933             case Dyninst::aarch64::iq1:      return 65;
1934             case Dyninst::aarch64::iq2:      return 66;
1935             case Dyninst::aarch64::iq3:      return 67;
1936             case Dyninst::aarch64::iq4:      return 68;
1937             case Dyninst::aarch64::iq5:      return 69;
1938             case Dyninst::aarch64::iq6:      return 70;
1939             case Dyninst::aarch64::iq7:      return 71;
1940             case Dyninst::aarch64::iq8:      return 72;
1941             case Dyninst::aarch64::iq9:      return 73;
1942             case Dyninst::aarch64::iq10:     return 74;
1943             case Dyninst::aarch64::iq11:     return 75;
1944             case Dyninst::aarch64::iq12:     return 76;
1945             case Dyninst::aarch64::iq13:     return 77;
1946             case Dyninst::aarch64::iq14:     return 78;
1947             case Dyninst::aarch64::iq15:     return 79;
1948             case Dyninst::aarch64::iq16:     return 80;
1949             case Dyninst::aarch64::iq17:     return 81;
1950             case Dyninst::aarch64::iq18:     return 82;
1951             case Dyninst::aarch64::iq19:     return 83;
1952             case Dyninst::aarch64::iq20:     return 84;
1953             case Dyninst::aarch64::iq21:     return 85;
1954             case Dyninst::aarch64::iq22:     return 86;
1955             case Dyninst::aarch64::iq23:     return 87;
1956             case Dyninst::aarch64::iq24:     return 88;
1957             case Dyninst::aarch64::iq25:     return 89;
1958             case Dyninst::aarch64::iq26:     return 90;
1959             case Dyninst::aarch64::iq27:     return 91;
1960             case Dyninst::aarch64::iq28:     return 92;
1961             case Dyninst::aarch64::iq29:     return 93;
1962             case Dyninst::aarch64::iq30:     return 94;
1963             case Dyninst::aarch64::iq31:     return 95;
1964
1965             default: return -1;
1966          }
1967          break;
1968       case Arch_none:
1969          assert(0);
1970          return -1;
1971       default:
1972         assert(0);
1973         return -1;
1974    }
1975    //Invalid register passed
1976    return -1;
1977 }
1978
1979 unsigned Dyninst::getArchAddressWidth(Dyninst::Architecture arch)
1980 {
1981    switch (arch) {
1982       case Arch_none:
1983          return 0;
1984       case Arch_x86:
1985       case Arch_ppc32:
1986          return 4;
1987       case Arch_x86_64:
1988       case Arch_ppc64:
1989       case Arch_aarch64:
1990       case Arch_cuda:
1991          return 8;
1992       default:
1993          assert(0);
1994          return InvalidReg;
1995    }
1996    return 0;
1997 }
1998
1999 MachRegister MachRegister::getArchReg(unsigned int regNum, Dyninst::Architecture arch){
2000     switch(arch){
2001       case Arch_aarch64:
2002          switch(regNum){
2003             case 0:  return Dyninst::aarch64::x0;
2004             case 1:  return Dyninst::aarch64::x1;
2005             case 2:  return Dyninst::aarch64::x2;
2006             case 3:  return Dyninst::aarch64::x3;
2007             case 4:  return Dyninst::aarch64::x4;
2008             case 5:  return Dyninst::aarch64::x5;
2009             case 6:  return Dyninst::aarch64::x6;
2010             case 7:  return Dyninst::aarch64::x7;
2011             case 8:  return Dyninst::aarch64::x8;
2012             case 9:  return Dyninst::aarch64::x9;
2013             case 10: return Dyninst::aarch64::x10;
2014             case 11: return Dyninst::aarch64::x11;
2015             case 12: return Dyninst::aarch64::x12;
2016             case 13: return Dyninst::aarch64::x13;
2017             case 14: return Dyninst::aarch64::x14;
2018             case 15: return Dyninst::aarch64::x15;
2019             case 16: return Dyninst::aarch64::x16;
2020             case 17: return Dyninst::aarch64::x17;
2021             case 18: return Dyninst::aarch64::x18;
2022             case 19: return Dyninst::aarch64::x19;
2023             case 20: return Dyninst::aarch64::x20;
2024             case 21: return Dyninst::aarch64::x21;
2025             case 22: return Dyninst::aarch64::x22;
2026             case 23: return Dyninst::aarch64::x23;
2027             case 24: return Dyninst::aarch64::x24;
2028             case 25: return Dyninst::aarch64::x25;
2029             case 26: return Dyninst::aarch64::x26;
2030             case 27: return Dyninst::aarch64::x27;
2031             case 28: return Dyninst::aarch64::x28;
2032             case 29: return Dyninst::aarch64::x29;
2033             case 30: return Dyninst::aarch64::x30;
2034
2035             case 100: return Dyninst::aarch64::sp;
2036             case 101: return Dyninst::aarch64::pc;
2037             case 102: return Dyninst::aarch64::pstate;
2038             case 103: return Dyninst::aarch64::xzr;
2039          }
2040       default:
2041          return InvalidReg;
2042     }
2043     return InvalidReg;
2044 }