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