modified: common/CMakeLists.txt
[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_aarch64:
88                                         //not verified
89                                         assert(0);
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                assert(0);
174          }
175       case Arch_ppc32: {
176          int reg_class = reg & 0x00ff0000;
177          if (reg_class == ppc32::FPR || reg_class == ppc32::FSR)
178             return 8;
179          return 4;
180       }
181       case Arch_ppc64:
182                         //aarch64: 64bit = 8*8bit
183                         case Arch_aarch64:
184          return 8;      
185       case Arch_none:
186          return 0;
187    }
188    return 0; //Unreachable, but disable warnings
189 }
190    
191 bool MachRegister::operator<(const MachRegister &a) const { 
192    return (reg < a.reg);
193 }
194  
195 bool MachRegister::operator==(const MachRegister &a) const { 
196    return (reg == a.reg);
197 }
198  
199 MachRegister::operator signed int() const {
200    return reg;
201 }
202
203 signed int MachRegister::val() const {
204    return reg;
205 }
206
207
208 MachRegister MachRegister::getPC(Dyninst::Architecture arch)
209 {
210    switch (arch)
211    {
212       case Arch_x86:
213          return x86::eip;
214       case Arch_x86_64:
215          return x86_64::rip;
216       case Arch_ppc32:
217          return ppc32::pc;
218       case Arch_ppc64:
219          return ppc64::pc;
220       case Arch_aarch64:
221                                         assert(0);
222                                         //aarch64: pc is not accessable
223          return aarch64::pc;
224       case Arch_none:
225          return InvalidReg;
226    }
227    return InvalidReg;
228 }
229
230 MachRegister MachRegister::getFramePointer(Dyninst::Architecture arch)
231 {
232    switch (arch)
233    {
234       case Arch_x86:
235          return x86::ebp;
236       case Arch_x86_64:
237          return x86_64::rbp;
238       case Arch_ppc32:
239          return ppc32::r1;
240       case Arch_ppc64:
241          return ppc64::r1;
242       case Arch_aarch64:
243                                 //aarch64: frame pointer is X29 by convention
244          return aarch64::x29;
245       case Arch_none:
246          return InvalidReg;
247    }
248    return InvalidReg;
249 }
250
251 MachRegister MachRegister::getStackPointer(Dyninst::Architecture arch)
252 {
253    switch (arch)
254    {
255       case Arch_x86:
256          return x86::esp;
257       case Arch_x86_64:
258          return x86_64::rsp;
259       case Arch_ppc32:
260          return ppc32::r1;
261       case Arch_ppc64:
262          return ppc64::r1;
263       case Arch_aarch64:
264                                         //aarch64: stack pointer is an independent register
265                                         assert(0);
266          return aarch64::x0;
267       case Arch_none:
268          return InvalidReg;
269    }
270    return InvalidReg;
271 }
272
273 MachRegister MachRegister::getSyscallNumberReg(Dyninst::Architecture arch)
274 {
275     switch (arch)
276     {
277         case Arch_x86:
278             return x86::eax;
279         case Arch_x86_64:
280             return x86_64::rax;
281         case Arch_ppc32:
282             return ppc32::r0;
283         case Arch_ppc64:
284             return ppc64::r0;
285         case Arch_aarch64:
286                                                 //aarch64: not verified
287                                                 assert(0);
288             return aarch64::x0;
289         case Arch_none:
290             return InvalidReg;
291     }
292     return InvalidReg;
293 }
294
295 MachRegister MachRegister::getSyscallNumberOReg(Dyninst::Architecture arch)
296 {
297     switch (arch)
298     {
299         case Arch_x86:
300             return x86::oeax;
301         case Arch_x86_64:
302             return x86_64::orax;
303         case Arch_ppc32: 
304             return ppc32::r0;
305         case Arch_ppc64:
306             return ppc64::r0;
307         case Arch_aarch64:
308                                                 //not verified
309                                                 assert(0);
310             return aarch64::x0;
311         case Arch_none:
312             return InvalidReg;
313     }
314     return InvalidReg;
315 }
316
317 MachRegister MachRegister::getSyscallReturnValueReg(Dyninst::Architecture arch)
318 {
319     switch (arch)
320     {
321         case Arch_x86:
322             return x86::eax;
323         case Arch_x86_64:
324             return x86_64::rax;
325         case Arch_ppc32: 
326             return ppc32::r3;
327         case Arch_ppc64:
328             return ppc64::r3;
329         case Arch_aarch64:
330                                                 //not verified
331                                                 assert(0);
332             return aarch64::x0;
333         case Arch_none:
334             return InvalidReg;
335     }
336     return InvalidReg;
337 }
338
339 bool MachRegister::isPC() const
340 {
341    return (*this == x86_64::rip || *this == x86::eip ||
342            *this == ppc32::pc || *this == ppc64::pc);
343 }
344
345 bool MachRegister::isFramePointer() const
346 {
347    return (*this == x86_64::rbp || *this == x86::ebp ||
348            *this == FrameBase);
349 }
350
351 bool MachRegister::isStackPointer() const
352 {
353    return (*this == x86_64::rsp || *this == x86::esp ||
354            *this == ppc32::r1 || *this == ppc64::r1);
355 }
356
357 bool MachRegister::isSyscallNumberReg() const
358 {
359     return (*this == x86_64::orax || *this == x86::oeax ||
360             *this == ppc32::r1 || *this == ppc64::r1);
361 }
362
363 bool MachRegister::isSyscallReturnValueReg() const
364 {
365     return (*this == x86_64::rax || *this == x86::eax ||
366             *this == ppc32::r1 || *this == ppc64::r1);
367 }
368
369 COMMON_EXPORT bool Dyninst::isSegmentRegister(int regClass)
370 {
371    return 0 != (regClass & x86::SEG);
372 }
373
374 void MachRegister::getROSERegister(int &c, int &n, int &p)
375 {
376    // Rose: class, number, position
377    // Dyninst: category, base id, subrange
378
379    signed int category = (reg & 0x00ff0000);
380    signed int subrange = (reg & 0x0000ff00);
381    signed int baseID =   (reg & 0x000000ff);
382
383    switch (getArchitecture()) {
384       case Arch_x86:
385       case Arch_x86_64: // 64-bit not supported in ROSE
386          switch (category) {
387             case x86::GPR:
388                c = x86_regclass_gpr;
389                switch (baseID) {
390                   case x86::BASEA:
391                      n = x86_gpr_ax;
392                      break;
393                   case x86::BASEC:
394                      n = x86_gpr_cx;
395                      break;
396                   case x86::BASED:
397                      n = x86_gpr_dx;
398                      break;
399                   case x86::BASEB:
400                      n = x86_gpr_bx;
401                      break;
402                   case x86::BASESP:
403                      n = x86_gpr_sp;
404                      break;
405                   case x86::BASEBP:
406                      n = x86_gpr_bp;
407                      break;
408                   case x86::BASESI:
409                      n = x86_gpr_si;
410                      break;
411                   case x86::BASEDI:
412                      n = x86_gpr_di;
413                      break;
414                   default:
415                      n = 0;
416                      break;
417                }
418                break;
419             case x86::SEG:
420                c = x86_regclass_segment;
421                switch (baseID) {
422                   case 0x0:
423                      n = x86_segreg_ds;
424                      break;
425                   case 0x1:
426                      n = x86_segreg_es;
427                      break;
428                   case 0x2:
429                      n = x86_segreg_fs;
430                      break;
431                   case 0x3:
432                      n = x86_segreg_gs;
433                      break;
434                   case 0x4:
435                      n = x86_segreg_cs;
436                      break;
437                   case 0x5:
438                      n = x86_segreg_ss;
439                      break;
440                   default:
441                      n = 0;
442                      break;
443                }
444                break;
445             case x86::FLAG:
446                c = x86_regclass_flags;
447                switch(baseID) {
448                case x86::CF:
449                  n = x86_flag_cf;
450                  break;
451                case x86::PF:
452                  n = x86_flag_pf;
453                  break;
454                case x86::AF:
455                  n = x86_flag_af;
456                  break;
457                case x86::ZF:
458                  n = x86_flag_zf;
459                  break;
460                case x86::SF:
461                  n = x86_flag_sf;
462                  break;
463                case x86::TF:
464                  n = x86_flag_tf;
465                  break;
466                case x86::IF:
467                  n = x86_flag_if;
468                  break;
469                case x86::DF:
470                  n = x86_flag_df;
471                  break;
472                case x86::OF:
473                  n = x86_flag_of;
474                  break;
475                default:
476                  assert(0);
477                  break;
478                }
479                break;
480             case x86::MISC:
481                c = x86_regclass_unknown;
482                break;
483             case x86::XMM:
484                c = x86_regclass_xmm;
485                n = baseID;
486                break;
487             case x86::MMX:
488                c = x86_regclass_mm;
489                n = baseID;
490                break;
491             case x86::CTL:
492                c = x86_regclass_cr;
493                n = baseID;
494                break;
495             case x86::DBG:
496                c = x86_regclass_dr;
497                n = baseID;
498                break;
499             case x86::TST:
500                c = x86_regclass_unknown;
501                break;
502             case 0:
503                switch (baseID) {
504                   case 0x10:
505                      c = x86_regclass_ip;
506                      n = 0;
507                      break;
508                   default:
509                      c = x86_regclass_unknown;
510                      break;
511                }
512                break;
513          }
514          break;
515        case Arch_ppc32:
516        case Arch_ppc64: // 64-bit not supported in ROSE
517        {
518          baseID = reg & 0x0000FFFF;
519            n = baseID;
520            switch(category)
521            {
522                case ppc32::GPR:
523                    c = powerpc_regclass_gpr;
524                    break;
525                case ppc32::FPR:
526                case ppc32::FSR:
527                    c = powerpc_regclass_fpr;
528                    break;
529                case ppc32::SPR:
530                {
531                    if(baseID < 613) {
532                        c = powerpc_regclass_spr;
533                    } else if(baseID < 621 ) {
534                        c = powerpc_regclass_sr; 
535                    } else {
536                        c = powerpc_regclass_cr;
537                        n = baseID - 621;
538                        if(n > 7) {
539                          n = 0;
540                          p = powerpc_condreggranularity_whole;
541                        } else {
542                          p = powerpc_condreggranularity_field;
543                        }
544
545                    }
546                }
547                break;
548                default:
549                    assert(!"unknown register type!");
550                    break;
551            }
552            return;
553        }
554        default:
555          c = x86_regclass_unknown;
556          n = 0;
557          break;
558    }
559
560    switch (getArchitecture()) {
561       case Arch_x86:
562       case Arch_x86_64:
563          switch (subrange) {
564             case x86::FULL:
565             case x86::OCT:
566             case x86::FPDBL:
567                p = x86_regpos_all;
568                break;
569             case x86::H_REG:
570                p = x86_regpos_high_byte;
571                break;
572             case x86::L_REG:
573                p = x86_regpos_low_byte;
574                break;
575             case x86::W_REG:
576                p = x86_regpos_word;
577                break;
578             case x86_64::D_REG:
579                p = x86_regpos_dword;
580                break;
581             case x86::BIT:
582                p = x86_regpos_all;
583                break;
584          }
585          break;
586       default:
587         p = x86_regpos_unknown;
588    }
589 }
590
591 MachRegister MachRegister::DwarfEncToReg(int encoding, Dyninst::Architecture arch)
592 {
593    switch (arch)
594    {
595       case Arch_x86:
596          switch (encoding) {
597             case 0: return Dyninst::x86::eax;
598             case 1: return Dyninst::x86::ecx;
599             case 2: return Dyninst::x86::edx;
600             case 3: return Dyninst::x86::ebx;
601             case 4: return Dyninst::x86::esp;
602             case 5: return Dyninst::x86::ebp;
603             case 6: return Dyninst::x86::esi;
604             case 7: return Dyninst::x86::edi;
605             case 8: return Dyninst::x86::eip;
606             case 9: return Dyninst::x86::flags;
607             case 10: return Dyninst::InvalidReg;
608             case 11: return Dyninst::x86::st0;
609             case 12: return Dyninst::x86::st1;
610             case 13: return Dyninst::x86::st2;
611             case 14: return Dyninst::x86::st3;
612             case 15: return Dyninst::x86::st4;
613             case 16: return Dyninst::x86::st5;
614             case 17: return Dyninst::x86::st6;
615             case 18: return Dyninst::x86::st7;
616             case 19: return Dyninst::InvalidReg;
617             case 20: return Dyninst::InvalidReg;
618             case 21: return Dyninst::x86::xmm0;
619             case 22: return Dyninst::x86::xmm1;
620             case 23: return Dyninst::x86::xmm2;
621             case 24: return Dyninst::x86::xmm3;
622             case 25: return Dyninst::x86::xmm4;
623             case 26: return Dyninst::x86::xmm5;
624             case 27: return Dyninst::x86::xmm6;
625             case 28: return Dyninst::x86::xmm7;
626             case 29: return Dyninst::x86::mm0;
627             case 30: return Dyninst::x86::mm1;
628             case 31: return Dyninst::x86::mm2;
629             case 32: return Dyninst::x86::mm3;
630             case 33: return Dyninst::x86::mm4;
631             case 34: return Dyninst::x86::mm5;
632             case 35: return Dyninst::x86::mm6;
633             case 36: return Dyninst::x86::mm7;
634             case 37: return Dyninst::InvalidReg; //fcw
635             case 38: return Dyninst::InvalidReg; //fsw
636             case 39: return Dyninst::InvalidReg; //mxcsr
637             case 40: return Dyninst::x86::es;
638             case 41: return Dyninst::x86::cs;
639             case 42: return Dyninst::x86::ss;
640             case 43: return Dyninst::x86::ds;
641             case 44: return Dyninst::x86::fs;
642             case 45: return Dyninst::x86::gs;
643             case 46: return Dyninst::InvalidReg;
644             case 47: return Dyninst::InvalidReg;
645             case 48: return Dyninst::InvalidReg; //tr
646             case 49: return Dyninst::InvalidReg; //ldtr
647             default: return Dyninst::InvalidReg;
648          }
649          break;
650       case Arch_x86_64:
651          switch (encoding) {
652             case 0: return Dyninst::x86_64::rax;
653             case 1: return Dyninst::x86_64::rdx;
654             case 2: return Dyninst::x86_64::rcx;
655             case 3: return Dyninst::x86_64::rbx;
656             case 4: return Dyninst::x86_64::rsi;
657             case 5: return Dyninst::x86_64::rdi;
658             case 6: return Dyninst::x86_64::rbp;
659             case 7: return Dyninst::x86_64::rsp;
660             case 8: return Dyninst::x86_64::r8;
661             case 9: return Dyninst::x86_64::r9;
662             case 10: return Dyninst::x86_64::r10;
663             case 11: return Dyninst::x86_64::r11;
664             case 12: return Dyninst::x86_64::r12;
665             case 13: return Dyninst::x86_64::r13;
666             case 14: return Dyninst::x86_64::r14;
667             case 15: return Dyninst::x86_64::r15;
668             case 16: return Dyninst::x86_64::rip;
669             case 17: return Dyninst::x86_64::xmm0;
670             case 18: return Dyninst::x86_64::xmm1;
671             case 19: return Dyninst::x86_64::xmm2;
672             case 20: return Dyninst::x86_64::xmm3;
673             case 21: return Dyninst::x86_64::xmm4;
674             case 22: return Dyninst::x86_64::xmm5;
675             case 23: return Dyninst::x86_64::xmm6;
676             case 24: return Dyninst::x86_64::xmm7;
677             case 25: return Dyninst::x86_64::xmm8;
678             case 26: return Dyninst::x86_64::xmm9;
679             case 27: return Dyninst::x86_64::xmm10;
680             case 28: return Dyninst::x86_64::xmm11;
681             case 29: return Dyninst::x86_64::xmm12;
682             case 30: return Dyninst::x86_64::xmm13;
683             case 31: return Dyninst::x86_64::xmm14;
684             case 32: return Dyninst::x86_64::xmm15;
685             case 33: return Dyninst::x86_64::st0;
686             case 34: return Dyninst::x86_64::st1;
687             case 35: return Dyninst::x86_64::st2;
688             case 36: return Dyninst::x86_64::st3;
689             case 37: return Dyninst::x86_64::st4;
690             case 38: return Dyninst::x86_64::st5;
691             case 39: return Dyninst::x86_64::st6;
692             case 40: return Dyninst::x86_64::st7;
693             case 41: return Dyninst::x86_64::mm0;
694             case 42: return Dyninst::x86_64::mm1;
695             case 43: return Dyninst::x86_64::mm2;
696             case 44: return Dyninst::x86_64::mm3;
697             case 45: return Dyninst::x86_64::mm4;
698             case 46: return Dyninst::x86_64::mm5;
699             case 47: return Dyninst::x86_64::mm6;
700             case 48: return Dyninst::x86_64::mm7;
701             case 49: return Dyninst::x86_64::flags;
702             case 50: return Dyninst::x86_64::es;
703             case 51: return Dyninst::x86_64::cs;
704             case 52: return Dyninst::x86_64::ss;
705             case 53: return Dyninst::x86_64::ds;
706             case 54: return Dyninst::x86_64::fs;
707             case 55: return Dyninst::x86_64::gs;
708             case 56: return Dyninst::InvalidReg;
709             case 57: return Dyninst::InvalidReg;
710             case 58: return Dyninst::x86_64::fsbase;
711             case 59: return Dyninst::x86_64::gsbase;
712             case 60: return Dyninst::InvalidReg; 
713             case 61: return Dyninst::InvalidReg; 
714             case 62: return Dyninst::InvalidReg; //tr
715             case 63: return Dyninst::InvalidReg; //ldtr
716             case 64: return Dyninst::InvalidReg; //mxcsr
717             case 65: return Dyninst::InvalidReg; //fcw
718             case 66: return Dyninst::InvalidReg; //fsw
719          }
720          break;
721       case Arch_ppc32:
722          switch (encoding) {
723             case 0: return Dyninst::ppc32::r0;
724             case 1: return Dyninst::ppc32::r1;
725             case 2: return Dyninst::ppc32::r2;
726             case 3: return Dyninst::ppc32::r3;
727             case 4: return Dyninst::ppc32::r4;
728             case 5: return Dyninst::ppc32::r5;
729             case 6: return Dyninst::ppc32::r6;
730             case 7: return Dyninst::ppc32::r7;
731             case 8: return Dyninst::ppc32::r8;
732             case 9: return Dyninst::ppc32::r9;
733             case 10: return Dyninst::ppc32::r10;
734             case 11: return Dyninst::ppc32::r11;
735             case 12: return Dyninst::ppc32::r12;
736             case 13: return Dyninst::ppc32::r13;
737             case 14: return Dyninst::ppc32::r14;
738             case 15: return Dyninst::ppc32::r15;
739             case 16: return Dyninst::ppc32::r16;
740             case 17: return Dyninst::ppc32::r17;
741             case 18: return Dyninst::ppc32::r18;
742             case 19: return Dyninst::ppc32::r19;
743             case 20: return Dyninst::ppc32::r20;
744             case 21: return Dyninst::ppc32::r21;
745             case 22: return Dyninst::ppc32::r22;
746             case 23: return Dyninst::ppc32::r23;
747             case 24: return Dyninst::ppc32::r24;
748             case 25: return Dyninst::ppc32::r25;
749             case 26: return Dyninst::ppc32::r26;
750             case 27: return Dyninst::ppc32::r27;
751             case 28: return Dyninst::ppc32::r28;
752             case 29: return Dyninst::ppc32::r29;
753             case 30: return Dyninst::ppc32::r30;
754             case 31: return Dyninst::ppc32::r31;
755             case 32: return Dyninst::ppc32::fpr0;
756             case 33: return Dyninst::ppc32::fpr1;
757             case 34: return Dyninst::ppc32::fpr2;
758             case 35: return Dyninst::ppc32::fpr3;
759             case 36: return Dyninst::ppc32::fpr4;
760             case 37: return Dyninst::ppc32::fpr5;
761             case 38: return Dyninst::ppc32::fpr6;
762             case 39: return Dyninst::ppc32::fpr7;
763             case 40: return Dyninst::ppc32::fpr8;
764             case 41: return Dyninst::ppc32::fpr9;
765             case 42: return Dyninst::ppc32::fpr10;
766             case 43: return Dyninst::ppc32::fpr11;
767             case 44: return Dyninst::ppc32::fpr12;
768             case 45: return Dyninst::ppc32::fpr13;
769             case 46: return Dyninst::ppc32::fpr14;
770             case 47: return Dyninst::ppc32::fpr15;
771             case 48: return Dyninst::ppc32::fpr16;
772             case 49: return Dyninst::ppc32::fpr17;
773             case 50: return Dyninst::ppc32::fpr18;
774             case 51: return Dyninst::ppc32::fpr19;
775             case 52: return Dyninst::ppc32::fpr20;
776             case 53: return Dyninst::ppc32::fpr21;
777             case 54: return Dyninst::ppc32::fpr22;
778             case 55: return Dyninst::ppc32::fpr23;
779             case 56: return Dyninst::ppc32::fpr24;
780             case 57: return Dyninst::ppc32::fpr25;
781             case 58: return Dyninst::ppc32::fpr26;
782             case 59: return Dyninst::ppc32::fpr27;
783             case 60: return Dyninst::ppc32::fpr28;
784             case 61: return Dyninst::ppc32::fpr29;
785             case 62: return Dyninst::ppc32::fpr30;
786             case 63: return Dyninst::ppc32::fpr31;
787             case 64: return Dyninst::ppc32::cr;
788             case 65: return Dyninst::InvalidReg; //FPSCR
789          }
790          //Seperate switch statements to give compilers an easier time of 
791          // optimizing
792          switch (encoding) {
793             case 100: return Dyninst::ppc32::mq;
794             case 101: return Dyninst::ppc32::xer;
795             case 102: return Dyninst::InvalidReg;
796             case 103: return Dyninst::InvalidReg;
797             case 104: return Dyninst::InvalidReg; //RTCU
798             case 105: return Dyninst::InvalidReg; //RTCL
799             case 106: return Dyninst::InvalidReg;
800             case 107: return Dyninst::InvalidReg;
801             case 108: return Dyninst::ppc32::lr;
802             case 109: return Dyninst::ppc32::ctr;
803             default: return Dyninst::InvalidReg;
804          }
805          break;
806       case Arch_ppc64:
807          switch (encoding) {
808             case 0: return Dyninst::ppc64::r0;
809             case 1: return Dyninst::ppc64::r1;
810             case 2: return Dyninst::ppc64::r2;
811             case 3: return Dyninst::ppc64::r3;
812             case 4: return Dyninst::ppc64::r4;
813             case 5: return Dyninst::ppc64::r5;
814             case 6: return Dyninst::ppc64::r6;
815             case 7: return Dyninst::ppc64::r7;
816             case 8: return Dyninst::ppc64::r8;
817             case 9: return Dyninst::ppc64::r9;
818             case 10: return Dyninst::ppc64::r10;
819             case 11: return Dyninst::ppc64::r11;
820             case 12: return Dyninst::ppc64::r12;
821             case 13: return Dyninst::ppc64::r13;
822             case 14: return Dyninst::ppc64::r14;
823             case 15: return Dyninst::ppc64::r15;
824             case 16: return Dyninst::ppc64::r16;
825             case 17: return Dyninst::ppc64::r17;
826             case 18: return Dyninst::ppc64::r18;
827             case 19: return Dyninst::ppc64::r19;
828             case 20: return Dyninst::ppc64::r20;
829             case 21: return Dyninst::ppc64::r21;
830             case 22: return Dyninst::ppc64::r22;
831             case 23: return Dyninst::ppc64::r23;
832             case 24: return Dyninst::ppc64::r24;
833             case 25: return Dyninst::ppc64::r25;
834             case 26: return Dyninst::ppc64::r26;
835             case 27: return Dyninst::ppc64::r27;
836             case 28: return Dyninst::ppc64::r28;
837             case 29: return Dyninst::ppc64::r29;
838             case 30: return Dyninst::ppc64::r30;
839             case 31: return Dyninst::ppc64::r31;
840             case 32: return Dyninst::ppc64::fpr0;
841             case 33: return Dyninst::ppc64::fpr1;
842             case 34: return Dyninst::ppc64::fpr2;
843             case 35: return Dyninst::ppc64::fpr3;
844             case 36: return Dyninst::ppc64::fpr4;
845             case 37: return Dyninst::ppc64::fpr5;
846             case 38: return Dyninst::ppc64::fpr6;
847             case 39: return Dyninst::ppc64::fpr7;
848             case 40: return Dyninst::ppc64::fpr8;
849             case 41: return Dyninst::ppc64::fpr9;
850             case 42: return Dyninst::ppc64::fpr10;
851             case 43: return Dyninst::ppc64::fpr11;
852             case 44: return Dyninst::ppc64::fpr12;
853             case 45: return Dyninst::ppc64::fpr13;
854             case 46: return Dyninst::ppc64::fpr14;
855             case 47: return Dyninst::ppc64::fpr15;
856             case 48: return Dyninst::ppc64::fpr16;
857             case 49: return Dyninst::ppc64::fpr17;
858             case 50: return Dyninst::ppc64::fpr18;
859             case 51: return Dyninst::ppc64::fpr19;
860             case 52: return Dyninst::ppc64::fpr20;
861             case 53: return Dyninst::ppc64::fpr21;
862             case 54: return Dyninst::ppc64::fpr22;
863             case 55: return Dyninst::ppc64::fpr23;
864             case 56: return Dyninst::ppc64::fpr24;
865             case 57: return Dyninst::ppc64::fpr25;
866             case 58: return Dyninst::ppc64::fpr26;
867             case 59: return Dyninst::ppc64::fpr27;
868             case 60: return Dyninst::ppc64::fpr28;
869             case 61: return Dyninst::ppc64::fpr29;
870             case 62: return Dyninst::ppc64::fpr30;
871             case 63: return Dyninst::ppc64::fpr31;
872             case 64: return Dyninst::ppc64::cr;
873             case 65: return Dyninst::InvalidReg; //FPSCR
874          }
875          //Seperate switch statements to give compilers an easier time of 
876          // optimizing
877          switch (encoding) {
878             case 100: return Dyninst::ppc64::mq;
879             case 101: return Dyninst::ppc64::xer;
880             case 102: return Dyninst::InvalidReg;
881             case 103: return Dyninst::InvalidReg;
882             case 104: return Dyninst::InvalidReg; //RTCU
883             case 105: return Dyninst::InvalidReg; //RTCL
884             case 106: return Dyninst::InvalidReg;
885             case 107: return Dyninst::InvalidReg;
886             case 108: return Dyninst::ppc64::lr;
887             case 109: return Dyninst::ppc64::ctr;
888             default: return Dyninst::InvalidReg;
889          }
890          break;
891       case Arch_none:
892          return Dyninst::InvalidReg;
893          break;
894    }
895    //Invalid Architecture passed
896    return Dyninst::InvalidReg;
897
898 }
899
900 int MachRegister::getDwarfEnc() const
901 {
902    switch (getArchitecture())
903    {
904       case Arch_x86:
905          switch (val()) {
906             case Dyninst::x86::ieax: return 0;
907             case Dyninst::x86::iecx: return 1;
908             case Dyninst::x86::iedx: return 2;
909             case Dyninst::x86::iebx: return 3;
910             case Dyninst::x86::iesp: return 4;
911             case Dyninst::x86::iebp: return 5;
912             case Dyninst::x86::iesi: return 6;
913             case Dyninst::x86::iedi: return 7;
914             case Dyninst::x86::ieip: return 8;
915             case Dyninst::x86::iflags: return 9;
916             case Dyninst::x86::ixmm0: return 21;
917             case Dyninst::x86::ixmm1: return 22;
918             case Dyninst::x86::ixmm2: return 23;
919             case Dyninst::x86::ixmm3: return 24;
920             case Dyninst::x86::ixmm4: return 25;
921             case Dyninst::x86::ixmm5: return 26;
922             case Dyninst::x86::ixmm6: return 27;
923             case Dyninst::x86::ixmm7: return 28;
924             case Dyninst::x86::imm0: return 29;
925             case Dyninst::x86::imm1: return 30;
926             case Dyninst::x86::imm2: return 31;
927             case Dyninst::x86::imm3: return 32;
928             case Dyninst::x86::imm4: return 33;
929             case Dyninst::x86::imm5: return 34;
930             case Dyninst::x86::imm6: return 35;
931             case Dyninst::x86::imm7: return 36;
932             case Dyninst::x86::ies: return 40;
933             case Dyninst::x86::ics: return 41;
934             case Dyninst::x86::iss: return 42;
935             case Dyninst::x86::ids: return 43;
936             case Dyninst::x86::ifs: return 44;
937             case Dyninst::x86::igs: return 45;
938             default: return -1;
939          }
940          break;
941       case Arch_x86_64:
942          switch (val()) {
943             case Dyninst::x86_64::irax: return 0;
944             case Dyninst::x86_64::irdx: return 1;
945             case Dyninst::x86_64::ircx: return 2;
946             case Dyninst::x86_64::irbx: return 3;
947             case Dyninst::x86_64::irsi: return 4;
948             case Dyninst::x86_64::irdi: return 5;
949             case Dyninst::x86_64::irbp: return 6;
950             case Dyninst::x86_64::irsp: return 7;
951             case Dyninst::x86_64::ir8: return 8;
952             case Dyninst::x86_64::ir9: return 9;
953             case Dyninst::x86_64::ir10: return 10;
954             case Dyninst::x86_64::ir11: return 11;
955             case Dyninst::x86_64::ir12: return 12;
956             case Dyninst::x86_64::ir13: return 13;
957             case Dyninst::x86_64::ir14: return 14;
958             case Dyninst::x86_64::ir15: return 15;
959             case Dyninst::x86_64::irip: return 16;
960             case Dyninst::x86_64::ixmm0: return 17;
961             case Dyninst::x86_64::ixmm1: return 18;
962             case Dyninst::x86_64::ixmm2: return 19;
963             case Dyninst::x86_64::ixmm3: return 20;
964             case Dyninst::x86_64::ixmm4: return 21;
965             case Dyninst::x86_64::ixmm5: return 22;
966             case Dyninst::x86_64::ixmm6: return 23;
967             case Dyninst::x86_64::ixmm7: return 24;
968             case Dyninst::x86_64::ixmm8: return 25;
969             case Dyninst::x86_64::ixmm9: return 26;
970             case Dyninst::x86_64::ixmm10: return 27;
971             case Dyninst::x86_64::ixmm11: return 28;
972             case Dyninst::x86_64::ixmm12: return 29;
973             case Dyninst::x86_64::ixmm13: return 30;
974             case Dyninst::x86_64::ixmm14: return 31;
975             case Dyninst::x86_64::ixmm15: return 32;
976             case Dyninst::x86_64::imm0: return 41;
977             case Dyninst::x86_64::imm1: return 42;
978             case Dyninst::x86_64::imm2: return 43;
979             case Dyninst::x86_64::imm3: return 44;
980             case Dyninst::x86_64::imm4: return 45;
981             case Dyninst::x86_64::imm5: return 46;
982             case Dyninst::x86_64::imm6: return 47;
983             case Dyninst::x86_64::imm7: return 48;
984             case Dyninst::x86_64::iflags: return 49;
985             case Dyninst::x86_64::ies: return 50;
986             case Dyninst::x86_64::ics: return 51;
987             case Dyninst::x86_64::iss: return 52;
988             case Dyninst::x86_64::ids: return 53;
989             case Dyninst::x86_64::ifs: return 54;
990             case Dyninst::x86_64::igs: return 55;
991             case Dyninst::x86_64::ifsbase: return 58;
992             case Dyninst::x86_64::igsbase: return 59;
993             default: return -1;
994          }
995          break;
996       case Arch_ppc32:
997          switch (val()) {
998             case Dyninst::ppc32::ir0: return 0;
999             case Dyninst::ppc32::ir1: return 1;
1000             case Dyninst::ppc32::ir2: return 2;
1001             case Dyninst::ppc32::ir3: return 3;
1002             case Dyninst::ppc32::ir4: return 4;
1003             case Dyninst::ppc32::ir5: return 5;
1004             case Dyninst::ppc32::ir6: return 6;
1005             case Dyninst::ppc32::ir7: return 7;
1006             case Dyninst::ppc32::ir8: return 8;
1007             case Dyninst::ppc32::ir9: return 9;
1008             case Dyninst::ppc32::ir10: return 10;
1009             case Dyninst::ppc32::ir11: return 11;
1010             case Dyninst::ppc32::ir12: return 12;
1011             case Dyninst::ppc32::ir13: return 13;
1012             case Dyninst::ppc32::ir14: return 14;
1013             case Dyninst::ppc32::ir15: return 15;
1014             case Dyninst::ppc32::ir16: return 16;
1015             case Dyninst::ppc32::ir17: return 17;
1016             case Dyninst::ppc32::ir18: return 18;
1017             case Dyninst::ppc32::ir19: return 19;
1018             case Dyninst::ppc32::ir20: return 20;
1019             case Dyninst::ppc32::ir21: return 21;
1020             case Dyninst::ppc32::ir22: return 22;
1021             case Dyninst::ppc32::ir23: return 23;
1022             case Dyninst::ppc32::ir24: return 24;
1023             case Dyninst::ppc32::ir25: return 25;
1024             case Dyninst::ppc32::ir26: return 26;
1025             case Dyninst::ppc32::ir27: return 27;
1026             case Dyninst::ppc32::ir28: return 28;
1027             case Dyninst::ppc32::ir29: return 29;
1028             case Dyninst::ppc32::ir30: return 30;
1029             case Dyninst::ppc32::ir31: return 31;
1030             case Dyninst::ppc32::ifpr0: return 32;
1031             case Dyninst::ppc32::ifpr1: return 33;
1032             case Dyninst::ppc32::ifpr2: return 34;
1033             case Dyninst::ppc32::ifpr3: return 35;
1034             case Dyninst::ppc32::ifpr4: return 36;
1035             case Dyninst::ppc32::ifpr5: return 37;
1036             case Dyninst::ppc32::ifpr6: return 38;
1037             case Dyninst::ppc32::ifpr7: return 39;
1038             case Dyninst::ppc32::ifpr8: return 40;
1039             case Dyninst::ppc32::ifpr9: return 41;
1040             case Dyninst::ppc32::ifpr10: return 42;
1041             case Dyninst::ppc32::ifpr11: return 43;
1042             case Dyninst::ppc32::ifpr12: return 44;
1043             case Dyninst::ppc32::ifpr13: return 45;
1044             case Dyninst::ppc32::ifpr14: return 46;
1045             case Dyninst::ppc32::ifpr15: return 47;
1046             case Dyninst::ppc32::ifpr16: return 48;
1047             case Dyninst::ppc32::ifpr17: return 49;
1048             case Dyninst::ppc32::ifpr18: return 50;
1049             case Dyninst::ppc32::ifpr19: return 51;
1050             case Dyninst::ppc32::ifpr20: return 52;
1051             case Dyninst::ppc32::ifpr21: return 53;
1052             case Dyninst::ppc32::ifpr22: return 54;
1053             case Dyninst::ppc32::ifpr23: return 55;
1054             case Dyninst::ppc32::ifpr24: return 56;
1055             case Dyninst::ppc32::ifpr25: return 57;
1056             case Dyninst::ppc32::ifpr26: return 58;
1057             case Dyninst::ppc32::ifpr27: return 59;
1058             case Dyninst::ppc32::ifpr28: return 60;
1059             case Dyninst::ppc32::ifpr29: return 61;
1060             case Dyninst::ppc32::ifpr30: return 62;
1061             case Dyninst::ppc32::ifpr31: return 63;
1062             case Dyninst::ppc32::icr: return 64;
1063             case Dyninst::ppc32::imq: return 100;
1064             case Dyninst::ppc32::ixer: return 101;
1065             case Dyninst::ppc32::ilr: return 108;
1066             case Dyninst::ppc32::ictr: return 109;
1067             default: return -1;
1068          }
1069       case Arch_ppc64:
1070          switch (val()) {
1071             case Dyninst::ppc64::ir0: return 0;
1072             case Dyninst::ppc64::ir1: return 1;
1073             case Dyninst::ppc64::ir2: return 2;
1074             case Dyninst::ppc64::ir3: return 3;
1075             case Dyninst::ppc64::ir4: return 4;
1076             case Dyninst::ppc64::ir5: return 5;
1077             case Dyninst::ppc64::ir6: return 6;
1078             case Dyninst::ppc64::ir7: return 7;
1079             case Dyninst::ppc64::ir8: return 8;
1080             case Dyninst::ppc64::ir9: return 9;
1081             case Dyninst::ppc64::ir10: return 10;
1082             case Dyninst::ppc64::ir11: return 11;
1083             case Dyninst::ppc64::ir12: return 12;
1084             case Dyninst::ppc64::ir13: return 13;
1085             case Dyninst::ppc64::ir14: return 14;
1086             case Dyninst::ppc64::ir15: return 15;
1087             case Dyninst::ppc64::ir16: return 16;
1088             case Dyninst::ppc64::ir17: return 17;
1089             case Dyninst::ppc64::ir18: return 18;
1090             case Dyninst::ppc64::ir19: return 19;
1091             case Dyninst::ppc64::ir20: return 20;
1092             case Dyninst::ppc64::ir21: return 21;
1093             case Dyninst::ppc64::ir22: return 22;
1094             case Dyninst::ppc64::ir23: return 23;
1095             case Dyninst::ppc64::ir24: return 24;
1096             case Dyninst::ppc64::ir25: return 25;
1097             case Dyninst::ppc64::ir26: return 26;
1098             case Dyninst::ppc64::ir27: return 27;
1099             case Dyninst::ppc64::ir28: return 28;
1100             case Dyninst::ppc64::ir29: return 29;
1101             case Dyninst::ppc64::ir30: return 30;
1102             case Dyninst::ppc64::ir31: return 31;
1103             case Dyninst::ppc64::ifpr0: return 32;
1104             case Dyninst::ppc64::ifpr1: return 33;
1105             case Dyninst::ppc64::ifpr2: return 34;
1106             case Dyninst::ppc64::ifpr3: return 35;
1107             case Dyninst::ppc64::ifpr4: return 36;
1108             case Dyninst::ppc64::ifpr5: return 37;
1109             case Dyninst::ppc64::ifpr6: return 38;
1110             case Dyninst::ppc64::ifpr7: return 39;
1111             case Dyninst::ppc64::ifpr8: return 40;
1112             case Dyninst::ppc64::ifpr9: return 41;
1113             case Dyninst::ppc64::ifpr10: return 42;
1114             case Dyninst::ppc64::ifpr11: return 43;
1115             case Dyninst::ppc64::ifpr12: return 44;
1116             case Dyninst::ppc64::ifpr13: return 45;
1117             case Dyninst::ppc64::ifpr14: return 46;
1118             case Dyninst::ppc64::ifpr15: return 47;
1119             case Dyninst::ppc64::ifpr16: return 48;
1120             case Dyninst::ppc64::ifpr17: return 49;
1121             case Dyninst::ppc64::ifpr18: return 50;
1122             case Dyninst::ppc64::ifpr19: return 51;
1123             case Dyninst::ppc64::ifpr20: return 52;
1124             case Dyninst::ppc64::ifpr21: return 53;
1125             case Dyninst::ppc64::ifpr22: return 54;
1126             case Dyninst::ppc64::ifpr23: return 55;
1127             case Dyninst::ppc64::ifpr24: return 56;
1128             case Dyninst::ppc64::ifpr25: return 57;
1129             case Dyninst::ppc64::ifpr26: return 58;
1130             case Dyninst::ppc64::ifpr27: return 59;
1131             case Dyninst::ppc64::ifpr28: return 60;
1132             case Dyninst::ppc64::ifpr29: return 61;
1133             case Dyninst::ppc64::ifpr30: return 62;
1134             case Dyninst::ppc64::ifpr31: return 63;
1135             case Dyninst::ppc64::icr: return 64;
1136             case Dyninst::ppc64::imq: return 100;
1137             case Dyninst::ppc64::ixer: return 101;
1138             case Dyninst::ppc64::ilr: return 108;
1139             case Dyninst::ppc64::ictr: return 109;
1140             default: return -1;
1141          }
1142          break;
1143                         #warning "This is not verified yet!"
1144       case Arch_aarch64:
1145          switch (val()) {
1146                                                 /*
1147             case Dyninst::aarch64::x0:  return 0;
1148             case Dyninst::aarch64::x1:  return 1;
1149             case Dyninst::aarch64::x2:  return 2;
1150             case Dyninst::aarch64::x3:  return 3;
1151             case Dyninst::aarch64::x4:  return 4;
1152             case Dyninst::aarch64::x5:  return 5;
1153             case Dyninst::aarch64::x6:  return 6;
1154             case Dyninst::aarch64::x7:  return 7;
1155             case Dyninst::aarch64::x8:  return 8;
1156             case Dyninst::aarch64::x9:  return 9;
1157             case Dyninst::aarch64::x10:         return 10;
1158             case Dyninst::aarch64::x11:         return 11;
1159             case Dyninst::aarch64::x12:         return 12;
1160             case Dyninst::aarch64::x13:         return 13;
1161             case Dyninst::aarch64::x14:         return 14;
1162             case Dyninst::aarch64::x15:         return 15;
1163             case Dyninst::aarch64::x16:         return 16;
1164             case Dyninst::aarch64::x17:         return 17;
1165             case Dyninst::aarch64::x18:         return 18;
1166             case Dyninst::aarch64::x19:         return 19;
1167             case Dyninst::aarch64::x20:         return 20;
1168             case Dyninst::aarch64::x21:         return 21;
1169             case Dyninst::aarch64::x22:         return 22;
1170             case Dyninst::aarch64::x23:         return 23;
1171             case Dyninst::aarch64::x24:         return 24;
1172             case Dyninst::aarch64::x25:         return 25;
1173             case Dyninst::aarch64::x26:         return 26;
1174             case Dyninst::aarch64::x27:         return 27;
1175             case Dyninst::aarch64::x28:         return 28;
1176             case Dyninst::aarch64::x29:         return 29;
1177             case Dyninst::aarch64::x30:         return 30;
1178                                                 */
1179             default: return -1;
1180          }
1181          break;
1182       case Arch_none:
1183          return -1;
1184    }
1185    //Invalid register passed
1186    return -1;
1187 }
1188
1189 unsigned Dyninst::getArchAddressWidth(Dyninst::Architecture arch)
1190 {
1191    switch (arch) {
1192       case Arch_none: 
1193          return 0;
1194       case Arch_x86:
1195       case Arch_ppc32:
1196          return 4;
1197       case Arch_x86_64:
1198       case Arch_ppc64:
1199                         //steve: added, 64bit width
1200                         case Arch_aarch64:
1201          return 8;
1202    }
1203    return 0;
1204 }
1205