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