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