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