frontend » machine » hppa

hppa/decoder_low.cpp

Go to the documentation of this file.
00001 #define sign_extend(N,SIZE) (((int)((N) << (sizeof(unsigned)*8-(SIZE)))) >> (sizeof(unsigned)*8-(SIZE)))
00002 #include <assert.h>
00003 
00004 #line 2 "machine/hppa/decoder_low.m"
00005 /*==============================================================================
00006  * FILE:        decoder_low.m
00007  * OVERVIEW:    Low level New Jersey Machine Code Toolkit match file for the
00008  *              HP Pa/risc architecture (basically PA/RISC version 1.1)
00009  *
00010  * (C) 2000-01 The University of Queensland, BT group
00011  *============================================================================*/
00012 
00013 /*
00014  * $Revision: 1.1 $
00015  *
00016  * 30 Nov 00 - Simon: Created
00017  * 22 Mar 01 - Simon: fixed low_sign_ext problem with ADDI
00018  * 04 May 01 - Mike: c_cc -> c_c for consistency; fixed a problem with c_null
00019  *              that seems to be a result of the merge
00020  * 04 May 01 - Mike: Generate RTLs now instead of strings
00021  * 19 Jul 01 - Simon: Updated integer/float loads/stores and LDO
00022  * 23 Jul 01 - Mike: Added "not_used" to quelch annoying warnings
00023  * 25 Jul 01 - Simon: Added shift, extract, deposit
00024  * 07 Aug 01 - Simon: Changed iloads and istores to take more parameters, so
00025  *              that the addressing mode details are explicit in the SSL now
00026  * 10 Aug 01 - Simon: Moved decoder_low.m:c_bit() to decoder.m:dis_c_bit()
00027  * 13 Aug 01 - Mike: Provide address with "Undecoded instruction" message
00028  * 22 Aug 01 - Mike: Fixed a warning with "notused(nulli)"
00029  */
00030 
00031 
00032 #include "global.h"
00033 #include "decoder.h"
00034 #include "hppa-names.h"
00035 #include "rtl.h"
00036 
00037 void c_null(ADDRESS hostpc, char **garble);
00038 unsigned long c_wcr(ADDRESS hostpc, char **garble);
00039 bool c_c_n(ADDRESS hostpc);
00040 void addr(ADDRESS hostpc);
00041 
00042 // The below is used to quelch annoying "variable not used" warnings
00043 void not_used(int unwanted)
00044 {
00045     unwanted = 0;
00046 }
00047 
00048 DWord getDword (unsigned lc)
00049 /* get4Bytes - returns next 4-Byte from image pointed to by lc.
00050    Fetch in a big-endian manner  */
00051 {
00052     return
00053       (DWord)
00054       ((((((
00055           *(Byte *)lc << 8
00056       ) + *(Byte *)(lc+1)) << 8
00057       ) + *(Byte *)(lc+2)) << 8
00058       ) + *(Byte *)(lc+3));
00059 }
00060 
00061 bool c_c_n(ADDRESS hostpc)
00062 {
00063     bool result = true;
00064 
00065 
00066 #line 60 "machine/hppa/decoder_low.m"
00067 { 
00068   dword MATCH_p = 
00069     
00070     #line 60 "machine/hppa/decoder_low.m"
00071     hostpc
00072     ;
00073   unsigned MATCH_w_32_0;
00074   { 
00075     MATCH_w_32_0 = getDword(MATCH_p); 
00076     
00077       switch((MATCH_w_32_0 >> 26 & 0x3f) /* op at 0 */) {
00078         case 0: case 1: case 3: case 4: case 5: case 6: case 7: case 8: 
00079         case 9: case 10: case 11: case 12: case 13: case 14: case 15: 
00080         case 16: case 17: case 18: case 19: case 20: case 21: case 22: 
00081         case 23: case 24: case 25: case 26: case 27: case 28: case 29: 
00082         case 30: case 31: case 38: case 46: case 48: case 49: case 54: 
00083         case 55: case 56: case 57: case 58: case 60: case 61: case 62: 
00084         case 63: 
00085           goto MATCH_label_e0; break;
00086         case 2: 
00087           
00088             switch((MATCH_w_32_0 >> 6 & 0x3f) /* ext6_20 at 0 */) {
00089               case 0: case 4: case 5: case 7: case 8: case 9: case 10: 
00090               case 11: case 12: case 13: case 14: case 15: case 16: case 17: 
00091               case 19: case 20: case 21: case 22: case 23: case 24: case 25: 
00092               case 26: case 27: case 28: case 29: case 30: case 31: case 34: 
00093               case 38: case 39: case 40: case 41: case 42: case 43: case 46: 
00094               case 47: case 48: case 51: case 52: case 56: case 57: case 58: 
00095               case 59: case 60: 
00096                 if ((MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ == 1) 
00097                   goto MATCH_label_e2;  /*opt-block+*/
00098                 else 
00099                   goto MATCH_label_e1;  /*opt-block+*/
00100                 
00101                 break;
00102               case 1: case 2: case 3: case 6: case 18: case 32: case 33: 
00103               case 35: case 36: case 37: case 44: case 45: case 49: case 50: 
00104               case 53: case 54: case 55: case 61: case 62: case 63: 
00105                 goto MATCH_label_e0; break;
00106               default: assert(0);
00107             } /* (MATCH_w_32_0 >> 6 & 0x3f) -- ext6_20 at 0 --*/ 
00108           break;
00109         case 32: case 33: case 39: case 40: case 41: 
00110           goto MATCH_label_e1; break;
00111         case 34: case 35: case 42: case 43: case 47: 
00112           goto MATCH_label_e2; break;
00113         case 36: 
00114           if ((MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ == 1) 
00115             goto MATCH_label_e2;  /*opt-block+*/
00116           else 
00117             goto MATCH_label_e1;  /*opt-block+*/
00118           
00119           break;
00120         case 37: case 44: case 45: 
00121           if ((MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ == 1 && 
00122             (0 <= (MATCH_w_32_0 >> 11 & 0x1) /* ext_20 at 0 */ && 
00123             (MATCH_w_32_0 >> 11 & 0x1) /* ext_20 at 0 */ < 2)) 
00124             goto MATCH_label_e2;  /*opt-block+*/
00125           else 
00126             goto MATCH_label_e1;  /*opt-block+*/
00127           
00128           break;
00129         case 50: case 51: 
00130           if ((MATCH_w_32_0 >> 15 & 0x1) /* c1_16 at 0 */ == 1) 
00131             goto MATCH_label_e2;  /*opt-block+*/
00132           else 
00133             goto MATCH_label_e1;  /*opt-block+*/
00134           
00135           break;
00136         case 52: 
00137           if ((MATCH_w_32_0 >> 15 & 0x1) /* c1_16 at 0 */ == 1) 
00138             if ((MATCH_w_32_0 >> 13 & 0x7) /* c3_16 at 0 */ == 0 || 
00139               2 <= (MATCH_w_32_0 >> 13 & 0x7) /* c3_16 at 0 */ && 
00140               (MATCH_w_32_0 >> 13 & 0x7) /* c3_16 at 0 */ < 8 || 
00141               (MATCH_w_32_0 >> 13 & 0x7) /* c3_16 at 0 */ == 1 && 
00142               (MATCH_w_32_0 >> 12 & 0x1) /* cl_19 at 0 */ == 0 && 
00143               (MATCH_w_32_0 >> 10 & 0x1) /* se_21 at 0 */ == 1) 
00144               goto MATCH_label_e0;  /*opt-block+*/
00145             else 
00146               goto MATCH_label_e2;  /*opt-block+*/ /*opt-block+*/
00147           else 
00148             if ((MATCH_w_32_0 >> 12 & 0x1) /* cl_19 at 0 */ == 0 && 
00149               (MATCH_w_32_0 >> 10 & 0x1) /* se_21 at 0 */ == 1) 
00150               goto MATCH_label_e0;  /*opt-block+*/
00151             else 
00152               goto MATCH_label_e1;  /*opt-block+*/ /*opt-block+*/
00153           break;
00154         case 53: 
00155           if ((MATCH_w_32_0 >> 15 & 0x1) /* c1_16 at 0 */ == 1) 
00156             if ((MATCH_w_32_0 >> 13 & 0x7) /* c3_16 at 0 */ == 0 || 
00157               2 <= (MATCH_w_32_0 >> 13 & 0x7) /* c3_16 at 0 */ && 
00158               (MATCH_w_32_0 >> 13 & 0x7) /* c3_16 at 0 */ < 8) 
00159               goto MATCH_label_e0;  /*opt-block+*/
00160             else 
00161               goto MATCH_label_e2;  /*opt-block+*/ /*opt-block+*/
00162           else 
00163             goto MATCH_label_e1;  /*opt-block+*/
00164           break;
00165         case 59: 
00166           if ((MATCH_w_32_0 >> 15 & 0x1) /* c1_16 at 0 */ == 1) 
00167             if ((MATCH_w_32_0 >> 13 & 0x7) /* c3_16 at 0 */ == 1) 
00168               goto MATCH_label_e2;  /*opt-block+*/
00169             else 
00170               goto MATCH_label_e0;  /*opt-block+*/ /*opt-block+*/
00171           else 
00172             goto MATCH_label_e1;  /*opt-block+*/
00173           break;
00174         default: assert(0);
00175       } /* (MATCH_w_32_0 >> 26 & 0x3f) -- op at 0 --*/ 
00176     
00177   }goto MATCH_finished_e; 
00178   
00179   MATCH_label_e0: (void)0; /*placeholder for label*/ 
00180     assert(0);  /* no match */ 
00181     goto MATCH_finished_e; 
00182     
00183   MATCH_label_e1: (void)0; /*placeholder for label*/ 
00184     
00185     #line 61 "machine/hppa/decoder_low.m"
00186      { result = true; }
00187 
00188     
00189      
00190     goto MATCH_finished_e; 
00191     
00192   MATCH_label_e2: (void)0; /*placeholder for label*/ 
00193     
00194     #line 62 "machine/hppa/decoder_low.m"
00195         { result = false; }
00196 
00197     
00198      
00199     goto MATCH_finished_e; 
00200     
00201   MATCH_finished_e: (void)0; /*placeholder for label*/
00202   
00203 }
00204 
00205 #line 65 "machine/hppa/decoder_low.m"
00206     return result;
00207 }
00208 
00209 SemStr* NJMCDecoder::c_c(ADDRESS hostpc, int &cond)
00210 {
00211   static const char *c_c_names[] = {
00212                 "c_c_no", "c_c_eq", "c_c_l", "c_c_le", "c_c_ul", "c_c_ule", "c_c_sv",
00213                 "c_c_od", "c_c_yes", "c_c_ne", "c_c_ge", "c_c_g", "c_c_uge", "c_c_ug",
00214                 "c_c_nsv", "c_c_ev"
00215         };
00216   static const int cmpib_codes[] = { 4, 1, 2, 3, 12, 9, 10, 11 };
00217   static const int sep_codes[] = { 0, 1, 2, 7, 8, 9, 10, 15 };
00218 
00219 
00220 #line 76 "machine/hppa/decoder_low.m"
00221 { 
00222   dword MATCH_p = 
00223     
00224     #line 76 "machine/hppa/decoder_low.m"
00225     hostpc
00226     ;
00227   unsigned MATCH_w_32_0;
00228   { 
00229     MATCH_w_32_0 = getDword(MATCH_p); 
00230     
00231       switch((MATCH_w_32_0 >> 26 & 0x3f) /* op at 0 */) {
00232         case 0: case 1: case 3: case 4: case 5: case 6: case 7: case 8: 
00233         case 9: case 11: case 12: case 13: case 14: case 15: case 16: 
00234         case 17: case 18: case 19: case 20: case 21: case 22: case 23: 
00235         case 24: case 25: case 26: case 27: case 28: case 29: case 30: 
00236         case 31: case 38: case 46: case 54: case 55: case 56: case 57: 
00237         case 58: case 60: case 61: case 62: case 63: 
00238           goto MATCH_label_d0; break;
00239         case 2: 
00240           
00241             switch((MATCH_w_32_0 >> 6 & 0x3f) /* ext6_20 at 0 */) {
00242               case 0: case 4: case 5: case 7: case 8: case 9: case 10: 
00243               case 11: case 12: case 13: case 14: case 15: case 16: case 17: 
00244               case 19: case 20: case 21: case 22: case 23: case 24: case 25: 
00245               case 26: case 27: case 28: case 29: case 30: case 31: case 34: 
00246               case 38: case 39: case 40: case 41: case 42: case 43: case 46: 
00247               case 47: case 48: case 51: case 52: case 56: case 57: case 58: 
00248               case 59: case 60: 
00249                 if ((MATCH_w_32_0 >> 5 & 0x1) /* d_26 at 0 */ == 1 && 
00250                   (0 <= (MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ && 
00251                   (MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ < 2)) { 
00252                   unsigned c3 = (MATCH_w_32_0 >> 13 & 0x7) /* c3_16 at 0 */;
00253                   unsigned cmplt = addressToPC(MATCH_p);
00254                   
00255                   #line 81 "machine/hppa/decoder_low.m"
00256                    {
00257 
00258                               cond = c3 + (c_c_n(cmplt)?0:8); 
00259 
00260                           }
00261 
00262                   
00263                   
00264                   
00265                 } /*opt-block*//*opt-block+*/
00266                 else 
00267                   goto MATCH_label_d1;  /*opt-block+*/
00268                 
00269                 break;
00270               case 1: case 2: case 3: case 6: case 18: case 32: case 33: 
00271               case 35: case 36: case 37: case 44: case 45: case 49: case 50: 
00272               case 53: case 54: case 55: case 61: case 62: case 63: 
00273                 goto MATCH_label_d0; break;
00274               default: assert(0);
00275             } /* (MATCH_w_32_0 >> 6 & 0x3f) -- ext6_20 at 0 --*/ 
00276           break;
00277         case 10: 
00278           
00279           #line 84 "machine/hppa/decoder_low.m"
00280            {
00281 
00282                       cond = 0;
00283 
00284                   }
00285 
00286           
00287           
00288           
00289           break;
00290         case 32: case 33: case 34: case 35: 
00291           { 
00292             unsigned c3 = (MATCH_w_32_0 >> 13 & 0x7) /* c3_16 at 0 */;
00293             unsigned cmplt = addressToPC(MATCH_p);
00294             
00295             #line 90 "machine/hppa/decoder_low.m"
00296              {
00297 
00298                         cond = c3 + (c_c_n(cmplt)?0:8); 
00299 
00300                     }
00301 
00302             
00303             
00304             
00305           }
00306           
00307           break;
00308         case 36: 
00309           goto MATCH_label_d1; break;
00310         case 37: case 44: case 45: 
00311           goto MATCH_label_d1; break;
00312         case 39: case 47: 
00313           { 
00314             unsigned c3 = (MATCH_w_32_0 >> 13 & 0x7) /* c3_16 at 0 */;
00315             unsigned cmplt = addressToPC(MATCH_p);
00316             
00317             #line 93 "machine/hppa/decoder_low.m"
00318              {
00319 
00320                         cond = c3 + (c_c_n(cmplt)?0:8); 
00321 
00322                     }
00323 
00324             
00325             
00326             
00327           }
00328           
00329           break;
00330         case 40: case 41: case 42: case 43: 
00331           goto MATCH_label_d1; break;
00332         case 48: case 49: 
00333           if ((MATCH_w_32_0 >> 13 & 0x1) /* d_18 at 0 */ == 1) { 
00334             unsigned c = (MATCH_w_32_0 >> 15 & 0x1) /* c_16 at 0 */;
00335             
00336             #line 102 "machine/hppa/decoder_low.m"
00337              {
00338 
00339                         cond = 1 + (c?0:8); 
00340 
00341                     }
00342 
00343             
00344             
00345             
00346           } /*opt-block*//*opt-block+*/
00347           else { 
00348             unsigned c = (MATCH_w_32_0 >> 15 & 0x1) /* c_16 at 0 */;
00349             
00350             #line 99 "machine/hppa/decoder_low.m"
00351              {
00352 
00353                         cond = 1 + (c?0:8); 
00354 
00355                     }
00356 
00357             
00358             
00359             
00360           } /*opt-block*//*opt-block+*/
00361           
00362           break;
00363         case 50: case 51: 
00364           goto MATCH_label_d2; break;
00365         case 52: 
00366           if ((MATCH_w_32_0 >> 12 & 0x1) /* cl_19 at 0 */ == 0 && 
00367             (MATCH_w_32_0 >> 10 & 0x1) /* se_21 at 0 */ == 1) 
00368             goto MATCH_label_d0;  /*opt-block+*/
00369           else 
00370             goto MATCH_label_d2;  /*opt-block+*/
00371           
00372           break;
00373         case 53: 
00374           goto MATCH_label_d2; break;
00375         case 59: 
00376           { 
00377             unsigned c3 = 
00378               ((MATCH_w_32_0 >> 15 & 0x1) /* c1_16 at 0 */ << 2) + 
00379               (MATCH_w_32_0 >> 13 & 0x3) /* c2_17 at 0 */;
00380             
00381             #line 96 "machine/hppa/decoder_low.m"
00382              {
00383 
00384                         cond = cmpib_codes[c3];
00385 
00386                     }
00387 
00388             
00389             
00390             
00391           }
00392           
00393           break;
00394         default: assert(0);
00395       } /* (MATCH_w_32_0 >> 26 & 0x3f) -- op at 0 --*/ 
00396     
00397   }goto MATCH_finished_d; 
00398   
00399   MATCH_label_d0: (void)0; /*placeholder for label*/ 
00400     
00401     #line 105 "machine/hppa/decoder_low.m"
00402     {
00403 
00404                 cond = 0;
00405 
00406             }
00407 
00408     
00409      
00410     goto MATCH_finished_d; 
00411     
00412   MATCH_label_d1: (void)0; /*placeholder for label*/ 
00413     { 
00414       unsigned c3 = (MATCH_w_32_0 >> 13 & 0x7) /* c3_16 at 0 */;
00415       unsigned cmplt = addressToPC(MATCH_p);
00416       
00417       #line 78 "machine/hppa/decoder_low.m"
00418        {
00419 
00420                   cond = c3 + (c_c_n(cmplt)?0:8); 
00421 
00422               }
00423 
00424       
00425       
00426       
00427     } 
00428     goto MATCH_finished_d; 
00429     
00430   MATCH_label_d2: (void)0; /*placeholder for label*/ 
00431     { 
00432       unsigned c3_16 = 
00433         ((MATCH_w_32_0 >> 15 & 0x1) /* c1_16 at 0 */ << 2) + 
00434         (MATCH_w_32_0 >> 13 & 0x3) /* c2_17 at 0 */;
00435       
00436       #line 87 "machine/hppa/decoder_low.m"
00437        {
00438 
00439                   cond = sep_codes[c3_16];
00440 
00441               }
00442 
00443       
00444       
00445       
00446     } 
00447     goto MATCH_finished_d; 
00448     
00449   MATCH_finished_d: (void)0; /*placeholder for label*/
00450   
00451 }
00452 
00453 #line 109 "machine/hppa/decoder_low.m"
00454   return instantiateNamedParam(c_c_names[cond]);
00455 }
00456 
00457 unsigned long c_wcr(ADDRESS hostpc, char **garble)
00458 {
00459 #if 0
00460   unsigned long regl;
00461 
00462 
00463 #line 115 "machine/hppa/decoder_low.m"
00464 { 
00465   dword MATCH_p = 
00466     
00467     #line 115 "machine/hppa/decoder_low.m"
00468     hostpc
00469     ;
00470   unsigned MATCH_w_32_0;
00471   { 
00472     MATCH_w_32_0 = getDword(MATCH_p); 
00473     if ((MATCH_w_32_0 >> 5 & 0xff) /* ext8_19 at 0 */ == 69) 
00474       if ((MATCH_w_32_0 >> 26 & 0x3f) /* op at 0 */ == 0) 
00475         if ((MATCH_w_32_0 >> 14 & 0x1) /* ext_17 at 0 */ == 1) 
00476           
00477           #line 120 "machine/hppa/decoder_low.m"
00478            {
00479 
00480                   *garble += sprintf(*garble,".w");
00481 
00482                   regl = 11;
00483 
00484               }
00485 
00486           
00487            /*opt-block+*/
00488         else { 
00489           unsigned r_06 = (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
00490           
00491           #line 117 "machine/hppa/decoder_low.m"
00492            {
00493 
00494                   regl = r_06;
00495 
00496               }
00497 
00498           
00499           
00500           
00501         } /*opt-block*//*opt-block+*/ /*opt-block+*/
00502       else 
00503         goto MATCH_label_c0;  /*opt-block+*/ 
00504     else 
00505       goto MATCH_label_c0;  /*opt-block+*/
00506     
00507   }goto MATCH_finished_c; 
00508   
00509   MATCH_label_c0: (void)0; /*placeholder for label*/ 
00510     
00511     #line 124 "machine/hppa/decoder_low.m"
00512     {
00513 
00514             regl = 0;
00515 
00516             //sprintf("#c_WCR%08X#", getDword(hostpc));
00517 
00518         }
00519 
00520     
00521      
00522     goto MATCH_finished_c; 
00523     
00524   MATCH_finished_c: (void)0; /*placeholder for label*/
00525   
00526 }
00527 
00528 #line 129 "machine/hppa/decoder_low.m"
00529   return regl;
00530 #else
00531     return 0;
00532 #endif
00533 }
00534 
00535 void c_null(ADDRESS hostpc, char **garble)
00536 {
00537 #if 0
00538 
00539 
00540 #line 137 "machine/hppa/decoder_low.m"
00541 { 
00542   dword MATCH_p = 
00543     
00544     #line 137 "machine/hppa/decoder_low.m"
00545     hostpc
00546     ;
00547   unsigned MATCH_w_32_0;
00548   { 
00549     MATCH_w_32_0 = getDword(MATCH_p); 
00550     
00551       switch((MATCH_w_32_0 >> 26 & 0x3f) /* op at 0 */) {
00552         case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: 
00553         case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: 
00554         case 16: case 17: case 18: case 19: case 20: case 21: case 22: 
00555         case 23: case 24: case 25: case 26: case 27: case 28: case 29: 
00556         case 30: case 31: case 36: case 37: case 38: case 44: case 45: 
00557         case 46: case 52: case 53: case 54: case 55: case 60: case 61: 
00558         case 62: case 63: 
00559           
00560           #line 144 "machine/hppa/decoder_low.m"
00561           {
00562 
00563                   //printf("#c_NULL%08X#", getDword(hostpc));
00564 
00565               }
00566 
00567           
00568           
00569           
00570           break;
00571         case 32: case 33: case 34: case 35: case 39: case 40: case 41: 
00572         case 42: case 43: case 47: case 48: case 49: case 50: case 51: 
00573         case 56: case 57: case 58: case 59: 
00574           if ((MATCH_w_32_0 >> 1 & 0x1) /* n_30 at 0 */ == 1) 
00575             
00576             #line 141 "machine/hppa/decoder_low.m"
00577              {
00578 
00579                     *garble += sprintf(*garble, ".n");
00580 
00581                 }
00582 
00583             
00584              /*opt-block+*/
00585           else 
00586             
00587             #line 138 "machine/hppa/decoder_low.m"
00588              {
00589 
00590                 }
00591 
00592             
00593              /*opt-block+*/
00594           
00595           break;
00596         default: assert(0);
00597       } /* (MATCH_w_32_0 >> 26 & 0x3f) -- op at 0 --*/ 
00598     
00599   }goto MATCH_finished_b; 
00600   
00601   MATCH_finished_b: (void)0; /*placeholder for label*/
00602   
00603 }
00604 
00605 #line 148 "machine/hppa/decoder_low.m"
00606 #endif
00607 }
00608 
00609 /*==============================================================================
00610  * FUNCTION:       NJMCDecoder::decodeLowLevelInstruction
00611  * OVERVIEW:       Decodes a machine instruction and returns an instantiated
00612  *                  list of RTs.
00613  * NOTE:           A side effect of decoding the completers is that there may
00614  *                  be some semantics added to members preInstSem or postInstSem
00615  *                  This is made part of the final RTL in decoder.m
00616  * PARAMETERS:     hostPC - the address of the pc in the loaded Elf object
00617  *                 pc - the virtual address of the pc
00618  *                 result - a reference parameter that has a fields for the
00619  *                  number of bytes decoded, their validity, etc
00620  * RETURNS:        the instantiated list of RTs
00621  *============================================================================*/
00622 list<RT*>* NJMCDecoder::decodeLowLevelInstruction (ADDRESS hostPC, ADDRESS pc,
00623                         DecodeResult& result)
00624 {
00625     ADDRESS nextPC; 
00626   
00627     list<RT*>* RTs = NULL;
00628     int condvalue;
00629 
00630 
00631 #line 170 "machine/hppa/decoder_low.m"
00632 { 
00633   dword MATCH_p = 
00634     
00635     #line 170 "machine/hppa/decoder_low.m"
00636     hostPC
00637     ;
00638   char *MATCH_name;
00639   static char *MATCH_name_ext8_19_0[] = {
00640     "BREAK", (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00641     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00642     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00643     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00644     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00645     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00646     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00647     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00648     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00649     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00650     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00651     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00652     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00653     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00654     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00655     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, "RFI", 
00656     (char *)0, (char *)0, (char *)0, (char *)0, "RFI.r", (char *)0, 
00657     (char *)0, (char *)0, (char *)0, (char *)0, "SSM", (char *)0, (char *)0, 
00658     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, "RSM", (char *)0, 
00659     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00660     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00661     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00662     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00663     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00664     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00665     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00666     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, "MFIA", 
00667     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00668     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00669     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00670     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00671     (char *)0, (char *)0, (char *)0, (char *)0, "MTCTL", "MTSM", (char *)0, 
00672     (char *)0, "MTSARCM", 
00673   };
00674   static char *MATCH_name_ext5_11_1[] = {
00675     "SYNC", (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00676     (char *)0, (char *)0, (char *)0, "SYNCDMA", 
00677   };
00678   static char *MATCH_name_ext_17_2[] = {"MFCTL", "MFCTL.w", };
00679   static char *MATCH_name_ext4_22_55[] = {
00680     "LDBS", "LDHS", "LDWS", "LDDS", "LDDAS", "LDCDS", "LDWAS", "LDCWS", 
00681     "STBS", "STHS", "STWS", "STDS", "STBYS", "STDBYS", "STWAS", "STWDS", 
00682   };
00683   static char *MATCH_name_op_58[] = {
00684     (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 
00685     (char *)0, (char *)0, "LDIL", (char *)0, "ADDIL", (char *)0, (char *)0, 
00686     "LDO", (char *)0, (char *)0, "LDB", "LDH", "LDW", "LDWM", (char *)0, 
00687     (char *)0, (char *)0, (char *)0, "STB", "STH", "STW", "STWM", 
00688   };
00689   static char *MATCH_name_sub_16_71[] = {
00690     "FID", "FTEST", "FCPY", "FABS", "FSQRT", "FRND", "FNEG", "FNEGABS", 
00691   };
00692   static char *MATCH_name_sub_14_72[] = {
00693     "FCNVFF", "FCNVXF", "FCNVFX", "FCNVFXT", 
00694   };
00695   static char *MATCH_name_sub_16_73[] = {"FCMP", "FSUB", "FMPY", "FDIV", };
00696   static char *MATCH_name_sub_16_74[] = {"FADD", "FTEST.E", };
00697   static char *MATCH_name_sub_14_75[] = {
00698     "FCNVFF.E", "FCNVXF.E", "FCNVFX.E", "FCNVFXT.E", 
00699   };
00700   static char *MATCH_name_p_20_88[] = {"VSHD", "SHD", };
00701   static char *MATCH_name_se_21_89[] = {"VEXTRU", "VEXTRS", };
00702   static char *MATCH_name_se_21_90[] = {"EXTRU", "EXTRS", };
00703   static char *MATCH_name_se_21_91[] = {"ZVDEP", "VDEP", };
00704   static char *MATCH_name_se_21_92[] = {"ZDEP", "DEP", };
00705   static char *MATCH_name_se_21_93[] = {"ZVDEPI", "VDEPI", };
00706   static char *MATCH_name_se_21_94[] = {"ZDEPI", "DEPI", };
00707   unsigned MATCH_w_32_0;
00708   { 
00709     MATCH_w_32_0 = getDword(MATCH_p); 
00710     
00711       switch((MATCH_w_32_0 >> 26 & 0x3f) /* op at 0 */) {
00712         case 0: 
00713           if (33 <= (MATCH_w_32_0 >> 5 & 0xff) /* ext8_19 at 0 */ && 
00714             (MATCH_w_32_0 >> 5 & 0xff) /* ext8_19 at 0 */ < 69 || 
00715             116 <= (MATCH_w_32_0 >> 5 & 0xff) /* ext8_19 at 0 */ && 
00716             (MATCH_w_32_0 >> 5 & 0xff) /* ext8_19 at 0 */ < 165 || 
00717             199 <= (MATCH_w_32_0 >> 5 & 0xff) /* ext8_19 at 0 */ && 
00718             (MATCH_w_32_0 >> 5 & 0xff) /* ext8_19 at 0 */ < 256) 
00719             goto MATCH_label_a0;  /*opt-block+*/
00720           else 
00721             switch((MATCH_w_32_0 >> 5 & 0xff) /* ext8_19 at 0 */) {
00722               case 0: 
00723                 MATCH_name = MATCH_name_ext8_19_0[(MATCH_w_32_0 >> 5 & 0xff) 
00724                       /* ext8_19 at 0 */]; 
00725                 { 
00726                   char *name = MATCH_name;
00727                   unsigned im13_06 = 
00728                     (MATCH_w_32_0 >> 13 & 0x1fff) /* im13_06 at 0 */;
00729                   unsigned im5_27 = (MATCH_w_32_0 & 0x1f) /* im5_27 at 0 */;
00730                   nextPC = 4 + MATCH_p; 
00731                   
00732                   #line 281 "machine/hppa/decoder_low.m"
00733                    {
00734 
00735                               RTs = instantiate(pc, name, dis_Num(im5_27), dis_Num(im13_06));
00736 
00737                           }
00738 
00739                   
00740                   
00741                   
00742                 }
00743                 
00744                 break;
00745               case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: 
00746               case 9: case 10: case 11: case 12: case 13: case 14: case 15: 
00747               case 16: case 17: case 18: case 19: case 20: case 21: case 22: 
00748               case 23: case 24: case 25: case 26: case 27: case 28: case 29: 
00749               case 30: case 31: case 70: case 71: case 72: case 73: case 74: 
00750               case 75: case 76: case 77: case 78: case 79: case 80: case 81: 
00751               case 82: case 83: case 84: case 85: case 86: case 87: case 88: 
00752               case 89: case 90: case 91: case 92: case 93: case 94: case 95: 
00753               case 97: case 98: case 99: case 100: case 102: case 103: 
00754               case 104: case 105: case 106: case 108: case 109: case 110: 
00755               case 111: case 112: case 113: case 114: case 166: case 167: 
00756               case 168: case 169: case 170: case 171: case 172: case 173: 
00757               case 174: case 175: case 176: case 177: case 178: case 179: 
00758               case 180: case 181: case 182: case 183: case 184: case 185: 
00759               case 186: case 187: case 188: case 189: case 190: case 191: 
00760               case 192: case 193: case 196: case 197: 
00761                 goto MATCH_label_a0; break;
00762               case 32: 
00763                 if ((MATCH_w_32_0 >> 16 & 0x1f) /* ext5_11 at 0 */ == 0 || 
00764                   (MATCH_w_32_0 >> 16 & 0x1f) /* ext5_11 at 0 */ == 10) { 
00765                   MATCH_name = 
00766                     MATCH_name_ext5_11_1[(MATCH_w_32_0 >> 16 & 0x1f) 
00767                         /* ext5_11 at 0 */]; 
00768                   goto MATCH_label_a1; 
00769                   
00770                 } /*opt-block*/
00771                 else 
00772                   goto MATCH_label_a0;  /*opt-block+*/
00773                 
00774                 break;
00775               case 69: 
00776                 MATCH_name = MATCH_name_ext_17_2[(MATCH_w_32_0 >> 14 & 0x1) 
00777                       /* ext_17 at 0 */]; 
00778                 { 
00779                   char *name = MATCH_name;
00780                   unsigned cmplt = addressToPC(MATCH_p);
00781                   unsigned t_27 = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
00782                   nextPC = 4 + MATCH_p; 
00783                   
00784                   #line 293 "machine/hppa/decoder_low.m"
00785                    {
00786 
00787                               RTs = instantiate(pc, name, dis_c_wcr(cmplt), dis_Reg(t_27));
00788 
00789                           }
00790 
00791                   
00792                   
00793                   
00794                 }
00795                 
00796                 break;
00797               case 96: case 101: 
00798                 MATCH_name = MATCH_name_ext8_19_0[(MATCH_w_32_0 >> 5 & 0xff) 
00799                       /* ext8_19 at 0 */]; 
00800                 goto MATCH_label_a1; 
00801                 
00802                 break;
00803               case 107: case 115: 
00804                 MATCH_name = MATCH_name_ext8_19_0[(MATCH_w_32_0 >> 5 & 0xff) 
00805                       /* ext8_19 at 0 */]; 
00806                 { 
00807                   char *name = MATCH_name;
00808                   unsigned im10_06 = 
00809                     (MATCH_w_32_0 >> 16 & 0x3ff) /* im10_06 at 0 */;
00810                   unsigned t_27 = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
00811                   nextPC = 4 + MATCH_p; 
00812                   
00813                   #line 284 "machine/hppa/decoder_low.m"
00814                    {
00815 
00816                               RTs = instantiate(pc, name, dis_Num(im10_06), dis_Reg(t_27));
00817 
00818                           }
00819 
00820                   
00821                   
00822                   
00823                 }
00824                 
00825                 break;
00826               case 165: 
00827                 MATCH_name = MATCH_name_ext8_19_0[(MATCH_w_32_0 >> 5 & 0xff) 
00828                       /* ext8_19 at 0 */]; 
00829                 { 
00830                   char *name = MATCH_name;
00831                   unsigned t_27 = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
00832                   nextPC = 4 + MATCH_p; 
00833                   
00834                   #line 299 "machine/hppa/decoder_low.m"
00835                    {
00836 
00837                               RTs = instantiate(pc, name, dis_Reg(t_27));
00838 
00839                           }
00840 
00841                   // Floating point instructions. Note that the floating point format is being
00842 
00843                   // passed as an ss inf the form of an integer constant (using dis_Num())
00844 
00845                   
00846                   
00847                   
00848                 }
00849                 
00850                 break;
00851               case 194: 
00852                 MATCH_name = MATCH_name_ext8_19_0[(MATCH_w_32_0 >> 5 & 0xff) 
00853                       /* ext8_19 at 0 */]; 
00854                 { 
00855                   char *name = MATCH_name;
00856                   unsigned ct_06 = 
00857                     (MATCH_w_32_0 >> 21 & 0x1f) /* cr_06 at 0 */;
00858                   unsigned r_11 = (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
00859                   nextPC = 4 + MATCH_p; 
00860                   
00861                   #line 296 "machine/hppa/decoder_low.m"
00862                    {
00863 
00864                               RTs = instantiate(pc, name, dis_Reg(r_11), dis_ct(ct_06));
00865 
00866                           }
00867 
00868                   
00869                   
00870                   
00871                 }
00872                 
00873                 break;
00874               case 195: case 198: 
00875                 MATCH_name = MATCH_name_ext8_19_0[(MATCH_w_32_0 >> 5 & 0xff) 
00876                       /* ext8_19 at 0 */]; 
00877                 { 
00878                   char *name = MATCH_name;
00879                   unsigned r_11 = (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
00880                   nextPC = 4 + MATCH_p; 
00881                   
00882                   #line 290 "machine/hppa/decoder_low.m"
00883                    {
00884 
00885                               RTs = instantiate(pc, name, dis_Reg(r_11));
00886 
00887                           }
00888 
00889                   
00890                   
00891                   
00892                 }
00893                 
00894                 break;
00895               default: assert(0);
00896             } /* (MATCH_w_32_0 >> 5 & 0xff) -- ext8_19 at 0 --*/ 
00897           break;
00898         case 1: case 4: case 5: case 6: case 7: case 15: case 20: case 21: 
00899         case 22: case 23: case 28: case 29: case 30: case 31: case 32: 
00900         case 33: case 34: case 35: case 38: case 39: case 40: case 41: 
00901         case 42: case 43: case 46: case 47: case 48: case 49: case 50: 
00902         case 51: case 54: case 55: case 56: case 57: case 59: case 60: 
00903         case 61: case 62: case 63: 
00904           goto MATCH_label_a0; break;
00905         case 2: 
00906           
00907             switch((MATCH_w_32_0 >> 6 & 0x3f) /* ext6_20 at 0 */) {
00908               case 0: 
00909                 MATCH_name = "ANDCM"; goto MATCH_label_a2; break;
00910               case 1: case 2: case 3: case 6: case 18: case 32: case 33: 
00911               case 35: case 36: case 37: case 44: case 45: case 49: case 50: 
00912               case 53: case 54: case 55: case 61: case 62: case 63: 
00913                 goto MATCH_label_a0; break;
00914               case 4: 
00915                 MATCH_name = "HSUB.u"; goto MATCH_label_a2; break;
00916               case 5: 
00917                 MATCH_name = "HSUB.s"; goto MATCH_label_a2; break;
00918               case 7: 
00919                 MATCH_name = "HSUB"; goto MATCH_label_a2; break;
00920               case 8: 
00921                 MATCH_name = "AND"; goto MATCH_label_a2; break;
00922               case 9: 
00923                 MATCH_name = "OR"; goto MATCH_label_a2; break;
00924               case 10: 
00925                 MATCH_name = "XOR"; goto MATCH_label_a2; break;
00926               case 11: 
00927                 MATCH_name = "HAVG"; goto MATCH_label_a2; break;
00928               case 12: 
00929                 MATCH_name = "HADD.u"; goto MATCH_label_a2; break;
00930               case 13: 
00931                 MATCH_name = "HADD.s"; goto MATCH_label_a2; break;
00932               case 14: 
00933                 MATCH_name = "UXOR"; goto MATCH_label_a2; break;
00934               case 15: 
00935                 MATCH_name = "HADD"; goto MATCH_label_a2; break;
00936               case 16: 
00937                 MATCH_name = "SUB"; goto MATCH_label_a2; break;
00938               case 17: 
00939                 MATCH_name = "DS"; goto MATCH_label_a2; break;
00940               case 19: 
00941                 MATCH_name = "SUB.t"; goto MATCH_label_a2; break;
00942               case 20: 
00943                 MATCH_name = "SUB.b"; goto MATCH_label_a2; break;
00944               case 21: 
00945                 MATCH_name = "HSHR1ADD"; goto MATCH_label_a2; break;
00946               case 22: 
00947                 MATCH_name = "HSHR2ADD"; goto MATCH_label_a2; break;
00948               case 23: 
00949                 MATCH_name = "HSHR3ADD"; goto MATCH_label_a2; break;
00950               case 24: 
00951                 MATCH_name = "ADD"; goto MATCH_label_a2; break;
00952               case 25: 
00953                 MATCH_name = "SHL1ADD"; goto MATCH_label_a2; break;
00954               case 26: 
00955                 MATCH_name = "SHL2ADD"; goto MATCH_label_a2; break;
00956               case 27: 
00957                 MATCH_name = "SHL3ADD"; goto MATCH_label_a2; break;
00958               case 28: 
00959                 MATCH_name = "ADD.c"; goto MATCH_label_a2; break;
00960               case 29: 
00961                 MATCH_name = "HSHL1ADD"; goto MATCH_label_a2; break;
00962               case 30: 
00963                 MATCH_name = "HSHL2ADD"; goto MATCH_label_a2; break;
00964               case 31: 
00965                 MATCH_name = "HSHL3ADD"; goto MATCH_label_a2; break;
00966               case 34: 
00967                 MATCH_name = "CMPCLR"; goto MATCH_label_a2; break;
00968               case 38: 
00969                 MATCH_name = "UADDCM"; goto MATCH_label_a2; break;
00970               case 39: 
00971                 MATCH_name = "UADDCMT"; goto MATCH_label_a2; break;
00972               case 40: 
00973                 MATCH_name = "ADD.l"; goto MATCH_label_a2; break;
00974               case 41: 
00975                 MATCH_name = "SHL1ADD.l"; goto MATCH_label_a2; break;
00976               case 42: 
00977                 MATCH_name = "SHL2ADD.l"; goto MATCH_label_a2; break;
00978               case 43: 
00979                 MATCH_name = "SHL3ADD.l"; goto MATCH_label_a2; break;
00980               case 46: 
00981                 MATCH_name = "DCOR"; goto MATCH_label_a2; break;
00982               case 47: 
00983                 MATCH_name = "IDCOR"; goto MATCH_label_a2; break;
00984               case 48: 
00985                 MATCH_name = "SUB.v"; goto MATCH_label_a2; break;
00986               case 51: 
00987                 MATCH_name = "SUB.t.v"; goto MATCH_label_a2; break;
00988               case 52: 
00989                 MATCH_name = "SUB.b.v"; goto MATCH_label_a2; break;
00990               case 56: 
00991                 MATCH_name = "ADD.v"; goto MATCH_label_a2; break;
00992               case 57: 
00993                 MATCH_name = "SHL1ADD.v"; goto MATCH_label_a2; break;
00994               case 58: 
00995                 MATCH_name = "SHL2ADD.v"; goto MATCH_label_a2; break;
00996               case 59: 
00997                 MATCH_name = "SHL3ADD.v"; goto MATCH_label_a2; break;
00998               case 60: 
00999                 MATCH_name = "ADD.c.v"; goto MATCH_label_a2; break;
01000               default: assert(0);
01001             } /* (MATCH_w_32_0 >> 6 & 0x3f) -- ext6_20 at 0 --*/ 
01002           break;
01003         case 3: 
01004           if ((MATCH_w_32_0 >> 12 & 0x1) /* addr_19 at 0 */ == 1) 
01005             if ((MATCH_w_32_0 >> 5 & 0x1) /* m_26 at 0 */ == 1) 
01006               if (0 <= (MATCH_w_32_0 >> 13 & 0x1) /* a_18 at 0 */ && 
01007                 (MATCH_w_32_0 >> 13 & 0x1) /* a_18 at 0 */ < 2 && 
01008                 (8 <= (MATCH_w_32_0 >> 6 & 0xf) /* ext4_22 at 0 */ && 
01009                 (MATCH_w_32_0 >> 6 & 0xf) /* ext4_22 at 0 */ < 16)) { 
01010                 MATCH_name = MATCH_name_ext4_22_55[(MATCH_w_32_0 >> 6 & 0xf) 
01011                       /* ext4_22 at 0 */]; 
01012                 goto MATCH_label_a4; 
01013                 
01014               } /*opt-block*/
01015               else { 
01016                 MATCH_name = MATCH_name_ext4_22_55[(MATCH_w_32_0 >> 6 & 0xf) 
01017                       /* ext4_22 at 0 */]; 
01018                 goto MATCH_label_a3; 
01019                 
01020               } /*opt-block*/ /*opt-block+*/
01021             else 
01022               
01023                 switch((MATCH_w_32_0 >> 6 & 0xf) /* ext4_22 at 0 */) {
01024                   case 0: case 1: case 2: case 3: case 4: case 5: case 6: 
01025                   case 7: 
01026                     MATCH_name = 
01027                       MATCH_name_ext4_22_55[(MATCH_w_32_0 >> 6 & 0xf) 
01028                           /* ext4_22 at 0 */]; 
01029                     goto MATCH_label_a3; 
01030                     
01031                     break;
01032                   case 8: case 9: case 10: case 11: case 14: case 15: 
01033                     MATCH_name = 
01034                       MATCH_name_ext4_22_55[(MATCH_w_32_0 >> 6 & 0xf) 
01035                           /* ext4_22 at 0 */]; 
01036                     goto MATCH_label_a4; 
01037                     
01038                     break;
01039                   case 12: 
01040                     MATCH_name = "STBYS"; goto MATCH_label_a4; break;
01041                   case 13: 
01042                     MATCH_name = "STDBYS"; goto MATCH_label_a4; break;
01043                   default: assert(0);
01044                 } /* (MATCH_w_32_0 >> 6 & 0xf) -- ext4_22 at 0 --*/   
01045           else 
01046             
01047               switch((MATCH_w_32_0 >> 6 & 0xf) /* ext4_22 at 0 */) {
01048                 case 0: 
01049                   MATCH_name = "LDBX"; goto MATCH_label_a3; break;
01050                 case 1: 
01051                   MATCH_name = "LDHX"; goto MATCH_label_a3; break;
01052                 case 2: 
01053                   MATCH_name = "LDWX"; goto MATCH_label_a3; break;
01054                 case 3: 
01055                   MATCH_name = "LDDX"; goto MATCH_label_a3; break;
01056                 case 4: 
01057                   MATCH_name = "LDDAX"; goto MATCH_label_a3; break;
01058                 case 5: 
01059                   MATCH_name = "LDCDX"; goto MATCH_label_a3; break;
01060                 case 6: 
01061                   MATCH_name = "LDWAX"; goto MATCH_label_a3; break;
01062                 case 7: 
01063                   MATCH_name = "LDCWX"; goto MATCH_label_a3; break;
01064                 case 8: case 9: case 10: case 11: case 12: case 13: case 14: 
01065                 case 15: 
01066                   goto MATCH_label_a0; break;
01067                 default: assert(0);
01068               } /* (MATCH_w_32_0 >> 6 & 0xf) -- ext4_22 at 0 --*/  
01069           break;
01070         case 8: 
01071           MATCH_name = 
01072             MATCH_name_op_58[(MATCH_w_32_0 >> 26 & 0x3f) /* op at 0 */]; 
01073           { 
01074             char *name = MATCH_name;
01075             unsigned imm21 = 
01076               ((MATCH_w_32_0 >> 12 & 0x3) /* im2_18 at 0 */ << 11) + 
01077               ((MATCH_w_32_0 >> 16 & 0x1f) /* im5_11 at 0 */ << 13) + 
01078               ((MATCH_w_32_0 >> 14 & 0x3) /* im2_16 at 0 */ << 18) + 
01079               ((MATCH_w_32_0 >> 1 & 0x7ff) /* im11_20 at 0 */ << 20) + 
01080               (((MATCH_w_32_0 & 0x1) /* i_31 at 0 */ & 0x1) << 31);
01081             unsigned t_06 = (MATCH_w_32_0 >> 21 & 0x1f) /* t_06 at 0 */;
01082             nextPC = 4 + MATCH_p; 
01083             
01084             #line 185 "machine/hppa/decoder_low.m"
01085              {
01086 
01087                         RTs = instantiate(pc, name, dis_Num(imm21), dis_Reg(t_06));
01088 
01089                     }
01090 
01091             
01092             
01093             
01094           }
01095           
01096           break;
01097         case 9: 
01098           if ((MATCH_w_32_0 >> 7 & 0x3) /* uid2_23 at 0 */ == 0) 
01099             if ((MATCH_w_32_0 >> 9 & 0x1) /* addr_22 at 0 */ == 1) 
01100               if ((MATCH_w_32_0 >> 12 & 0x1) /* addr_19 at 0 */ == 1 && 
01101                 (MATCH_w_32_0 >> 5 & 0x1) /* m_26 at 0 */ == 0 || 
01102                 (MATCH_w_32_0 >> 12 & 0x1) /* addr_19 at 0 */ == 1 && 
01103                 (MATCH_w_32_0 >> 5 & 0x1) /* m_26 at 0 */ == 1 && 
01104                 (0 <= (MATCH_w_32_0 >> 13 & 0x1) /* a_18 at 0 */ && 
01105                 (MATCH_w_32_0 >> 13 & 0x1) /* a_18 at 0 */ < 2)) { 
01106                 MATCH_name = "FSTWS"; 
01107                 goto MATCH_label_a6; 
01108                 
01109               } /*opt-block*/
01110               else { 
01111                 MATCH_name = "FSTWX"; 
01112                 goto MATCH_label_a6; 
01113                 
01114               } /*opt-block*/ /*opt-block+*/
01115             else 
01116               if ((MATCH_w_32_0 >> 12 & 0x1) /* addr_19 at 0 */ == 1 && 
01117                 (MATCH_w_32_0 >> 5 & 0x1) /* m_26 at 0 */ == 0 || 
01118                 (MATCH_w_32_0 >> 12 & 0x1) /* addr_19 at 0 */ == 1 && 
01119                 (MATCH_w_32_0 >> 5 & 0x1) /* m_26 at 0 */ == 1 && 
01120                 (0 <= (MATCH_w_32_0 >> 13 & 0x1) /* a_18 at 0 */ && 
01121                 (MATCH_w_32_0 >> 13 & 0x1) /* a_18 at 0 */ < 2)) { 
01122                 MATCH_name = "FLDWS"; 
01123                 goto MATCH_label_a5; 
01124                 
01125               } /*opt-block*/
01126               else { 
01127                 MATCH_name = "FLDWX"; 
01128                 goto MATCH_label_a5; 
01129                 
01130               } /*opt-block*/ /*opt-block+*/ 
01131           else 
01132             goto MATCH_label_a0;  /*opt-block+*/
01133           break;
01134         case 10: 
01135           MATCH_name = 
01136             MATCH_name_op_58[(MATCH_w_32_0 >> 26 & 0x3f) /* op at 0 */]; 
01137           { 
01138             char *name = MATCH_name;
01139             unsigned imm21 = 
01140               ((MATCH_w_32_0 >> 12 & 0x3) /* im2_18 at 0 */ << 11) + 
01141               ((MATCH_w_32_0 >> 16 & 0x1f) /* im5_11 at 0 */ << 13) + 
01142               ((MATCH_w_32_0 >> 14 & 0x3) /* im2_16 at 0 */ << 18) + 
01143               ((MATCH_w_32_0 >> 1 & 0x7ff) /* im11_20 at 0 */ << 20) + 
01144               (((MATCH_w_32_0 & 0x1) /* i_31 at 0 */ & 0x1) << 31);
01145             unsigned r_06 = (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
01146             nextPC = 4 + MATCH_p; 
01147             
01148             #line 182 "machine/hppa/decoder_low.m"
01149              {
01150 
01151                         RTs = instantiate(pc, name, dis_Num(imm21), dis_Reg(r_06));
01152 
01153                     }
01154 
01155             
01156             
01157             
01158           }
01159           
01160           break;
01161         case 11: 
01162           if ((MATCH_w_32_0 >> 7 & 0x3) /* uid2_23 at 0 */ == 0) 
01163             if ((MATCH_w_32_0 >> 9 & 0x1) /* addr_22 at 0 */ == 1) 
01164               if ((MATCH_w_32_0 >> 12 & 0x1) /* addr_19 at 0 */ == 1 && 
01165                 (MATCH_w_32_0 >> 5 & 0x1) /* m_26 at 0 */ == 0 || 
01166                 (MATCH_w_32_0 >> 12 & 0x1) /* addr_19 at 0 */ == 1 && 
01167                 (MATCH_w_32_0 >> 5 & 0x1) /* m_26 at 0 */ == 1 && 
01168                 (0 <= (MATCH_w_32_0 >> 13 & 0x1) /* a_18 at 0 */ && 
01169                 (MATCH_w_32_0 >> 13 & 0x1) /* a_18 at 0 */ < 2)) { 
01170                 MATCH_name = "FSTDS"; 
01171                 goto MATCH_label_a8; 
01172                 
01173               } /*opt-block*/
01174               else { 
01175                 MATCH_name = "FSTDX"; 
01176                 goto MATCH_label_a8; 
01177                 
01178               } /*opt-block*/ /*opt-block+*/
01179             else 
01180               if ((MATCH_w_32_0 >> 12 & 0x1) /* addr_19 at 0 */ == 1 && 
01181                 (MATCH_w_32_0 >> 5 & 0x1) /* m_26 at 0 */ == 0 || 
01182                 (MATCH_w_32_0 >> 12 & 0x1) /* addr_19 at 0 */ == 1 && 
01183                 (MATCH_w_32_0 >> 5 & 0x1) /* m_26 at 0 */ == 1 && 
01184                 (0 <= (MATCH_w_32_0 >> 13 & 0x1) /* a_18 at 0 */ && 
01185                 (MATCH_w_32_0 >> 13 & 0x1) /* a_18 at 0 */ < 2)) { 
01186                 MATCH_name = "FLDDS"; 
01187                 goto MATCH_label_a7; 
01188                 
01189               } /*opt-block*/
01190               else { 
01191                 MATCH_name = "FLDDX"; 
01192                 goto MATCH_label_a7; 
01193                 
01194               } /*opt-block*/ /*opt-block+*/ 
01195           else 
01196             goto MATCH_label_a0;  /*opt-block+*/
01197           break;
01198         case 12: 
01199           
01200             switch((MATCH_w_32_0 >> 9 & 0x3) /* class_21 at 0 */) {
01201               case 0: 
01202                 if ((MATCH_w_32_0 >> 13 & 0x7) /* sub_16 at 0 */ == 1) 
01203                   goto MATCH_label_a0;  /*opt-block+*/
01204                 else { 
01205                   MATCH_name = 
01206                     MATCH_name_sub_16_71[(MATCH_w_32_0 >> 13 & 0x7) 
01207                         /* sub_16 at 0 */]; 
01208                   { 
01209                     char *name = MATCH_name;
01210                     unsigned fmt = 
01211                       (MATCH_w_32_0 >> 11 & 0x3) /* fmt_19 at 0 */;
01212                     unsigned rf = (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
01213                     unsigned tf = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
01214                     nextPC = 4 + MATCH_p; 
01215                     
01216                     #line 304 "machine/hppa/decoder_low.m"
01217                      {
01218 
01219                                 RTs = instantiate(pc, name, dis_Num(fmt), dis_Freg(rf, fmt),
01220 
01221                                     dis_Freg(tf, fmt));
01222 
01223                             }
01224 
01225                     
01226                     
01227                     
01228                   }
01229                   
01230                 } /*opt-block*/
01231                 
01232                 break;
01233               case 1: 
01234                 if (0 <= (MATCH_w_32_0 >> 15 & 0x7) /* sub_14 at 0 */ && 
01235                   (MATCH_w_32_0 >> 15 & 0x7) /* sub_14 at 0 */ < 4) { 
01236                   MATCH_name = 
01237                     MATCH_name_sub_14_72[(MATCH_w_32_0 >> 15 & 0x7) 
01238                         /* sub_14 at 0 */]; 
01239                   { 
01240                     char *name = MATCH_name;
01241                     unsigned df = (MATCH_w_32_0 >> 13 & 0x3) /* df_17 at 0 */;
01242                     unsigned rf = (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
01243                     unsigned sf = (MATCH_w_32_0 >> 11 & 0x3) /* sf_19 at 0 */;
01244                     unsigned tf = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
01245                     nextPC = 4 + MATCH_p; 
01246                     
01247                     #line 308 "machine/hppa/decoder_low.m"
01248                      {
01249 
01250                                 RTs = instantiate(pc, name, dis_Num(sf), dis_Num(df),
01251 
01252                                     dis_Freg(rf, sf), dis_Freg(tf, df));
01253 
01254                             }
01255 
01256                     
01257                     
01258                     
01259                   }
01260                   
01261                 } /*opt-block*/
01262                 else 
01263                   goto MATCH_label_a0;  /*opt-block+*/
01264                 
01265                 break;
01266               case 2: 
01267                 
01268                   switch((MATCH_w_32_0 >> 13 & 0x7) /* sub_16 at 0 */) {
01269                     case 0: 
01270                       MATCH_name = 
01271                         MATCH_name_sub_16_73[(MATCH_w_32_0 >> 13 & 0x7) 
01272                             /* sub_16 at 0 */]; 
01273                       goto MATCH_label_a9; 
01274                       
01275                       break;
01276                     case 1: 
01277                       MATCH_name = 
01278                         MATCH_name_sub_16_71[(MATCH_w_32_0 >> 13 & 0x7) 
01279                             /* sub_16 at 0 */]; 
01280                       goto MATCH_label_a9; 
01281                       
01282                       break;
01283                     case 2: case 3: case 4: case 5: case 6: case 7: 
01284                       goto MATCH_label_a0; break;
01285                     default: assert(0);
01286                   } /* (MATCH_w_32_0 >> 13 & 0x7) -- sub_16 at 0 --*/ 
01287                 break;
01288               case 3: 
01289                 
01290                   switch((MATCH_w_32_0 >> 13 & 0x7) /* sub_16 at 0 */) {
01291                     case 0: 
01292                       MATCH_name = 
01293                         MATCH_name_sub_16_74[(MATCH_w_32_0 >> 13 & 0x7) 
01294                             /* sub_16 at 0 */]; 
01295                       goto MATCH_label_a10; 
01296                       
01297                       break;
01298                     case 1: case 2: case 3: 
01299                       MATCH_name = 
01300                         MATCH_name_sub_16_73[(MATCH_w_32_0 >> 13 & 0x7) 
01301                             /* sub_16 at 0 */]; 
01302                       goto MATCH_label_a10; 
01303                       
01304                       break;
01305                     case 4: case 5: case 6: case 7: 
01306                       goto MATCH_label_a0; break;
01307                     default: assert(0);
01308                   } /* (MATCH_w_32_0 >> 13 & 0x7) -- sub_16 at 0 --*/ 
01309                 break;
01310               default: assert(0);
01311             } /* (MATCH_w_32_0 >> 9 & 0x3) -- class_21 at 0 --*/ 
01312           break;
01313         case 13: 
01314           MATCH_name = 
01315             MATCH_name_op_58[(MATCH_w_32_0 >> 26 & 0x3f) /* op at 0 */]; 
01316           { 
01317             char *name = MATCH_name;
01318             unsigned b = (MATCH_w_32_0 >> 21 & 0x1f) /* b_06 at 0 */;
01319             unsigned ldisp = 
01320               (sign_extend((MATCH_w_32_0 & 0x1) /* i_31 at 0 */, 1) << 13) + 
01321               (MATCH_w_32_0 >> 1 & 0x1fff) /* im13_18 at 0 */;
01322             unsigned t = (MATCH_w_32_0 >> 16 & 0x1f) /* t_11 at 0 */;
01323             nextPC = 4 + MATCH_p; 
01324             
01325             #line 221 "machine/hppa/decoder_low.m"
01326              {
01327 
01328                         RTs = instantiate(pc, name, dis_Num(ldisp), dis_Reg(b), dis_Reg(t));
01329 
01330                     }
01331 
01332             
01333             
01334             
01335           }
01336           
01337           break;
01338         case 14: 
01339           
01340             switch((MATCH_w_32_0 >> 9 & 0x3) /* class_21 at 0 */) {
01341               case 0: 
01342                 goto MATCH_label_a0; break;
01343               case 1: 
01344                 if (0 <= (MATCH_w_32_0 >> 15 & 0x7) /* sub_14 at 0 */ && 
01345                   (MATCH_w_32_0 >> 15 & 0x7) /* sub_14 at 0 */ < 4) { 
01346                   MATCH_name = 
01347                     MATCH_name_sub_14_75[(MATCH_w_32_0 >> 15 & 0x7) 
01348                         /* sub_14 at 0 */]; 
01349                   { 
01350                     char *name = MATCH_name;
01351                     unsigned df = (MATCH_w_32_0 >> 13 & 0x3) /* df_17 at 0 */;
01352                     unsigned rf = 
01353                       ((MATCH_w_32_0 >> 7 & 0x1) /* r1_24 at 0 */ << 5) + 
01354                       (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
01355                     unsigned sf = (MATCH_w_32_0 >> 11 & 0x3) /* sf_19 at 0 */;
01356                     unsigned tf = 
01357                       ((MATCH_w_32_0 >> 6 & 0x1) /* t_25 at 0 */ << 5) + 
01358                       (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
01359                     nextPC = 4 + MATCH_p; 
01360                     
01361                     #line 308 "machine/hppa/decoder_low.m"
01362                      {
01363 
01364                                 RTs = instantiate(pc, name, dis_Num(sf), dis_Num(df),
01365 
01366                                     dis_Freg(rf, sf), dis_Freg(tf, df));
01367 
01368                             }
01369 
01370                     
01371                     
01372                     
01373                   }
01374                   
01375                 } /*opt-block*/
01376                 else 
01377                   goto MATCH_label_a0;  /*opt-block+*/
01378                 
01379                 break;
01380               case 2: 
01381                 
01382                   switch((MATCH_w_32_0 >> 13 & 0x7) /* sub_16 at 0 */) {
01383                     case 0: 
01384                       MATCH_name = "FCMP.E"; goto MATCH_label_a11; break;
01385                     case 1: 
01386                       MATCH_name = 
01387                         MATCH_name_sub_16_74[(MATCH_w_32_0 >> 13 & 0x7) 
01388                             /* sub_16 at 0 */]; 
01389                       goto MATCH_label_a11; 
01390                       
01391                       break;
01392                     case 2: case 3: case 4: case 5: case 6: case 7: 
01393                       goto MATCH_label_a0; break;
01394                     default: assert(0);
01395                   } /* (MATCH_w_32_0 >> 13 & 0x7) -- sub_16 at 0 --*/ 
01396                 break;
01397               case 3: 
01398                 
01399                   switch((MATCH_w_32_0 >> 13 & 0x7) /* sub_16 at 0 */) {
01400                     case 0: 
01401                       if ((MATCH_w_32_0 >> 8 & 0x1) /* x_23 at 0 */ == 0) { 
01402                         MATCH_name = "FADD.E"; 
01403                         goto MATCH_label_a12; 
01404                         
01405                       } /*opt-block*/
01406                       else 
01407                         goto MATCH_label_a0;  /*opt-block+*/
01408                       
01409                       break;
01410                     case 1: 
01411                       if ((MATCH_w_32_0 >> 8 & 0x1) /* x_23 at 0 */ == 0) { 
01412                         MATCH_name = "FSUB.E"; 
01413                         goto MATCH_label_a12; 
01414                         
01415                       } /*opt-block*/
01416                       else 
01417                         goto MATCH_label_a0;  /*opt-block+*/
01418                       
01419                       break;
01420                     case 2: 
01421                       if ((MATCH_w_32_0 >> 8 & 0x1) /* x_23 at 0 */ == 1) { 
01422                         unsigned fr1 = 
01423                           ((MATCH_w_32_0 >> 7 & 0x1) /* r1_24 at 0 */ << 5) + 
01424                           (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
01425                         unsigned fr2 = 
01426                           ((MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ << 5) + 
01427                           (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
01428                         unsigned frt = 
01429                           ((MATCH_w_32_0 >> 6 & 0x1) /* t_25 at 0 */ << 5) + 
01430                           (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
01431                         nextPC = 4 + MATCH_p; 
01432                         
01433                         #line 320 "machine/hppa/decoder_low.m"
01434                          {
01435 
01436                                     // This instruction has fixed register sizes
01437 
01438                                     RTs = instantiate(pc, "XMPYU", dis_Freg(fr1, 0), dis_Freg(fr2, 0),
01439 
01440                                         dis_Freg(frt, 1));
01441 
01442                                 }
01443 
01444                         //      | LDSID(s2_16,b_06,t_27)[name] => {
01445 
01446                         //      }
01447 
01448                         //      | MTSP(r_11,sr)[name] => {
01449 
01450                         //      }
01451 
01452                         //      | MFSP(sr,t_27)[name] => {
01453 
01454                         //      }
01455 
01456                         
01457                         
01458                         
01459                       } /*opt-block*//*opt-block+*/
01460                       else { 
01461                         MATCH_name = "FMPY.E"; 
01462                         goto MATCH_label_a12; 
01463                         
01464                       } /*opt-block*/
01465                       
01466                       break;
01467                     case 3: 
01468                       if ((MATCH_w_32_0 >> 8 & 0x1) /* x_23 at 0 */ == 0) { 
01469                         MATCH_name = "FDIV.E"; 
01470                         goto MATCH_label_a12; 
01471                         
01472                       } /*opt-block*/
01473                       else 
01474                         goto MATCH_label_a0;  /*opt-block+*/
01475                       
01476                       break;
01477                     case 4: case 5: case 6: case 7: 
01478                       goto MATCH_label_a0; break;
01479                     default: assert(0);
01480                   } /* (MATCH_w_32_0 >> 13 & 0x7) -- sub_16 at 0 --*/ 
01481                 break;
01482               default: assert(0);
01483             } /* (MATCH_w_32_0 >> 9 & 0x3) -- class_21 at 0 --*/ 
01484           break;
01485         case 16: case 17: case 18: case 19: 
01486           MATCH_name = 
01487             MATCH_name_op_58[(MATCH_w_32_0 >> 26 & 0x3f) /* op at 0 */]; 
01488           { 
01489             char *name = MATCH_name;
01490             unsigned b = (MATCH_w_32_0 >> 21 & 0x1f) /* b_06 at 0 */;
01491             unsigned c_addr = addressToPC(MATCH_p);
01492             unsigned r_11 = (MATCH_w_32_0 >> 16 & 0x1f) /* t_11 at 0 */;
01493             unsigned s = (MATCH_w_32_0 >> 14 & 0x3) /* s2_16 at 0 */;
01494             unsigned xd = addressToPC(MATCH_p);
01495             nextPC = 4 + MATCH_p; 
01496             
01497             #line 213 "machine/hppa/decoder_low.m"
01498              {
01499 
01500                         RTs = instantiate(pc, name, dis_c_addr(c_addr), dis_xd(xd),
01501 
01502                             dis_Sreg(s), dis_Reg(b), dis_Reg(r_11));
01503 
01504                     }
01505 
01506             
01507             
01508             
01509           }
01510           
01511           break;
01512         case 24: case 25: case 26: case 27: 
01513           MATCH_name = 
01514             MATCH_name_op_58[(MATCH_w_32_0 >> 26 & 0x3f) /* op at 0 */]; 
01515           { 
01516             char *name = MATCH_name;
01517             unsigned b = (MATCH_w_32_0 >> 21 & 0x1f) /* b_06 at 0 */;
01518             unsigned c_addr = addressToPC(MATCH_p);
01519             unsigned r_11 = (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
01520             unsigned s = (MATCH_w_32_0 >> 14 & 0x3) /* s2_16 at 0 */;
01521             unsigned xd = addressToPC(MATCH_p);
01522             nextPC = 4 + MATCH_p; 
01523             
01524             #line 217 "machine/hppa/decoder_low.m"
01525              {
01526 
01527                         RTs = instantiate(pc, name, dis_c_addr(c_addr), dis_Reg(r_11),
01528 
01529                             dis_xd(xd), dis_Sreg(s), dis_Reg(b));
01530 
01531                     }
01532 
01533             
01534             
01535             
01536           }
01537           
01538           break;
01539         case 36: 
01540           MATCH_name = "CMPICLR"; goto MATCH_label_a13; break;
01541         case 37: 
01542           if ((MATCH_w_32_0 >> 11 & 0x1) /* ext_20 at 0 */ == 1 && 
01543             (0 <= (MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ && 
01544             (MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ < 2)) { 
01545             MATCH_name = "SUBI.v"; 
01546             goto MATCH_label_a13; 
01547             
01548           } /*opt-block*/
01549           else { MATCH_name = "SUBI"; goto MATCH_label_a13; } /*opt-block*/
01550           
01551           break;
01552         case 44: 
01553           if ((MATCH_w_32_0 >> 11 & 0x1) /* ext_20 at 0 */ == 1 && 
01554             (0 <= (MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ && 
01555             (MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ < 2)) { 
01556             MATCH_name = "ADDI.t.v"; 
01557             goto MATCH_label_a13; 
01558             
01559           } /*opt-block*/
01560           else { MATCH_name = "ADDI.t"; goto MATCH_label_a13; } /*opt-block*/
01561           
01562           break;
01563         case 45: 
01564           if ((MATCH_w_32_0 >> 11 & 0x1) /* ext_20 at 0 */ == 1 && 
01565             (0 <= (MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ && 
01566             (MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ < 2)) { 
01567             MATCH_name = "ADDI.v"; 
01568             goto MATCH_label_a13; 
01569             
01570           } /*opt-block*/
01571           else { MATCH_name = "ADDI"; goto MATCH_label_a13; } /*opt-block*/
01572           
01573           break;
01574         case 52: 
01575           if ((MATCH_w_32_0 >> 12 & 0x1) /* cl_19 at 0 */ == 1) 
01576             if ((MATCH_w_32_0 >> 11 & 0x1) /* p_20 at 0 */ == 1 && 
01577               (0 <= (MATCH_w_32_0 >> 10 & 0x1) /* se_21 at 0 */ && 
01578               (MATCH_w_32_0 >> 10 & 0x1) /* se_21 at 0 */ < 2)) { 
01579               MATCH_name = MATCH_name_se_21_90[(MATCH_w_32_0 >> 10 & 0x1) 
01580                     /* se_21 at 0 */]; 
01581               { 
01582                 char *name = MATCH_name;
01583                 unsigned c = addressToPC(MATCH_p);
01584                 unsigned len = 32 - (MATCH_w_32_0 & 0x1f) /* clen5_27 at 0 */;
01585                 unsigned p = (MATCH_w_32_0 >> 5 & 0x1f) /* pos5_22 at 0 */;
01586                 unsigned r = (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
01587                 unsigned t = (MATCH_w_32_0 >> 16 & 0x1f) /* t_11 at 0 */;
01588                 nextPC = 4 + MATCH_p; 
01589                 
01590                 #line 236 "machine/hppa/decoder_low.m"
01591                  {
01592 
01593                             RTs = instantiate(pc, name, dis_Reg(r), dis_Num(p), dis_Num(len),
01594 
01595                                 dis_Reg(t), c_c(c, condvalue));
01596 
01597                         }
01598 
01599                 
01600                 
01601                 
01602               }
01603               
01604             } /*opt-block*/
01605             else { 
01606               MATCH_name = MATCH_name_se_21_89[(MATCH_w_32_0 >> 10 & 0x1) 
01607                     /* se_21 at 0 */]; 
01608               { 
01609                 char *name = MATCH_name;
01610                 unsigned c = addressToPC(MATCH_p);
01611                 unsigned len = 32 - (MATCH_w_32_0 & 0x1f) /* clen5_27 at 0 */;
01612                 unsigned r = (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
01613                 unsigned t = (MATCH_w_32_0 >> 16 & 0x1f) /* t_11 at 0 */;
01614                 nextPC = 4 + MATCH_p; 
01615                 
01616                 #line 232 "machine/hppa/decoder_low.m"
01617                  {
01618 
01619                             RTs = instantiate(pc, name, dis_Reg(r), dis_Num(len), dis_Reg(t),
01620 
01621                                 c_c(c, condvalue));
01622 
01623                         }
01624 
01625                 
01626                 
01627                 
01628               }
01629               
01630             } /*opt-block*/ /*opt-block+*/
01631           else 
01632             if ((MATCH_w_32_0 >> 10 & 0x1) /* se_21 at 0 */ == 1) 
01633               goto MATCH_label_a0;  /*opt-block+*/
01634             else 
01635               if ((MATCH_w_32_0 >> 11 & 0x1) /* p_20 at 0 */ == 1) { 
01636                 MATCH_name = MATCH_name_p_20_88[(MATCH_w_32_0 >> 11 & 0x1) 
01637                       /* p_20 at 0 */]; 
01638                 { 
01639                   char *name = MATCH_name;
01640                   unsigned c = addressToPC(MATCH_p);
01641                   unsigned p = 
01642                     31 - (MATCH_w_32_0 >> 5 & 0x1f) /* pos5_22 at 0 */;
01643                   unsigned r1 = (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
01644                   unsigned r2 = (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
01645                   unsigned t = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
01646                   nextPC = 4 + MATCH_p; 
01647                   
01648                   #line 228 "machine/hppa/decoder_low.m"
01649                    {
01650 
01651                               RTs = instantiate(pc, name, dis_Reg(r1), dis_Reg(r2), dis_Num(p),
01652 
01653                                   dis_Reg(t), c_c(c, condvalue));
01654 
01655                           }
01656 
01657                   
01658                   
01659                   
01660                 }
01661                 
01662               } /*opt-block*/
01663               else { 
01664                 MATCH_name = MATCH_name_p_20_88[(MATCH_w_32_0 >> 11 & 0x1) 
01665                       /* p_20 at 0 */]; 
01666                 { 
01667                   char *name = MATCH_name;
01668                   unsigned c = addressToPC(MATCH_p);
01669                   unsigned r1 = (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
01670                   unsigned r2 = (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
01671                   unsigned t = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
01672                   nextPC = 4 + MATCH_p; 
01673                   
01674                   #line 224 "machine/hppa/decoder_low.m"
01675                    {
01676 
01677                               RTs = instantiate(pc, name, dis_Reg(r1), dis_Reg(r2), dis_Reg(t),
01678 
01679                                   c_c(c, condvalue));
01680 
01681                           }
01682 
01683                   
01684                   
01685                   
01686                 }
01687                 
01688               } /*opt-block*/ /*opt-block+*/ 
01689           break;
01690         case 53: 
01691           if ((MATCH_w_32_0 >> 12 & 0x1) /* cl_19 at 0 */ == 1) 
01692             if ((MATCH_w_32_0 >> 11 & 0x1) /* p_20 at 0 */ == 1 && 
01693               (0 <= (MATCH_w_32_0 >> 10 & 0x1) /* se_21 at 0 */ && 
01694               (MATCH_w_32_0 >> 10 & 0x1) /* se_21 at 0 */ < 2)) { 
01695               MATCH_name = MATCH_name_se_21_94[(MATCH_w_32_0 >> 10 & 0x1) 
01696                     /* se_21 at 0 */]; 
01697               { 
01698                 char *name = MATCH_name;
01699                 unsigned c = addressToPC(MATCH_p);
01700                 unsigned i = 
01701                   ((sign_extend((MATCH_w_32_0 >> 16 & 0x1) /* im1_15 at 0 */, 
01702                               1) & 0xfffffff) << 4) + 
01703                   (MATCH_w_32_0 >> 17 & 0xf) /* im4_11 at 0 */;
01704                 unsigned len = 32 - (MATCH_w_32_0 & 0x1f) /* clen5_27 at 0 */;
01705                 unsigned p = 
01706                   31 - (MATCH_w_32_0 >> 5 & 0x1f) /* pos5_22 at 0 */;
01707                 unsigned t = (MATCH_w_32_0 >> 21 & 0x1f) /* t_06 at 0 */;
01708                 nextPC = 4 + MATCH_p; 
01709                 
01710                 #line 252 "machine/hppa/decoder_low.m"
01711                  {
01712 
01713                             RTs = instantiate(pc, name, dis_Num(i), dis_Num(p), dis_Num(len),
01714 
01715                                 dis_Reg(t), c_c(c, condvalue));
01716 
01717                         }
01718 
01719                 
01720                 
01721                 
01722               }
01723               
01724             } /*opt-block*/
01725             else { 
01726               MATCH_name = MATCH_name_se_21_93[(MATCH_w_32_0 >> 10 & 0x1) 
01727                     /* se_21 at 0 */]; 
01728               { 
01729                 char *name = MATCH_name;
01730                 unsigned c = addressToPC(MATCH_p);
01731                 unsigned i = 
01732                   ((sign_extend((MATCH_w_32_0 >> 16 & 0x1) /* im1_15 at 0 */, 
01733                               1) & 0xfffffff) << 4) + 
01734                   (MATCH_w_32_0 >> 17 & 0xf) /* im4_11 at 0 */;
01735                 unsigned len = 32 - (MATCH_w_32_0 & 0x1f) /* clen5_27 at 0 */;
01736                 unsigned t = (MATCH_w_32_0 >> 21 & 0x1f) /* t_06 at 0 */;
01737                 nextPC = 4 + MATCH_p; 
01738                 
01739                 #line 248 "machine/hppa/decoder_low.m"
01740                  {
01741 
01742                             RTs = instantiate(pc, name, dis_Num(i), dis_Num(len), dis_Reg(t),
01743 
01744                                 c_c(c, condvalue));
01745 
01746                         }
01747 
01748                 
01749                 
01750                 
01751               }
01752               
01753             } /*opt-block*/ /*opt-block+*/
01754           else 
01755             if ((MATCH_w_32_0 >> 11 & 0x1) /* p_20 at 0 */ == 1 && 
01756               (0 <= (MATCH_w_32_0 >> 10 & 0x1) /* se_21 at 0 */ && 
01757               (MATCH_w_32_0 >> 10 & 0x1) /* se_21 at 0 */ < 2)) { 
01758               MATCH_name = MATCH_name_se_21_92[(MATCH_w_32_0 >> 10 & 0x1) 
01759                     /* se_21 at 0 */]; 
01760               { 
01761                 char *name = MATCH_name;
01762                 unsigned c = addressToPC(MATCH_p);
01763                 unsigned len = 32 - (MATCH_w_32_0 & 0x1f) /* clen5_27 at 0 */;
01764                 unsigned p = 
01765                   31 - (MATCH_w_32_0 >> 5 & 0x1f) /* pos5_22 at 0 */;
01766                 unsigned r = (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
01767                 unsigned t = (MATCH_w_32_0 >> 21 & 0x1f) /* t_06 at 0 */;
01768                 nextPC = 4 + MATCH_p; 
01769                 
01770                 #line 244 "machine/hppa/decoder_low.m"
01771                  {
01772 
01773                             RTs = instantiate(pc, name, dis_Reg(r), dis_Num(p), dis_Num(len),
01774 
01775                                 dis_Reg(t), c_c(c, condvalue));
01776 
01777                         }
01778 
01779                 
01780                 
01781                 
01782               }
01783               
01784             } /*opt-block*/
01785             else { 
01786               MATCH_name = MATCH_name_se_21_91[(MATCH_w_32_0 >> 10 & 0x1) 
01787                     /* se_21 at 0 */]; 
01788               { 
01789                 char *name = MATCH_name;
01790                 unsigned c = addressToPC(MATCH_p);
01791                 unsigned len = 32 - (MATCH_w_32_0 & 0x1f) /* clen5_27 at 0 */;
01792                 unsigned r = (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
01793                 unsigned t = (MATCH_w_32_0 >> 21 & 0x1f) /* t_06 at 0 */;
01794                 nextPC = 4 + MATCH_p; 
01795                 
01796                 #line 240 "machine/hppa/decoder_low.m"
01797                  {
01798 
01799                             RTs = instantiate(pc, name, dis_Reg(r), dis_Num(len), dis_Reg(t),
01800 
01801                                 c_c(c, condvalue));
01802 
01803                         }
01804 
01805                 
01806                 
01807                 
01808               }
01809               
01810             } /*opt-block*/ /*opt-block+*/
01811           break;
01812         case 58: 
01813           
01814             switch((MATCH_w_32_0 >> 13 & 0x7) /* ext3_16 at 0 */) {
01815               case 0: 
01816                 MATCH_name = "BL"; goto MATCH_label_a14; break;
01817               case 1: 
01818                 MATCH_name = "GATE"; goto MATCH_label_a14; break;
01819               case 2: 
01820                 if ((MATCH_w_32_0 >> 12 & 0x1) /* ve_19 at 0 */ == 1) 
01821                   goto MATCH_label_a0;  /*opt-block+*/
01822                 else { 
01823                   MATCH_name = "BLR"; 
01824                   { 
01825                     char *name = MATCH_name;
01826                     unsigned nulli = addressToPC(MATCH_p);
01827                     unsigned t_06 = 
01828                       (MATCH_w_32_0 >> 21 & 0x1f) /* t_06 at 0 */;
01829                     unsigned x_11 = 
01830                       (MATCH_w_32_0 >> 16 & 0x1f) /* x_11 at 0 */;
01831                     nextPC = 4 + MATCH_p; 
01832                     
01833                     #line 266 "machine/hppa/decoder_low.m"
01834                      {
01835 
01836                                 /* BLR,n x,t */
01837 
01838                                 RTs = instantiate(pc, name, dis_Reg(x_11), dis_Reg(t_06));
01839 
01840                                 not_used(nulli);
01841 
01842                             }
01843 
01844                     
01845                     
01846                     
01847                   }
01848                   
01849                 } /*opt-block*/
01850                 
01851                 break;
01852               case 3: 
01853                 goto MATCH_label_a0; break;
01854               case 4: 
01855                 MATCH_name = "BL.PUSH"; goto MATCH_label_a14; break;
01856               case 5: 
01857                 MATCH_name = "BL.LONG"; 
01858                 { 
01859                   char *name = MATCH_name;
01860                   unsigned nulli = addressToPC(MATCH_p);
01861                   unsigned ubr_target = 
01862                     8 + 
01863                     ((MATCH_w_32_0 >> 3 & 0x3ff) /* w10_19 at 0 */ << 2) + 
01864                     ((MATCH_w_32_0 >> 2 & 0x1) /* w_29 at 0 */ << 12) + 
01865                     ((MATCH_w_32_0 >> 16 & 0x1f) /* w5_11 at 0 */ << 13) + 
01866                     ((MATCH_w_32_0 >> 21 & 0x1f) /* w5_06 at 0 */ << 18) + 
01867                     (sign_extend((MATCH_w_32_0 & 0x1) /* w_31 at 0 */, 
01868                                 1) << 23);
01869                   nextPC = 4 + MATCH_p; 
01870                   
01871                   #line 261 "machine/hppa/decoder_low.m"
01872                    {
01873 
01874                               /* BL.LONG cmplt,n  target,2) */
01875 
01876                               RTs = instantiate(pc, name, dis_Num(ubr_target));
01877 
01878                               not_used(nulli);
01879 
01880                           }
01881 
01882                   
01883                   
01884                   
01885                 }
01886                 
01887                 break;
01888               case 6: 
01889                 if ((MATCH_w_32_0 >> 12 & 0x1) /* ve_19 at 0 */ == 1 && 
01890                   (0 <= (MATCH_w_32_0 >> 1 & 0x1) /* n_30 at 0 */ && 
01891                   (MATCH_w_32_0 >> 1 & 0x1) /* n_30 at 0 */ < 2)) { 
01892                   MATCH_name = "BVE"; 
01893                   goto MATCH_label_a15; 
01894                   
01895                 } /*opt-block*/
01896                 else { 
01897                   MATCH_name = "BV"; 
01898                   { 
01899                     char *name = MATCH_name;
01900                     unsigned b_06 = 
01901                       (MATCH_w_32_0 >> 21 & 0x1f) /* b_06 at 0 */;
01902                     unsigned nulli = addressToPC(MATCH_p);
01903                     unsigned x_11 = 
01904                       (MATCH_w_32_0 >> 16 & 0x1f) /* x_11 at 0 */;
01905                     nextPC = 4 + MATCH_p; 
01906                     
01907                     #line 271 "machine/hppa/decoder_low.m"
01908                      {
01909 
01910                                 /* BV,n x_11(b_06) */
01911 
01912                                 RTs = instantiate(pc, name, dis_Reg(x_11), dis_Reg(b_06));
01913 
01914                                 not_used(nulli);
01915 
01916                             }
01917 
01918                     
01919                     
01920                     
01921                   }
01922                   
01923                 } /*opt-block*/
01924                 
01925                 break;
01926               case 7: 
01927                 if ((MATCH_w_32_0 >> 12 & 0x1) /* ve_19 at 0 */ == 0) 
01928                   goto MATCH_label_a0;  /*opt-block+*/
01929                 else { 
01930                   MATCH_name = "BVE.l"; 
01931                   goto MATCH_label_a15; 
01932                   
01933                 } /*opt-block*/
01934                 
01935                 break;
01936               default: assert(0);
01937             } /* (MATCH_w_32_0 >> 13 & 0x7) -- ext3_16 at 0 --*/ 
01938           break;
01939         default: assert(0);
01940       } /* (MATCH_w_32_0 >> 26 & 0x3f) -- op at 0 --*/ 
01941     
01942   }goto MATCH_finished_a; 
01943   
01944   MATCH_label_a0: (void)0; /*placeholder for label*/ 
01945     { 
01946       nextPC = MATCH_p; 
01947       
01948       #line 331 "machine/hppa/decoder_low.m"
01949       {
01950 
01951                 //RTs = NULL;
01952 
01953                   result.valid = false;
01954 
01955       cout << "Undecoded instruction " << hex << *(int*)hostPC << " at " << pc << " (opcode " << ((*(unsigned*)hostPC) >> 26) << ")\n";
01956 
01957               }
01958 
01959       
01960       
01961       
01962     } 
01963     goto MATCH_finished_a; 
01964     
01965   MATCH_label_a1: (void)0; /*placeholder for label*/ 
01966     { 
01967       char *name = MATCH_name;
01968       nextPC = 4 + MATCH_p; 
01969       
01970       #line 287 "machine/hppa/decoder_low.m"
01971        {
01972 
01973                   RTs = instantiate(pc, name);
01974 
01975               }
01976 
01977       
01978       
01979       
01980     } 
01981     goto MATCH_finished_a; 
01982     
01983   MATCH_label_a2: (void)0; /*placeholder for label*/ 
01984     { 
01985       char *name = MATCH_name;
01986       unsigned cmplt = addressToPC(MATCH_p);
01987       unsigned r_06 = (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
01988       unsigned r_11 = (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
01989       unsigned t_27 = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
01990       nextPC = 4 + MATCH_p; 
01991       
01992       #line 172 "machine/hppa/decoder_low.m"
01993        {
01994 
01995                   /*  Arith,cc_16   r_11, r_06, t_27 */
01996 
01997                   RTs = instantiate(pc, name, dis_Reg(r_11), dis_Reg(r_06),
01998 
01999                     dis_Reg(t_27),c_c(cmplt, condvalue));
02000 
02001               }
02002 
02003       
02004       
02005       
02006     } 
02007     goto MATCH_finished_a; 
02008     
02009   MATCH_label_a3: (void)0; /*placeholder for label*/ 
02010     { 
02011       char *name = MATCH_name;
02012       unsigned b = (MATCH_w_32_0 >> 21 & 0x1f) /* b_06 at 0 */;
02013       unsigned c_addr = addressToPC(MATCH_p);
02014       unsigned s = (MATCH_w_32_0 >> 14 & 0x3) /* s2_16 at 0 */;
02015       unsigned t_27 = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
02016       unsigned xd = addressToPC(MATCH_p);
02017       nextPC = 4 + MATCH_p; 
02018       
02019       #line 188 "machine/hppa/decoder_low.m"
02020        {
02021 
02022                   RTs = instantiate(pc, name, dis_c_addr(c_addr),
02023 
02024                     dis_xd(xd), dis_Sreg(s),
02025 
02026                       dis_Reg(b), dis_Reg(t_27));
02027 
02028               }
02029 
02030       
02031       
02032       
02033     } 
02034     goto MATCH_finished_a; 
02035     
02036   MATCH_label_a4: (void)0; /*placeholder for label*/ 
02037     { 
02038       char *name = MATCH_name;
02039       unsigned b = (MATCH_w_32_0 >> 21 & 0x1f) /* b_06 at 0 */;
02040       unsigned c_addr = addressToPC(MATCH_p);
02041       unsigned r_11 = (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
02042       unsigned s = (MATCH_w_32_0 >> 14 & 0x3) /* s2_16 at 0 */;
02043       unsigned xd = addressToPC(MATCH_p);
02044       nextPC = 4 + MATCH_p; 
02045       
02046       #line 193 "machine/hppa/decoder_low.m"
02047        {
02048 
02049                   RTs = instantiate(pc, name, dis_c_addr(c_addr), dis_Reg(r_11),
02050 
02051                       dis_xd(xd), dis_Sreg(s), dis_Reg(b));
02052 
02053               }
02054 
02055       
02056       
02057       
02058     } 
02059     goto MATCH_finished_a; 
02060     
02061   MATCH_label_a5: (void)0; /*placeholder for label*/ 
02062     { 
02063       char *name = MATCH_name;
02064       unsigned b = (MATCH_w_32_0 >> 21 & 0x1f) /* b_06 at 0 */;
02065       unsigned c_addr = addressToPC(MATCH_p);
02066       unsigned s = (MATCH_w_32_0 >> 14 & 0x3) /* s2_16 at 0 */;
02067       unsigned t_27 = 
02068         ((MATCH_w_32_0 >> 6 & 0x1) /* t_25 at 0 */ << 5) + 
02069         (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
02070       unsigned xd = addressToPC(MATCH_p);
02071       nextPC = 4 + MATCH_p; 
02072       
02073       #line 197 "machine/hppa/decoder_low.m"
02074        {
02075 
02076                   RTs = instantiate(pc, name, dis_c_addr(c_addr), dis_xd(xd),
02077 
02078                       dis_Sreg(s), dis_Reg(b), dis_Freg(t_27, 0));
02079 
02080               }
02081 
02082       
02083       
02084       
02085     } 
02086     goto MATCH_finished_a; 
02087     
02088   MATCH_label_a6: (void)0; /*placeholder for label*/ 
02089     { 
02090       char *name = MATCH_name;
02091       unsigned b = (MATCH_w_32_0 >> 21 & 0x1f) /* b_06 at 0 */;
02092       unsigned c_addr = addressToPC(MATCH_p);
02093       unsigned r_27 = 
02094         ((MATCH_w_32_0 >> 6 & 0x1) /* r_25 at 0 */ << 5) + 
02095         (MATCH_w_32_0 & 0x1f) /* r_27 at 0 */;
02096       unsigned s = (MATCH_w_32_0 >> 14 & 0x3) /* s2_16 at 0 */;
02097       unsigned xd = addressToPC(MATCH_p);
02098       nextPC = 4 + MATCH_p; 
02099       
02100       #line 201 "machine/hppa/decoder_low.m"
02101        {
02102 
02103                   RTs = instantiate(pc, name, dis_c_addr(c_addr), dis_Freg(r_27, 0),
02104 
02105                       dis_xd(xd), dis_Sreg(s), dis_Reg(b));
02106 
02107               }
02108 
02109       
02110       
02111       
02112     } 
02113     goto MATCH_finished_a; 
02114     
02115   MATCH_label_a7: (void)0; /*placeholder for label*/ 
02116     { 
02117       char *name = MATCH_name;
02118       unsigned b = (MATCH_w_32_0 >> 21 & 0x1f) /* b_06 at 0 */;
02119       unsigned c_addr = addressToPC(MATCH_p);
02120       unsigned s = (MATCH_w_32_0 >> 14 & 0x3) /* s2_16 at 0 */;
02121       unsigned t_27 = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
02122       unsigned xd = addressToPC(MATCH_p);
02123       nextPC = 4 + MATCH_p; 
02124       
02125       #line 205 "machine/hppa/decoder_low.m"
02126        {
02127 
02128                   RTs = instantiate(pc, name, dis_c_addr(c_addr), dis_xd(xd),
02129 
02130                       dis_Sreg(s), dis_Reg(b), dis_Freg(t_27, 1));
02131 
02132               }
02133 
02134       
02135       
02136       
02137     } 
02138     goto MATCH_finished_a; 
02139     
02140   MATCH_label_a8: (void)0; /*placeholder for label*/ 
02141     { 
02142       char *name = MATCH_name;
02143       unsigned b = (MATCH_w_32_0 >> 21 & 0x1f) /* b_06 at 0 */;
02144       unsigned c_addr = addressToPC(MATCH_p);
02145       unsigned r_27 = (MATCH_w_32_0 & 0x1f) /* r_27 at 0 */;
02146       unsigned s = (MATCH_w_32_0 >> 14 & 0x3) /* s2_16 at 0 */;
02147       unsigned xd = addressToPC(MATCH_p);
02148       nextPC = 4 + MATCH_p; 
02149       
02150       #line 209 "machine/hppa/decoder_low.m"
02151        {
02152 
02153                   RTs = instantiate(pc, name, dis_c_addr(c_addr), dis_Freg(r_27, 1),
02154 
02155                       dis_xd(xd), dis_Sreg(s), dis_Reg(b));
02156 
02157               }
02158 
02159       
02160       
02161       
02162     } 
02163     goto MATCH_finished_a; 
02164     
02165   MATCH_label_a9: (void)0; /*placeholder for label*/ 
02166     { 
02167       char *name = MATCH_name;
02168       unsigned df = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
02169       unsigned rf = (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
02170       unsigned sf = (MATCH_w_32_0 >> 11 & 0x3) /* fmt_19 at 0 */;
02171       unsigned tf = (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
02172       nextPC = 4 + MATCH_p; 
02173       
02174       #line 312 "machine/hppa/decoder_low.m"
02175        {
02176 
02177                   RTs = instantiate(pc, name, dis_Num(sf), dis_Num(df),
02178 
02179                       dis_Freg(rf, sf), dis_Freg(tf, df));
02180 
02181               }
02182 
02183       
02184       
02185       
02186     } 
02187     goto MATCH_finished_a; 
02188     
02189   MATCH_label_a10: (void)0; /*placeholder for label*/ 
02190     { 
02191       char *name = MATCH_name;
02192       unsigned fmt = (MATCH_w_32_0 >> 11 & 0x3) /* fmt_19 at 0 */;
02193       unsigned fr1 = (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
02194       unsigned fr2 = (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
02195       unsigned frt = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
02196       nextPC = 4 + MATCH_p; 
02197       
02198       #line 316 "machine/hppa/decoder_low.m"
02199        {
02200 
02201                   RTs = instantiate(pc, name, dis_Num(fmt), dis_Freg(fr1, fmt),
02202 
02203                       dis_Freg(fr2, fmt), dis_Freg(frt, fmt));
02204 
02205               }
02206 
02207       
02208       
02209       
02210     } 
02211     goto MATCH_finished_a; 
02212     
02213   MATCH_label_a11: (void)0; /*placeholder for label*/ 
02214     { 
02215       char *name = MATCH_name;
02216       unsigned df = (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
02217       unsigned rf = 
02218         ((MATCH_w_32_0 >> 7 & 0x1) /* r1_24 at 0 */ << 5) + 
02219         (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
02220       unsigned sf = (MATCH_w_32_0 >> 11 & 0x1) /* f_20 at 0 */;
02221       unsigned tf = 
02222         ((MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ << 5) + 
02223         (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
02224       nextPC = 4 + MATCH_p; 
02225       
02226       #line 312 "machine/hppa/decoder_low.m"
02227        {
02228 
02229                   RTs = instantiate(pc, name, dis_Num(sf), dis_Num(df),
02230 
02231                       dis_Freg(rf, sf), dis_Freg(tf, df));
02232 
02233               }
02234 
02235       
02236       
02237       
02238     } 
02239     goto MATCH_finished_a; 
02240     
02241   MATCH_label_a12: (void)0; /*placeholder for label*/ 
02242     { 
02243       char *name = MATCH_name;
02244       unsigned fmt = (MATCH_w_32_0 >> 11 & 0x1) /* f_20 at 0 */;
02245       unsigned fr1 = 
02246         ((MATCH_w_32_0 >> 7 & 0x1) /* r1_24 at 0 */ << 5) + 
02247         (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
02248       unsigned fr2 = 
02249         ((MATCH_w_32_0 >> 12 & 0x1) /* f_19 at 0 */ << 5) + 
02250         (MATCH_w_32_0 >> 16 & 0x1f) /* r_11 at 0 */;
02251       unsigned frt = 
02252         ((MATCH_w_32_0 >> 6 & 0x1) /* t_25 at 0 */ << 5) + 
02253         (MATCH_w_32_0 & 0x1f) /* t_27 at 0 */;
02254       nextPC = 4 + MATCH_p; 
02255       
02256       #line 316 "machine/hppa/decoder_low.m"
02257        {
02258 
02259                   RTs = instantiate(pc, name, dis_Num(fmt), dis_Freg(fr1, fmt),
02260 
02261                       dis_Freg(fr2, fmt), dis_Freg(frt, fmt));
02262 
02263               }
02264 
02265       
02266       
02267       
02268     } 
02269     goto MATCH_finished_a; 
02270     
02271   MATCH_label_a13: (void)0; /*placeholder for label*/ 
02272     { 
02273       char *name = MATCH_name;
02274       unsigned cmplt = addressToPC(MATCH_p);
02275       unsigned imm11 = 
02276         (sign_extend((MATCH_w_32_0 & 0x1) /* i_31 at 0 */, 1) << 10) + 
02277         (MATCH_w_32_0 >> 1 & 0x3ff) /* im10_21 at 0 */;
02278       unsigned r_06 = (MATCH_w_32_0 >> 21 & 0x1f) /* r_06 at 0 */;
02279       unsigned t_11 = (MATCH_w_32_0 >> 16 & 0x1f) /* t_11 at 0 */;
02280       nextPC = 4 + MATCH_p; 
02281       
02282       #line 177 "machine/hppa/decoder_low.m"
02283        {
02284 
02285                   /* arith_imm,cc_16 imm11!,r_06,t_11 */
02286 
02287                   RTs = instantiate(pc, name, dis_Num(imm11), dis_Reg(r_06),
02288 
02289                     dis_Reg(t_11), c_c(cmplt, condvalue));
02290 
02291               }
02292 
02293       
02294       
02295       
02296     } 
02297     goto MATCH_finished_a; 
02298     
02299   MATCH_label_a14: (void)0; /*placeholder for label*/ 
02300     { 
02301       char *name = MATCH_name;
02302       unsigned nulli = addressToPC(MATCH_p);
02303       unsigned t_06 = (MATCH_w_32_0 >> 21 & 0x1f) /* t_06 at 0 */;
02304       unsigned ubr_target = 
02305         8 + ((MATCH_w_32_0 >> 3 & 0x3ff) /* w10_19 at 0 */ << 2) + 
02306         ((MATCH_w_32_0 >> 2 & 0x1) /* w_29 at 0 */ << 12) + 
02307         ((MATCH_w_32_0 >> 16 & 0x1f) /* w5_11 at 0 */ << 13) + 
02308         (sign_extend((MATCH_w_32_0 & 0x1) /* w_31 at 0 */, 1) << 18);
02309       nextPC = 4 + MATCH_p; 
02310       
02311       #line 256 "machine/hppa/decoder_low.m"
02312        {
02313 
02314                   /* ubranch,cmplt,n  target,t_06) */
02315 
02316                   RTs = instantiate(pc, name, dis_Num(ubr_target), dis_Reg(t_06));
02317 
02318                   not_used(nulli);
02319 
02320               }
02321 
02322       
02323       
02324       
02325     } 
02326     goto MATCH_finished_a; 
02327     
02328   MATCH_label_a15: (void)0; /*placeholder for label*/ 
02329     { 
02330       char *name = MATCH_name;
02331       unsigned b_06 = (MATCH_w_32_0 >> 21 & 0x1f) /* b_06 at 0 */;
02332       unsigned nulli = addressToPC(MATCH_p);
02333       unsigned p_31 = (MATCH_w_32_0 & 0x1) /* p_31 at 0 */;
02334       nextPC = 4 + MATCH_p; 
02335       
02336       #line 276 "machine/hppa/decoder_low.m"
02337        {
02338 
02339                   /* BVE.l BVE.lp BVE.p BVE  */
02340 
02341                   RTs = instantiate(pc, name, p_31, dis_Reg(b_06));
02342 
02343                   not_used(nulli);
02344 
02345               }
02346 
02347       
02348       
02349       
02350     } 
02351     goto MATCH_finished_a; 
02352     
02353   MATCH_finished_a: (void)0; /*placeholder for label*/
02354   
02355 }
02356 
02357 #line 337 "machine/hppa/decoder_low.m"
02358 
02359     result.numBytes = (nextPC - hostPC);
02360     return RTs;
02361 
02362 }
02363 
02364 /*
02365         }
02366         | LDWl(cmplt, ldisp, s2_16, b_06, t_11)[name] => {
02367                 *garble += sprintf(*garble, "%s", name);
02368             c_disps(cmplt);
02369             *garble += sprintf(*garble, "  %d(%s,%s),%s", ldisp, s2_16_names[s2_16], b_06_names[b_06], t_11_names[t_11]);
02370         
02371 */
02372 
02373
Generated on Tue Sep 19 21:18:16 2006 for Boomerang by  doxygen 1.4.6