src/vm/jit/verify/typecheck-stackbased-gen.inc

   1 #define GENERATED
   2
   3   GENERATED  case ICMD_NOP:
   4   GENERATED     /* (--) */
   5   GENERATED     break;
   6   GENERATED
   7   GENERATED
   8   GENERATED  case ICMD_ACONST:
   9   GENERATED     /* (--A) */
  10   GENERATED     maythrow = true;
  11   GENERATED     CHECK_STACK_SPACE(1);
  12   GENERATED
  13 #               define DST  (&(stack[1]))
  14   GENERATED     /* may use stack[1] ... stack[1] */
  15   GENERATED
  16   GENERATED
  17 #               line 347 "src/vm/jit/verify/icmds.c"
  18   GENERATED     if (IPTR->flags.bits & INS_FLAG_CLASS) {
  19   GENERATED             /* a java.lang.Class reference */
  20   GENERATED             TYPEINFO_INIT_JAVA_LANG_CLASS(DST->typeinfo,IPTR->sx.val.c);
  21   GENERATED     }
  22   GENERATED     else {
  23   GENERATED             if (IPTR->sx.val.anyptr == NULL)
  24   GENERATED                     TYPEINFO_INIT_NULLTYPE(DST->typeinfo);
  25   GENERATED             else {
  26   GENERATED                     /* string constant (or constant for builtin function) */
  27   GENERATED                     typeinfo_init_classinfo(&(DST->typeinfo),class_java_lang_String);
  28   GENERATED             }
  29   GENERATED     }
  30   GENERATED
  31 #               line 32 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
  32   GENERATED
  33   GENERATED     stack += 1;
  34   GENERATED     stack[0].type = TYPE_ADR;
  35   GENERATED     break;
  36   GENERATED
  37   GENERATED
  38 #               undef DST
  39   GENERATED
  40   GENERATED
  41   GENERATED  case ICMD_CHECKNULL:
  42   GENERATED     /* (A--A) */
  43   GENERATED     maythrow = true;
  44   GENERATED     CHECK_STACK_DEPTH(1);
  45   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_ADR);
  46   GENERATED     break;
  47   GENERATED
  48   GENERATED
  49   GENERATED  case ICMD_ICONST:
  50   GENERATED     /* (--I) */
  51   GENERATED     CHECK_STACK_SPACE(1);
  52   GENERATED     stack += 1;
  53   GENERATED     stack[0].type = TYPE_INT;
  54   GENERATED     break;
  55   GENERATED
  56   GENERATED
  57   GENERATED  case ICMD_LCONST:
  58   GENERATED     /* (--L) */
  59   GENERATED     CHECK_STACK_SPACE(2);
  60   GENERATED     stack += 2;
  61   GENERATED     stack[0].type = TYPE_VOID;
  62   GENERATED     stack[-1].type = TYPE_LNG;
  63   GENERATED     break;
  64   GENERATED
  65   GENERATED
  66   GENERATED  case ICMD_FCONST:
  67   GENERATED     /* (--F) */
  68   GENERATED     CHECK_STACK_SPACE(1);
  69   GENERATED     stack += 1;
  70   GENERATED     stack[0].type = TYPE_FLT;
  71   GENERATED     break;
  72   GENERATED
  73   GENERATED
  74   GENERATED  case ICMD_DCONST:
  75   GENERATED     /* (--D) */
  76   GENERATED     CHECK_STACK_SPACE(2);
  77   GENERATED     stack += 2;
  78   GENERATED     stack[0].type = TYPE_VOID;
  79   GENERATED     stack[-1].type = TYPE_DBL;
  80   GENERATED     break;
  81   GENERATED
  82   GENERATED
  83   GENERATED  case ICMD_ILOAD:
  84   GENERATED     /* (--I) */
  85   GENERATED     CHECK_STACK_SPACE(1);
  86   GENERATED     CHECK_LOCAL_TYPE(IPTR->s1.varindex, TYPE_INT);
  87   GENERATED     stack += 1;
  88   GENERATED     stack[0].type = TYPE_INT;
  89   GENERATED     break;
  90   GENERATED
  91   GENERATED
  92   GENERATED  case ICMD_LLOAD:
  93   GENERATED     /* (--L) */
  94   GENERATED     CHECK_STACK_SPACE(2);
  95   GENERATED     CHECK_LOCAL_TYPE(IPTR->s1.varindex, TYPE_LNG);
  96   GENERATED     stack += 2;
  97   GENERATED     stack[0].type = TYPE_VOID;
  98   GENERATED     stack[-1].type = TYPE_LNG;
  99   GENERATED     break;
 100   GENERATED
 101   GENERATED
 102   GENERATED  case ICMD_FLOAD:
 103   GENERATED     /* (--F) */
 104   GENERATED     CHECK_STACK_SPACE(1);
 105   GENERATED     CHECK_LOCAL_TYPE(IPTR->s1.varindex, TYPE_FLT);
 106   GENERATED     stack += 1;
 107   GENERATED     stack[0].type = TYPE_FLT;
 108   GENERATED     break;
 109   GENERATED
 110   GENERATED
 111   GENERATED  case ICMD_DLOAD:
 112   GENERATED     /* (--D) */
 113   GENERATED     CHECK_STACK_SPACE(2);
 114   GENERATED     CHECK_LOCAL_TYPE(IPTR->s1.varindex, TYPE_DBL);
 115   GENERATED     stack += 2;
 116   GENERATED     stack[0].type = TYPE_VOID;
 117   GENERATED     stack[-1].type = TYPE_DBL;
 118   GENERATED     break;
 119   GENERATED
 120   GENERATED
 121   GENERATED  case ICMD_ALOAD:
 122   GENERATED     /* (--A) */
 123   GENERATED     CHECK_STACK_SPACE(1);
 124   GENERATED     CHECK_LOCAL_TYPE(IPTR->s1.varindex, TYPE_ADR);
 125   GENERATED
 126 #               define OP1 LOCAL_SLOT(IPTR->s1.varindex)
 127   GENERATED
 128 #               define DST  (&(stack[1]))
 129   GENERATED     /* may use stack[1] ... stack[1] */
 130   GENERATED
 131   GENERATED
 132 #               line 91 "src/vm/jit/verify/icmds.c"
 133   GENERATED     TYPECHECK_COUNT(stat_ins_aload);
 134   GENERATED
 135   GENERATED
 136 #            if !defined(TYPECHECK_TYPEINFERER)
 137   GENERATED     /* loading a returnAddress is not allowed */
 138   GENERATED     if (!TYPEDESC_IS_REFERENCE(*OP1)) {
 139   GENERATED             VERIFY_ERROR("illegal instruction: ALOAD loading non-reference");
 140   GENERATED     }
 141   GENERATED
 142 #            endif
 143   GENERATED     TYPEINFO_COPY(OP1->typeinfo,DST->typeinfo);
 144   GENERATED
 145 #               line 146 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 146   GENERATED
 147   GENERATED     stack += 1;
 148   GENERATED     stack[0].type = TYPE_ADR;
 149   GENERATED     break;
 150   GENERATED
 151   GENERATED
 152 #               undef OP1
 153   GENERATED
 154 #               undef DST
 155   GENERATED
 156   GENERATED
 157   GENERATED  case ICMD_IALOAD:
 158   GENERATED     /* (AI--I) */
 159   GENERATED     maythrow = true;
 160   GENERATED     CHECK_STACK_DEPTH(2);
 161   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_ADR);
 162   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 163   GENERATED
 164 #               define OP1 (&(stack[-1]))
 165   GENERATED
 166 #               define OP2 (&(stack[0]))
 167   GENERATED
 168 #               define DST  (&(stack[-1]))
 169   GENERATED     /* may use stack[-1] ... stack[0] */
 170   GENERATED
 171   GENERATED
 172 #               line 258 "src/vm/jit/verify/icmds.c"
 173   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_INT))
 174   GENERATED             VERIFY_ERROR("Array type mismatch");
 175   GENERATED
 176 #               line 177 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 177   GENERATED
 178   GENERATED     stack += -1;
 179   GENERATED     stack[0].type = TYPE_INT;
 180   GENERATED     break;
 181   GENERATED
 182   GENERATED
 183 #               undef OP1
 184   GENERATED
 185 #               undef OP2
 186   GENERATED
 187 #               undef DST
 188   GENERATED
 189   GENERATED
 190   GENERATED  case ICMD_LALOAD:
 191   GENERATED     /* (AI--L) */
 192   GENERATED     maythrow = true;
 193   GENERATED     CHECK_STACK_DEPTH(2);
 194   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_ADR);
 195   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 196   GENERATED
 197 #               define OP1 (&(stack[-1]))
 198   GENERATED
 199 #               define OP2 (&(stack[0]))
 200   GENERATED
 201 #               define DST  (&(stack[-1]))
 202   GENERATED     /* may use stack[-1] ... stack[0] */
 203   GENERATED
 204   GENERATED
 205 #               line 268 "src/vm/jit/verify/icmds.c"
 206   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_LONG))
 207   GENERATED             VERIFY_ERROR("Array type mismatch");
 208   GENERATED
 209 #               line 210 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 210   GENERATED
 211   GENERATED     stack[0].type = TYPE_VOID;
 212   GENERATED     stack[-1].type = TYPE_LNG;
 213   GENERATED     break;
 214   GENERATED
 215   GENERATED
 216 #               undef OP1
 217   GENERATED
 218 #               undef OP2
 219   GENERATED
 220 #               undef DST
 221   GENERATED
 222   GENERATED
 223   GENERATED  case ICMD_FALOAD:
 224   GENERATED     /* (AI--F) */
 225   GENERATED     maythrow = true;
 226   GENERATED     CHECK_STACK_DEPTH(2);
 227   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_ADR);
 228   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 229   GENERATED
 230 #               define OP1 (&(stack[-1]))
 231   GENERATED
 232 #               define OP2 (&(stack[0]))
 233   GENERATED
 234 #               define DST  (&(stack[-1]))
 235   GENERATED     /* may use stack[-1] ... stack[0] */
 236   GENERATED
 237   GENERATED
 238 #               line 253 "src/vm/jit/verify/icmds.c"
 239   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_FLOAT))
 240   GENERATED             VERIFY_ERROR("Array type mismatch");
 241   GENERATED
 242 #               line 243 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 243   GENERATED
 244   GENERATED     stack += -1;
 245   GENERATED     stack[0].type = TYPE_FLT;
 246   GENERATED     break;
 247   GENERATED
 248   GENERATED
 249 #               undef OP1
 250   GENERATED
 251 #               undef OP2
 252   GENERATED
 253 #               undef DST
 254   GENERATED
 255   GENERATED
 256   GENERATED  case ICMD_DALOAD:
 257   GENERATED     /* (AI--D) */
 258   GENERATED     maythrow = true;
 259   GENERATED     CHECK_STACK_DEPTH(2);
 260   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_ADR);
 261   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 262   GENERATED
 263 #               define OP1 (&(stack[-1]))
 264   GENERATED
 265 #               define OP2 (&(stack[0]))
 266   GENERATED
 267 #               define DST  (&(stack[-1]))
 268   GENERATED     /* may use stack[-1] ... stack[0] */
 269   GENERATED
 270   GENERATED
 271 #               line 248 "src/vm/jit/verify/icmds.c"
 272   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_DOUBLE))
 273   GENERATED             VERIFY_ERROR("Array type mismatch");
 274   GENERATED
 275 #               line 276 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 276   GENERATED
 277   GENERATED     stack[0].type = TYPE_VOID;
 278   GENERATED     stack[-1].type = TYPE_DBL;
 279   GENERATED     break;
 280   GENERATED
 281   GENERATED
 282 #               undef OP1
 283   GENERATED
 284 #               undef OP2
 285   GENERATED
 286 #               undef DST
 287   GENERATED
 288   GENERATED
 289   GENERATED  case ICMD_AALOAD:
 290   GENERATED     /* (AI--A) */
 291   GENERATED     maythrow = true;
 292   GENERATED     CHECK_STACK_DEPTH(2);
 293   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_ADR);
 294   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 295   GENERATED
 296 #               define OP1 (&(stack[-1]))
 297   GENERATED
 298 #               define OP2 (&(stack[0]))
 299   GENERATED
 300 #               define DST  (&(stack[-1]))
 301   GENERATED     /* may use stack[-1] ... stack[0] */
 302   GENERATED
 303   GENERATED
 304 #               line 113 "src/vm/jit/verify/icmds.c"
 305   GENERATED
 306 #            if !defined(TYPECHECK_TYPEINFERER)
 307   GENERATED     if (!TYPEINFO_MAYBE_ARRAY_OF_REFS(OP1->typeinfo))
 308   GENERATED             VERIFY_ERROR("illegal instruction: AALOAD on non-reference array");
 309   GENERATED
 310 #            endif
 311   GENERATED
 312   GENERATED     if (!typeinfo_init_component(&OP1->typeinfo,&DST->typeinfo))
 313   GENERATED             EXCEPTION;
 314   GENERATED
 315 #               line 316 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 316   GENERATED
 317   GENERATED     stack += -1;
 318   GENERATED     break;
 319   GENERATED
 320   GENERATED
 321 #               undef OP1
 322   GENERATED
 323 #               undef OP2
 324   GENERATED
 325 #               undef DST
 326   GENERATED
 327   GENERATED
 328   GENERATED  case ICMD_BALOAD:
 329   GENERATED     /* (AI--I) */
 330   GENERATED     maythrow = true;
 331   GENERATED     CHECK_STACK_DEPTH(2);
 332   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_ADR);
 333   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 334   GENERATED
 335 #               define OP1 (&(stack[-1]))
 336   GENERATED
 337 #               define OP2 (&(stack[0]))
 338   GENERATED
 339 #               define DST  (&(stack[-1]))
 340   GENERATED     /* may use stack[-1] ... stack[0] */
 341   GENERATED
 342   GENERATED
 343 #               line 237 "src/vm/jit/verify/icmds.c"
 344   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_BOOLEAN)
 345   GENERATED                     && !TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_BYTE))
 346   GENERATED             VERIFY_ERROR("Array type mismatch");
 347   GENERATED
 348 #               line 349 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 349   GENERATED
 350   GENERATED     stack += -1;
 351   GENERATED     stack[0].type = TYPE_INT;
 352   GENERATED     break;
 353   GENERATED
 354   GENERATED
 355 #               undef OP1
 356   GENERATED
 357 #               undef OP2
 358   GENERATED
 359 #               undef DST
 360   GENERATED
 361   GENERATED
 362   GENERATED  case ICMD_CALOAD:
 363   GENERATED     /* (AI--I) */
 364   GENERATED     maythrow = true;
 365   GENERATED     CHECK_STACK_DEPTH(2);
 366   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_ADR);
 367   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 368   GENERATED
 369 #               define OP1 (&(stack[-1]))
 370   GENERATED
 371 #               define OP2 (&(stack[0]))
 372   GENERATED
 373 #               define DST  (&(stack[-1]))
 374   GENERATED     /* may use stack[-1] ... stack[0] */
 375   GENERATED
 376   GENERATED
 377 #               line 243 "src/vm/jit/verify/icmds.c"
 378   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_CHAR))
 379   GENERATED             VERIFY_ERROR("Array type mismatch");
 380   GENERATED
 381 #               line 382 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 382   GENERATED
 383   GENERATED     stack += -1;
 384   GENERATED     stack[0].type = TYPE_INT;
 385   GENERATED     break;
 386   GENERATED
 387   GENERATED
 388 #               undef OP1
 389   GENERATED
 390 #               undef OP2
 391   GENERATED
 392 #               undef DST
 393   GENERATED
 394   GENERATED
 395   GENERATED  case ICMD_SALOAD:
 396   GENERATED     /* (AI--I) */
 397   GENERATED     maythrow = true;
 398   GENERATED     CHECK_STACK_DEPTH(2);
 399   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_ADR);
 400   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 401   GENERATED
 402 #               define OP1 (&(stack[-1]))
 403   GENERATED
 404 #               define OP2 (&(stack[0]))
 405   GENERATED
 406 #               define DST  (&(stack[-1]))
 407   GENERATED     /* may use stack[-1] ... stack[0] */
 408   GENERATED
 409   GENERATED
 410 #               line 263 "src/vm/jit/verify/icmds.c"
 411   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_SHORT))
 412   GENERATED             VERIFY_ERROR("Array type mismatch");
 413   GENERATED
 414 #               line 415 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 415   GENERATED
 416   GENERATED     stack += -1;
 417   GENERATED     stack[0].type = TYPE_INT;
 418   GENERATED     break;
 419   GENERATED
 420   GENERATED
 421 #               undef OP1
 422   GENERATED
 423 #               undef OP2
 424   GENERATED
 425 #               undef DST
 426   GENERATED
 427   GENERATED
 428   GENERATED  case ICMD_ISTORE:
 429   GENERATED     /* (I--) */
 430   GENERATED     CHECK_STACK_DEPTH(1);
 431   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 432   GENERATED     STORE_LOCAL(TYPE_INT, IPTR->dst.varindex);
 433   GENERATED     stack += -1;
 434   GENERATED     break;
 435   GENERATED
 436   GENERATED
 437   GENERATED  case ICMD_LSTORE:
 438   GENERATED     /* (L--) */
 439   GENERATED     CHECK_STACK_DEPTH(2);
 440   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_LNG);
 441   GENERATED     STORE_LOCAL_2_WORD(TYPE_LNG, IPTR->dst.varindex);
 442   GENERATED     stack += -2;
 443   GENERATED     break;
 444   GENERATED
 445   GENERATED
 446   GENERATED  case ICMD_FSTORE:
 447   GENERATED     /* (F--) */
 448   GENERATED     CHECK_STACK_DEPTH(1);
 449   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_FLT);
 450   GENERATED     STORE_LOCAL(TYPE_FLT, IPTR->dst.varindex);
 451   GENERATED     stack += -1;
 452   GENERATED     break;
 453   GENERATED
 454   GENERATED
 455   GENERATED  case ICMD_DSTORE:
 456   GENERATED     /* (D--) */
 457   GENERATED     CHECK_STACK_DEPTH(2);
 458   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_DBL);
 459   GENERATED     STORE_LOCAL_2_WORD(TYPE_DBL, IPTR->dst.varindex);
 460   GENERATED     stack += -2;
 461   GENERATED     break;
 462   GENERATED
 463   GENERATED
 464   GENERATED  case ICMD_ASTORE:
 465   GENERATED     /* (A--|R--) */
 466   GENERATED     CHECK_STACK_DEPTH(1);
 467   GENERATED
 468 #               define OP1 (&(stack[0]))
 469   GENERATED     STORE_LOCAL(OP1->type, IPTR->dst.varindex);
 470   GENERATED
 471 #               define DST LOCAL_SLOT(IPTR->dst.varindex)
 472   GENERATED     /* may use stack[0] ... stack[0] */
 473   GENERATED
 474   GENERATED
 475 #               line 106 "src/vm/jit/verify/icmds.c"
 476   GENERATED     TYPEINFO_COPY(OP1->typeinfo, DST->typeinfo);
 477   GENERATED
 478 #               line 479 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 479   GENERATED
 480   GENERATED     stack += -1;
 481   GENERATED     break;
 482   GENERATED
 483   GENERATED
 484 #               undef OP1
 485   GENERATED
 486 #               undef DST
 487   GENERATED
 488   GENERATED
 489   GENERATED  case ICMD_IASTORE:
 490   GENERATED     /* (AII--) */
 491   GENERATED     maythrow = true;
 492   GENERATED     CHECK_STACK_DEPTH(3);
 493   GENERATED     CHECK_STACK_TYPE(stack[-2], TYPE_ADR);
 494   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_INT);
 495   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 496   GENERATED
 497 #               define OP1 (&(stack[-2]))
 498   GENERATED
 499 #               define OP2 (&(stack[-1]))
 500   GENERATED
 501 #               define OP3 (&(stack[0]))
 502   GENERATED     /* may use stack[-2] ... stack[0] */
 503   GENERATED
 504   GENERATED
 505 #               line 294 "src/vm/jit/verify/icmds.c"
 506   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_INT))
 507   GENERATED             VERIFY_ERROR("Array type mismatch");
 508   GENERATED
 509 #               line 510 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 510   GENERATED
 511   GENERATED     stack += -3;
 512   GENERATED     break;
 513   GENERATED
 514   GENERATED
 515 #               undef OP1
 516   GENERATED
 517 #               undef OP2
 518   GENERATED
 519 #               undef OP3
 520   GENERATED
 521   GENERATED
 522   GENERATED  case ICMD_LASTORE:
 523   GENERATED     /* (AIL--) */
 524   GENERATED     maythrow = true;
 525   GENERATED     CHECK_STACK_DEPTH(4);
 526   GENERATED     CHECK_STACK_TYPE(stack[-3], TYPE_ADR);
 527   GENERATED     CHECK_STACK_TYPE(stack[-2], TYPE_INT);
 528   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_LNG);
 529   GENERATED
 530 #               define OP1 (&(stack[-3]))
 531   GENERATED
 532 #               define OP2 (&(stack[-2]))
 533   GENERATED
 534 #               define OP3 (&(stack[-1]))
 535   GENERATED     /* may use stack[-3] ... stack[0] */
 536   GENERATED
 537   GENERATED
 538 #               line 304 "src/vm/jit/verify/icmds.c"
 539   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_LONG))
 540   GENERATED             VERIFY_ERROR("Array type mismatch");
 541   GENERATED
 542 #               line 543 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 543   GENERATED
 544   GENERATED     stack += -4;
 545   GENERATED     break;
 546   GENERATED
 547   GENERATED
 548 #               undef OP1
 549   GENERATED
 550 #               undef OP2
 551   GENERATED
 552 #               undef OP3
 553   GENERATED
 554   GENERATED
 555   GENERATED  case ICMD_FASTORE:
 556   GENERATED     /* (AIF--) */
 557   GENERATED     maythrow = true;
 558   GENERATED     CHECK_STACK_DEPTH(3);
 559   GENERATED     CHECK_STACK_TYPE(stack[-2], TYPE_ADR);
 560   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_INT);
 561   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_FLT);
 562   GENERATED
 563 #               define OP1 (&(stack[-2]))
 564   GENERATED
 565 #               define OP2 (&(stack[-1]))
 566   GENERATED
 567 #               define OP3 (&(stack[0]))
 568   GENERATED     /* may use stack[-2] ... stack[0] */
 569   GENERATED
 570   GENERATED
 571 #               line 289 "src/vm/jit/verify/icmds.c"
 572   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_FLOAT))
 573   GENERATED             VERIFY_ERROR("Array type mismatch");
 574   GENERATED
 575 #               line 576 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 576   GENERATED
 577   GENERATED     stack += -3;
 578   GENERATED     break;
 579   GENERATED
 580   GENERATED
 581 #               undef OP1
 582   GENERATED
 583 #               undef OP2
 584   GENERATED
 585 #               undef OP3
 586   GENERATED
 587   GENERATED
 588   GENERATED  case ICMD_DASTORE:
 589   GENERATED     /* (AID--) */
 590   GENERATED     maythrow = true;
 591   GENERATED     CHECK_STACK_DEPTH(4);
 592   GENERATED     CHECK_STACK_TYPE(stack[-3], TYPE_ADR);
 593   GENERATED     CHECK_STACK_TYPE(stack[-2], TYPE_INT);
 594   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_DBL);
 595   GENERATED
 596 #               define OP1 (&(stack[-3]))
 597   GENERATED
 598 #               define OP2 (&(stack[-2]))
 599   GENERATED
 600 #               define OP3 (&(stack[-1]))
 601   GENERATED     /* may use stack[-3] ... stack[0] */
 602   GENERATED
 603   GENERATED
 604 #               line 284 "src/vm/jit/verify/icmds.c"
 605   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_DOUBLE))
 606   GENERATED             VERIFY_ERROR("Array type mismatch");
 607   GENERATED
 608 #               line 609 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 609   GENERATED
 610   GENERATED     stack += -4;
 611   GENERATED     break;
 612   GENERATED
 613   GENERATED
 614 #               undef OP1
 615   GENERATED
 616 #               undef OP2
 617   GENERATED
 618 #               undef OP3
 619   GENERATED
 620   GENERATED
 621   GENERATED  case ICMD_AASTORE:
 622   GENERATED     /* (AIA--) */
 623   GENERATED     maythrow = true;
 624   GENERATED     CHECK_STACK_DEPTH(3);
 625   GENERATED     CHECK_STACK_TYPE(stack[-2], TYPE_ADR);
 626   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_INT);
 627   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_ADR);
 628   GENERATED
 629 #               define OP1 (&(stack[-2]))
 630   GENERATED
 631 #               define OP2 (&(stack[-1]))
 632   GENERATED
 633 #               define OP3 (&(stack[0]))
 634   GENERATED     /* may use stack[-2] ... stack[0] */
 635   GENERATED
 636   GENERATED
 637 #               line 309 "src/vm/jit/verify/icmds.c"
 638   GENERATED     /* we just check the basic input types and that the           */
 639   GENERATED     /* destination is an array of references. Assignability to    */
 640   GENERATED     /* the actual array must be checked at runtime, each time the */
 641   GENERATED     /* instruction is performed. (See builtin_canstore.)          */
 642   GENERATED     if (!TYPEINFO_MAYBE_ARRAY_OF_REFS(OP1->typeinfo))
 643   GENERATED             VERIFY_ERROR("illegal instruction: AASTORE to non-reference array");
 644   GENERATED
 645 #               line 646 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 646   GENERATED
 647   GENERATED     stack += -3;
 648   GENERATED     break;
 649   GENERATED
 650   GENERATED
 651 #               undef OP1
 652   GENERATED
 653 #               undef OP2
 654   GENERATED
 655 #               undef OP3
 656   GENERATED
 657   GENERATED
 658   GENERATED  case ICMD_BASTORE:
 659   GENERATED     /* (AII--) */
 660   GENERATED     maythrow = true;
 661   GENERATED     CHECK_STACK_DEPTH(3);
 662   GENERATED     CHECK_STACK_TYPE(stack[-2], TYPE_ADR);
 663   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_INT);
 664   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 665   GENERATED
 666 #               define OP1 (&(stack[-2]))
 667   GENERATED
 668 #               define OP2 (&(stack[-1]))
 669   GENERATED
 670 #               define OP3 (&(stack[0]))
 671   GENERATED     /* may use stack[-2] ... stack[0] */
 672   GENERATED
 673   GENERATED
 674 #               line 273 "src/vm/jit/verify/icmds.c"
 675   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_BOOLEAN)
 676   GENERATED                     && !TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_BYTE))
 677   GENERATED             VERIFY_ERROR("Array type mismatch");
 678   GENERATED
 679 #               line 680 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 680   GENERATED
 681   GENERATED     stack += -3;
 682   GENERATED     break;
 683   GENERATED
 684   GENERATED
 685 #               undef OP1
 686   GENERATED
 687 #               undef OP2
 688   GENERATED
 689 #               undef OP3
 690   GENERATED
 691   GENERATED
 692   GENERATED  case ICMD_CASTORE:
 693   GENERATED     /* (AII--) */
 694   GENERATED     maythrow = true;
 695   GENERATED     CHECK_STACK_DEPTH(3);
 696   GENERATED     CHECK_STACK_TYPE(stack[-2], TYPE_ADR);
 697   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_INT);
 698   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 699   GENERATED
 700 #               define OP1 (&(stack[-2]))
 701   GENERATED
 702 #               define OP2 (&(stack[-1]))
 703   GENERATED
 704 #               define OP3 (&(stack[0]))
 705   GENERATED     /* may use stack[-2] ... stack[0] */
 706   GENERATED
 707   GENERATED
 708 #               line 279 "src/vm/jit/verify/icmds.c"
 709   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_CHAR))
 710   GENERATED             VERIFY_ERROR("Array type mismatch");
 711   GENERATED
 712 #               line 713 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 713   GENERATED
 714   GENERATED     stack += -3;
 715   GENERATED     break;
 716   GENERATED
 717   GENERATED
 718 #               undef OP1
 719   GENERATED
 720 #               undef OP2
 721   GENERATED
 722 #               undef OP3
 723   GENERATED
 724   GENERATED
 725   GENERATED  case ICMD_SASTORE:
 726   GENERATED     /* (AII--) */
 727   GENERATED     maythrow = true;
 728   GENERATED     CHECK_STACK_DEPTH(3);
 729   GENERATED     CHECK_STACK_TYPE(stack[-2], TYPE_ADR);
 730   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_INT);
 731   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 732   GENERATED
 733 #               define OP1 (&(stack[-2]))
 734   GENERATED
 735 #               define OP2 (&(stack[-1]))
 736   GENERATED
 737 #               define OP3 (&(stack[0]))
 738   GENERATED     /* may use stack[-2] ... stack[0] */
 739   GENERATED
 740   GENERATED
 741 #               line 299 "src/vm/jit/verify/icmds.c"
 742   GENERATED     if (!TYPEINFO_MAYBE_PRIMITIVE_ARRAY(OP1->typeinfo,ARRAYTYPE_SHORT))
 743   GENERATED             VERIFY_ERROR("Array type mismatch");
 744   GENERATED
 745 #               line 746 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 746   GENERATED
 747   GENERATED     stack += -3;
 748   GENERATED     break;
 749   GENERATED
 750   GENERATED
 751 #               undef OP1
 752   GENERATED
 753 #               undef OP2
 754   GENERATED
 755 #               undef OP3
 756   GENERATED
 757   GENERATED
 758   GENERATED  case ICMD_POP:
 759   GENERATED     /* (1--) */
 760   GENERATED     CHECK_STACK_DEPTH(1);
 761   GENERATED     /* may use stack[0] ... stack[0] */
 762   GENERATED
 763   GENERATED
 764 #               line 676 "src/vm/jit/verify/icmds.c"
 765   GENERATED     /* we pop 1 */
 766   GENERATED     CHECK_CAT1(stack[0]);
 767   GENERATED
 768 #               line 769 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 769   GENERATED
 770   GENERATED     stack += -1;
 771   GENERATED     break;
 772   GENERATED
 773   GENERATED
 774   GENERATED  case ICMD_POP2:
 775   GENERATED     /* (11--|2--) */
 776   GENERATED     CHECK_STACK_DEPTH(2);
 777   GENERATED     /* may use stack[-1] ... stack[0] */
 778   GENERATED
 779   GENERATED
 780 #               line 681 "src/vm/jit/verify/icmds.c"
 781   GENERATED     /* we pop either 11 or 2 */
 782   GENERATED     if (IS_CAT1(stack[0]))
 783   GENERATED             CHECK_CAT1(stack[-1]);
 784   GENERATED
 785 #               line 786 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 786   GENERATED
 787   GENERATED     stack += -2;
 788   GENERATED     break;
 789   GENERATED
 790   GENERATED
 791   GENERATED  case ICMD_DUP:
 792   GENERATED     /* (1--11) */
 793   GENERATED     CHECK_STACK_DEPTH(1);
 794   GENERATED     CHECK_STACK_SPACE(1);
 795   GENERATED
 796 #               define DST  (&(stack[0]))
 797   GENERATED     /* may use stack[0] ... stack[1] */
 798   GENERATED
 799   GENERATED
 800 #               line 696 "src/vm/jit/verify/icmds.c"
 801   GENERATED     /* we dup 1 */
 802   GENERATED     CHECK_CAT1(stack[0]);
 803   GENERATED
 804   GENERATED     COPY_SLOT(stack[ 0], stack[ 1]);
 805   GENERATED
 806 #               line 807 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 807   GENERATED
 808   GENERATED     stack += 1;
 809   GENERATED     break;
 810   GENERATED
 811   GENERATED
 812 #               undef DST
 813   GENERATED
 814   GENERATED
 815   GENERATED  case ICMD_DUP_X1:
 816   GENERATED     /* (11--111) */
 817   GENERATED     CHECK_STACK_DEPTH(2);
 818   GENERATED     CHECK_STACK_SPACE(1);
 819   GENERATED
 820 #               define DST  (&(stack[-1]))
 821   GENERATED     /* may use stack[-1] ... stack[1] */
 822   GENERATED
 823   GENERATED
 824 #               line 703 "src/vm/jit/verify/icmds.c"
 825   GENERATED     /* we dup 1 */
 826   GENERATED     CHECK_CAT1(stack[0]);
 827   GENERATED     /* we skip 1 */
 828   GENERATED     CHECK_CAT1(stack[-1]);
 829   GENERATED
 830   GENERATED     COPY_SLOT(stack[ 0], stack[ 1]);
 831   GENERATED     COPY_SLOT(stack[-1], stack[ 0]);
 832   GENERATED     COPY_SLOT(stack[ 1], stack[-1]);
 833   GENERATED
 834 #               line 835 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 835   GENERATED
 836   GENERATED     stack += 1;
 837   GENERATED     break;
 838   GENERATED
 839   GENERATED
 840 #               undef DST
 841   GENERATED
 842   GENERATED
 843   GENERATED  case ICMD_DUP_X2:
 844   GENERATED     /* (111--1111|21--121) */
 845   GENERATED     CHECK_STACK_DEPTH(3);
 846   GENERATED     CHECK_STACK_SPACE(1);
 847   GENERATED     /* may use stack[-2] ... stack[1] */
 848   GENERATED
 849   GENERATED
 850 #               line 714 "src/vm/jit/verify/icmds.c"
 851   GENERATED     /* we dup 1 */
 852   GENERATED     CHECK_CAT1(stack[0]);
 853   GENERATED     /* we skip either 11 or 2 */
 854   GENERATED     if (IS_CAT1(stack[-1]))
 855   GENERATED             CHECK_CAT1(stack[-2]);
 856   GENERATED
 857   GENERATED     COPY_SLOT(stack[ 0], stack[ 1]);
 858   GENERATED     COPY_SLOT(stack[-1], stack[ 0]);
 859   GENERATED     COPY_SLOT(stack[-2], stack[-1]);
 860   GENERATED     COPY_SLOT(stack[ 1], stack[-2]);
 861   GENERATED
 862 #               line 863 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 863   GENERATED
 864   GENERATED     stack += 1;
 865   GENERATED     break;
 866   GENERATED
 867   GENERATED
 868   GENERATED  case ICMD_DUP2:
 869   GENERATED     /* (11--1111|2--22) */
 870   GENERATED     CHECK_STACK_DEPTH(2);
 871   GENERATED     CHECK_STACK_SPACE(2);
 872   GENERATED     /* may use stack[-1] ... stack[2] */
 873   GENERATED
 874   GENERATED
 875 #               line 727 "src/vm/jit/verify/icmds.c"
 876   GENERATED     /* we dup either 11 or 2 */
 877   GENERATED     if (IS_CAT1(stack[0]))
 878   GENERATED             CHECK_CAT1(stack[-1]);
 879   GENERATED
 880   GENERATED     COPY_SLOT(stack[ 0], stack[ 2]);
 881   GENERATED     COPY_SLOT(stack[-1], stack[ 1]);
 882   GENERATED
 883 #               line 884 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 884   GENERATED
 885   GENERATED     stack += 2;
 886   GENERATED     break;
 887   GENERATED
 888   GENERATED
 889   GENERATED  case ICMD_DUP2_X1:
 890   GENERATED     /* (111--11111|12--212) */
 891   GENERATED     CHECK_STACK_DEPTH(3);
 892   GENERATED     CHECK_STACK_SPACE(2);
 893   GENERATED     /* may use stack[-2] ... stack[2] */
 894   GENERATED
 895   GENERATED
 896 #               line 736 "src/vm/jit/verify/icmds.c"
 897   GENERATED     /* we dup either 11 or 2 */
 898   GENERATED     if (IS_CAT1(stack[0]))
 899   GENERATED             CHECK_CAT1(stack[-1]);
 900   GENERATED     /* we skip 1 */
 901   GENERATED     CHECK_CAT1(stack[-2]);
 902   GENERATED
 903   GENERATED     COPY_SLOT(stack[ 0], stack[ 2]);
 904   GENERATED     COPY_SLOT(stack[-1], stack[ 1]);
 905   GENERATED     COPY_SLOT(stack[-2], stack[ 0]);
 906   GENERATED     COPY_SLOT(stack[ 2], stack[-1]);
 907   GENERATED     COPY_SLOT(stack[ 1], stack[-2]);
 908   GENERATED
 909 #               line 910 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 910   GENERATED
 911   GENERATED     stack += 2;
 912   GENERATED     break;
 913   GENERATED
 914   GENERATED
 915   GENERATED  case ICMD_DUP2_X2:
 916   GENERATED     /* (1111--111111|112--2112|22--222|211--11211) */
 917   GENERATED     CHECK_STACK_DEPTH(4);
 918   GENERATED     CHECK_STACK_SPACE(2);
 919   GENERATED     /* may use stack[-3] ... stack[2] */
 920   GENERATED
 921   GENERATED
 922 #               line 750 "src/vm/jit/verify/icmds.c"
 923   GENERATED     /* we dup either 11 or 2 */
 924   GENERATED     if (IS_CAT1(stack[0]))
 925   GENERATED             CHECK_CAT1(stack[-1]);
 926   GENERATED     /* we skip either 11 or 2 */
 927   GENERATED     if (IS_CAT1(stack[-2]))
 928   GENERATED             CHECK_CAT1(stack[-3]);
 929   GENERATED
 930   GENERATED     COPY_SLOT(stack[ 0], stack[ 2]);
 931   GENERATED     COPY_SLOT(stack[-1], stack[ 1]);
 932   GENERATED     COPY_SLOT(stack[-2], stack[ 0]);
 933   GENERATED     COPY_SLOT(stack[-3], stack[-1]);
 934   GENERATED     COPY_SLOT(stack[ 2], stack[-2]);
 935   GENERATED     COPY_SLOT(stack[ 1], stack[-3]);
 936   GENERATED
 937 #               line 938 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 938   GENERATED
 939   GENERATED     stack += 2;
 940   GENERATED     break;
 941   GENERATED
 942   GENERATED
 943   GENERATED  case ICMD_SWAP:
 944   GENERATED     /* (11--11) */
 945   GENERATED     CHECK_STACK_DEPTH(2);
 946   GENERATED
 947 #               define DST  (&(stack[-1]))
 948   GENERATED     /* may use stack[-1] ... stack[0] */
 949   GENERATED
 950   GENERATED
 951 #               line 687 "src/vm/jit/verify/icmds.c"
 952   GENERATED     CHECK_CAT1(stack[0]);
 953   GENERATED     CHECK_CAT1(stack[-1]);
 954   GENERATED
 955   GENERATED     COPY_SLOT(stack[ 0], temp     );
 956   GENERATED     COPY_SLOT(stack[-1], stack[ 0]);
 957   GENERATED     COPY_SLOT(temp     , stack[-1]);
 958   GENERATED
 959 #               line 960 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
 960   GENERATED
 961   GENERATED     break;
 962   GENERATED
 963   GENERATED
 964 #               undef DST
 965   GENERATED
 966   GENERATED
 967   GENERATED  case ICMD_IADD:
 968   GENERATED  case ICMD_ISUB:
 969   GENERATED  case ICMD_IMUL:
 970   GENERATED  case ICMD_ISHL:
 971   GENERATED  case ICMD_ISHR:
 972   GENERATED  case ICMD_IUSHR:
 973   GENERATED  case ICMD_IAND:
 974   GENERATED  case ICMD_IOR:
 975   GENERATED  case ICMD_IXOR:
 976   GENERATED     /* (II--I) */
 977   GENERATED     CHECK_STACK_DEPTH(2);
 978   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_INT);
 979   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
 980   GENERATED     stack += -1;
 981   GENERATED     break;
 982   GENERATED
 983   GENERATED
 984   GENERATED  case ICMD_LADD:
 985   GENERATED  case ICMD_LSUB:
 986   GENERATED  case ICMD_LMUL:
 987   GENERATED  case ICMD_LAND:
 988   GENERATED  case ICMD_LOR:
 989   GENERATED  case ICMD_LXOR:
 990   GENERATED     /* (LL--L) */
 991   GENERATED     CHECK_STACK_DEPTH(4);
 992   GENERATED     CHECK_STACK_TYPE(stack[-3], TYPE_LNG);
 993   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_LNG);
 994   GENERATED     stack += -2;
 995   GENERATED     break;
 996   GENERATED
 997   GENERATED
 998   GENERATED  case ICMD_FADD:
 999   GENERATED  case ICMD_FSUB:
1000   GENERATED  case ICMD_FMUL:
1001   GENERATED  case ICMD_FDIV:
1002   GENERATED  case ICMD_FREM:
1003   GENERATED     /* (FF--F) */
1004   GENERATED     CHECK_STACK_DEPTH(2);
1005   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_FLT);
1006   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_FLT);
1007   GENERATED     stack += -1;
1008   GENERATED     break;
1009   GENERATED
1010   GENERATED
1011   GENERATED  case ICMD_DADD:
1012   GENERATED  case ICMD_DSUB:
1013   GENERATED  case ICMD_DMUL:
1014   GENERATED  case ICMD_DDIV:
1015   GENERATED  case ICMD_DREM:
1016   GENERATED     /* (DD--D) */
1017   GENERATED     CHECK_STACK_DEPTH(4);
1018   GENERATED     CHECK_STACK_TYPE(stack[-3], TYPE_DBL);
1019   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_DBL);
1020   GENERATED     stack += -2;
1021   GENERATED     break;
1022   GENERATED
1023   GENERATED
1024   GENERATED  case ICMD_IDIV:
1025   GENERATED  case ICMD_IREM:
1026   GENERATED     /* (II--I) */
1027   GENERATED     maythrow = true;
1028   GENERATED     CHECK_STACK_DEPTH(2);
1029   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_INT);
1030   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
1031   GENERATED     stack += -1;
1032   GENERATED     break;
1033   GENERATED
1034   GENERATED
1035   GENERATED  case ICMD_LDIV:
1036   GENERATED  case ICMD_LREM:
1037   GENERATED     /* (LL--L) */
1038   GENERATED     maythrow = true;
1039   GENERATED     CHECK_STACK_DEPTH(4);
1040   GENERATED     CHECK_STACK_TYPE(stack[-3], TYPE_LNG);
1041   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_LNG);
1042   GENERATED     stack += -2;
1043   GENERATED     break;
1044   GENERATED
1045   GENERATED
1046   GENERATED  case ICMD_INEG:
1047   GENERATED  case ICMD_INT2BYTE:
1048   GENERATED  case ICMD_INT2CHAR:
1049   GENERATED  case ICMD_INT2SHORT:
1050   GENERATED     /* (I--I) */
1051   GENERATED     CHECK_STACK_DEPTH(1);
1052   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
1053   GENERATED     break;
1054   GENERATED
1055   GENERATED
1056   GENERATED  case ICMD_LNEG:
1057   GENERATED     /* (L--L) */
1058   GENERATED     CHECK_STACK_DEPTH(2);
1059   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_LNG);
1060   GENERATED     break;
1061   GENERATED
1062   GENERATED
1063   GENERATED  case ICMD_FNEG:
1064   GENERATED     /* (F--F) */
1065   GENERATED     CHECK_STACK_DEPTH(1);
1066   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_FLT);
1067   GENERATED     break;
1068   GENERATED
1069   GENERATED
1070   GENERATED  case ICMD_DNEG:
1071   GENERATED     /* (D--D) */
1072   GENERATED     CHECK_STACK_DEPTH(2);
1073   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_DBL);
1074   GENERATED     break;
1075   GENERATED
1076   GENERATED
1077   GENERATED  case ICMD_LSHL:
1078   GENERATED  case ICMD_LSHR:
1079   GENERATED  case ICMD_LUSHR:
1080   GENERATED     /* (LI--L) */
1081   GENERATED     CHECK_STACK_DEPTH(3);
1082   GENERATED     CHECK_STACK_TYPE(stack[-2], TYPE_LNG);
1083   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
1084   GENERATED     stack += -1;
1085   GENERATED     break;
1086   GENERATED
1087   GENERATED
1088   GENERATED  case ICMD_IINC:
1089   GENERATED     /* (--) */
1090   GENERATED     CHECK_LOCAL_TYPE(IPTR->s1.varindex, TYPE_INT);
1091   GENERATED     break;
1092   GENERATED
1093   GENERATED
1094   GENERATED  case ICMD_I2L:
1095   GENERATED     /* (I--L) */
1096   GENERATED     CHECK_STACK_DEPTH(1);
1097   GENERATED     CHECK_STACK_SPACE(1);
1098   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
1099   GENERATED     stack += 1;
1100   GENERATED     stack[0].type = TYPE_VOID;
1101   GENERATED     stack[-1].type = TYPE_LNG;
1102   GENERATED     break;
1103   GENERATED
1104   GENERATED
1105   GENERATED  case ICMD_I2F:
1106   GENERATED     /* (I--F) */
1107   GENERATED     CHECK_STACK_DEPTH(1);
1108   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
1109   GENERATED     stack[0].type = TYPE_FLT;
1110   GENERATED     break;
1111   GENERATED
1112   GENERATED
1113   GENERATED  case ICMD_I2D:
1114   GENERATED     /* (I--D) */
1115   GENERATED     CHECK_STACK_DEPTH(1);
1116   GENERATED     CHECK_STACK_SPACE(1);
1117   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
1118   GENERATED     stack += 1;
1119   GENERATED     stack[0].type = TYPE_VOID;
1120   GENERATED     stack[-1].type = TYPE_DBL;
1121   GENERATED     break;
1122   GENERATED
1123   GENERATED
1124   GENERATED  case ICMD_L2I:
1125   GENERATED     /* (L--I) */
1126   GENERATED     CHECK_STACK_DEPTH(2);
1127   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_LNG);
1128   GENERATED     stack += -1;
1129   GENERATED     stack[0].type = TYPE_INT;
1130   GENERATED     break;
1131   GENERATED
1132   GENERATED
1133   GENERATED  case ICMD_L2F:
1134   GENERATED     /* (L--F) */
1135   GENERATED     CHECK_STACK_DEPTH(2);
1136   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_LNG);
1137   GENERATED     stack += -1;
1138   GENERATED     stack[0].type = TYPE_FLT;
1139   GENERATED     break;
1140   GENERATED
1141   GENERATED
1142   GENERATED  case ICMD_L2D:
1143   GENERATED     /* (L--D) */
1144   GENERATED     CHECK_STACK_DEPTH(2);
1145   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_LNG);
1146   GENERATED     stack[0].type = TYPE_VOID;
1147   GENERATED     stack[-1].type = TYPE_DBL;
1148   GENERATED     break;
1149   GENERATED
1150   GENERATED
1151   GENERATED  case ICMD_F2I:
1152   GENERATED     /* (F--I) */
1153   GENERATED     CHECK_STACK_DEPTH(1);
1154   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_FLT);
1155   GENERATED     stack[0].type = TYPE_INT;
1156   GENERATED     break;
1157   GENERATED
1158   GENERATED
1159   GENERATED  case ICMD_F2L:
1160   GENERATED     /* (F--L) */
1161   GENERATED     CHECK_STACK_DEPTH(1);
1162   GENERATED     CHECK_STACK_SPACE(1);
1163   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_FLT);
1164   GENERATED     stack += 1;
1165   GENERATED     stack[0].type = TYPE_VOID;
1166   GENERATED     stack[-1].type = TYPE_LNG;
1167   GENERATED     break;
1168   GENERATED
1169   GENERATED
1170   GENERATED  case ICMD_F2D:
1171   GENERATED     /* (F--D) */
1172   GENERATED     CHECK_STACK_DEPTH(1);
1173   GENERATED     CHECK_STACK_SPACE(1);
1174   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_FLT);
1175   GENERATED     stack += 1;
1176   GENERATED     stack[0].type = TYPE_VOID;
1177   GENERATED     stack[-1].type = TYPE_DBL;
1178   GENERATED     break;
1179   GENERATED
1180   GENERATED
1181   GENERATED  case ICMD_D2I:
1182   GENERATED     /* (D--I) */
1183   GENERATED     CHECK_STACK_DEPTH(2);
1184   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_DBL);
1185   GENERATED     stack += -1;
1186   GENERATED     stack[0].type = TYPE_INT;
1187   GENERATED     break;
1188   GENERATED
1189   GENERATED
1190   GENERATED  case ICMD_D2L:
1191   GENERATED     /* (D--L) */
1192   GENERATED     CHECK_STACK_DEPTH(2);
1193   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_DBL);
1194   GENERATED     stack[0].type = TYPE_VOID;
1195   GENERATED     stack[-1].type = TYPE_LNG;
1196   GENERATED     break;
1197   GENERATED
1198   GENERATED
1199   GENERATED  case ICMD_D2F:
1200   GENERATED     /* (D--F) */
1201   GENERATED     CHECK_STACK_DEPTH(2);
1202   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_DBL);
1203   GENERATED     stack += -1;
1204   GENERATED     stack[0].type = TYPE_FLT;
1205   GENERATED     break;
1206   GENERATED
1207   GENERATED
1208   GENERATED  case ICMD_LCMP:
1209   GENERATED     /* (LL--I) */
1210   GENERATED     CHECK_STACK_DEPTH(4);
1211   GENERATED     CHECK_STACK_TYPE(stack[-3], TYPE_LNG);
1212   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_LNG);
1213   GENERATED     stack += -3;
1214   GENERATED     stack[0].type = TYPE_INT;
1215   GENERATED     break;
1216   GENERATED
1217   GENERATED
1218   GENERATED  case ICMD_FCMPL:
1219   GENERATED  case ICMD_FCMPG:
1220   GENERATED     /* (FF--I) */
1221   GENERATED     CHECK_STACK_DEPTH(2);
1222   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_FLT);
1223   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_FLT);
1224   GENERATED     stack += -1;
1225   GENERATED     stack[0].type = TYPE_INT;
1226   GENERATED     break;
1227   GENERATED
1228   GENERATED
1229   GENERATED  case ICMD_DCMPL:
1230   GENERATED  case ICMD_DCMPG:
1231   GENERATED     /* (DD--I) */
1232   GENERATED     CHECK_STACK_DEPTH(4);
1233   GENERATED     CHECK_STACK_TYPE(stack[-3], TYPE_DBL);
1234   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_DBL);
1235   GENERATED     stack += -3;
1236   GENERATED     stack[0].type = TYPE_INT;
1237   GENERATED     break;
1238   GENERATED
1239   GENERATED
1240   GENERATED  case ICMD_IFEQ:
1241   GENERATED  case ICMD_IFNE:
1242   GENERATED  case ICMD_IFLT:
1243   GENERATED  case ICMD_IFGE:
1244   GENERATED  case ICMD_IFGT:
1245   GENERATED  case ICMD_IFLE:
1246   GENERATED     /* (I--) */
1247   GENERATED     CHECK_STACK_DEPTH(1);
1248   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
1249   GENERATED     stack += -1;
1250   GENERATED     /* CAUTION: stack pointer changed before custom code! */
1251   GENERATED
1252 #               define OP1 (&(stack[1]))
1253   GENERATED     /* may use stack[1] ... stack[1] */
1254   GENERATED
1255   GENERATED
1256 #               line 391 "src/vm/jit/verify/icmds.c"
1257   GENERATED     /* {RESULTNOW} */
1258   GENERATED     TYPECHECK_COUNT(stat_ins_branch);
1259   GENERATED
1260   GENERATED     /* propagate stack and variables to the target block */
1261   GENERATED     REACH(IPTR->dst);
1262   GENERATED
1263 #               line 1264 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1264   GENERATED
1265   GENERATED     break;
1266   GENERATED
1267   GENERATED
1268 #               undef OP1
1269   GENERATED
1270   GENERATED
1271   GENERATED  case ICMD_IF_ICMPEQ:
1272   GENERATED  case ICMD_IF_ICMPNE:
1273   GENERATED  case ICMD_IF_ICMPLT:
1274   GENERATED  case ICMD_IF_ICMPGE:
1275   GENERATED  case ICMD_IF_ICMPGT:
1276   GENERATED  case ICMD_IF_ICMPLE:
1277   GENERATED     /* (II--) */
1278   GENERATED     CHECK_STACK_DEPTH(2);
1279   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_INT);
1280   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
1281   GENERATED     stack += -2;
1282   GENERATED     /* CAUTION: stack pointer changed before custom code! */
1283   GENERATED
1284 #               define OP1 (&(stack[1]))
1285   GENERATED
1286 #               define OP2 (&(stack[2]))
1287   GENERATED     /* may use stack[1] ... stack[2] */
1288   GENERATED
1289   GENERATED
1290 #               line 397 "src/vm/jit/verify/icmds.c"
1291   GENERATED     /* {RESULTNOW} */
1292   GENERATED     TYPECHECK_COUNT(stat_ins_branch);
1293   GENERATED
1294   GENERATED     /* propagate stack and variables to the target block */
1295   GENERATED     REACH(IPTR->dst);
1296   GENERATED
1297 #               line 1298 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1298   GENERATED
1299   GENERATED     break;
1300   GENERATED
1301   GENERATED
1302 #               undef OP1
1303   GENERATED
1304 #               undef OP2
1305   GENERATED
1306   GENERATED
1307   GENERATED  case ICMD_IF_ACMPEQ:
1308   GENERATED  case ICMD_IF_ACMPNE:
1309   GENERATED     /* (AA--) */
1310   GENERATED     CHECK_STACK_DEPTH(2);
1311   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_ADR);
1312   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_ADR);
1313   GENERATED     stack += -2;
1314   GENERATED     /* CAUTION: stack pointer changed before custom code! */
1315   GENERATED
1316 #               define OP1 (&(stack[1]))
1317   GENERATED
1318 #               define OP2 (&(stack[2]))
1319   GENERATED     /* may use stack[1] ... stack[2] */
1320   GENERATED
1321   GENERATED
1322 #               line 403 "src/vm/jit/verify/icmds.c"
1323   GENERATED     /* {RESULTNOW} */
1324   GENERATED     TYPECHECK_COUNT(stat_ins_branch);
1325   GENERATED
1326   GENERATED     /* propagate stack and variables to the target block */
1327   GENERATED     REACH(IPTR->dst);
1328   GENERATED
1329 #               line 1330 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1330   GENERATED
1331   GENERATED     break;
1332   GENERATED
1333   GENERATED
1334 #               undef OP1
1335   GENERATED
1336 #               undef OP2
1337   GENERATED
1338   GENERATED
1339   GENERATED  case ICMD_GOTO:
1340   GENERATED     /* (--) */
1341   GENERATED     superblockend = true;
1342   GENERATED
1343   GENERATED
1344 #               line 388 "src/vm/jit/verify/icmds.c"
1345   GENERATED     /* {RESULTNOW} */
1346   GENERATED     TYPECHECK_COUNT(stat_ins_branch);
1347   GENERATED
1348   GENERATED     /* propagate stack and variables to the target block */
1349   GENERATED     REACH(IPTR->dst);
1350   GENERATED
1351 #               line 1352 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1352   GENERATED
1353   GENERATED     break;
1354   GENERATED
1355   GENERATED
1356   GENERATED  case ICMD_JSR:
1357   GENERATED     /* (--R) */
1358   GENERATED     superblockend = true;
1359   GENERATED     CHECK_STACK_SPACE(1);
1360   GENERATED     stack += 1;
1361   GENERATED     stack[0].type = TYPE_RET;
1362   GENERATED     /* CAUTION: stack types changed before custom code! */
1363   GENERATED     /* CAUTION: stack pointer changed before custom code! */
1364   GENERATED
1365 #               define DST  (&(stack[0]))
1366   GENERATED     /* may use stack[0] ... stack[0] */
1367   GENERATED
1368   GENERATED
1369 #               line 558 "src/vm/jit/verify/icmds.c"
1370   GENERATED     /* {RESULTNOW} */
1371   GENERATED     tbptr = IPTR->sx.s23.s3.jsrtarget.block;
1372   GENERATED
1373   GENERATED     TYPEINFO_INIT_RETURNADDRESS(stack[0].typeinfo, tbptr);
1374   GENERATED     REACH_BLOCK(tbptr);
1375   GENERATED
1376   GENERATED     stack = typecheck_stackbased_jsr(STATE, stack, stackfloor);
1377   GENERATED     if (stack == NULL)
1378   GENERATED             EXCEPTION;
1379   GENERATED
1380 #               line 1381 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1381   GENERATED
1382   GENERATED     break;
1383   GENERATED
1384   GENERATED
1385 #               undef DST
1386   GENERATED
1387   GENERATED
1388   GENERATED  case ICMD_RET:
1389   GENERATED     /* (--) */
1390   GENERATED     superblockend = true;
1391   GENERATED
1392   GENERATED
1393 #               line 579 "src/vm/jit/verify/icmds.c"
1394   GENERATED     /* {RESULTNOW} */
1395   GENERATED     CHECK_LOCAL_TYPE(IPTR->s1.varindex, TYPE_RET);
1396   GENERATED     if (!TYPEINFO_IS_PRIMITIVE(STATE->locals[IPTR->s1.varindex].typeinfo))
1397   GENERATED             VERIFY_ERROR("illegal instruction: RET using non-returnAddress variable");
1398   GENERATED
1399   GENERATED     if (!typecheck_stackbased_ret(STATE, stack, stackfloor))
1400   GENERATED             EXCEPTION;
1401   GENERATED
1402 #               line 1403 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1403   GENERATED
1404   GENERATED     break;
1405   GENERATED
1406   GENERATED
1407   GENERATED  case ICMD_TABLESWITCH:
1408   GENERATED     /* (I--) */
1409   GENERATED     superblockend = true;
1410   GENERATED     CHECK_STACK_DEPTH(1);
1411   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
1412   GENERATED     stack += -1;
1413   GENERATED     /* CAUTION: stack pointer changed before custom code! */
1414   GENERATED
1415 #               define OP1 (&(stack[1]))
1416   GENERATED     /* may use stack[1] ... stack[1] */
1417   GENERATED
1418   GENERATED
1419 #               line 429 "src/vm/jit/verify/icmds.c"
1420   GENERATED     /* {RESULTNOW} */
1421   GENERATED     TYPECHECK_COUNT(stat_ins_switch);
1422   GENERATED
1423   GENERATED     table = IPTR->dst.table;
1424   GENERATED     i = IPTR->sx.s23.s3.tablehigh
1425   GENERATED     - IPTR->sx.s23.s2.tablelow + 1 + 1; /* plus default */
1426   GENERATED
1427   GENERATED     while (--i >= 0) {
1428   GENERATED             REACH(*table);
1429   GENERATED             table++;
1430   GENERATED     }
1431   GENERATED
1432   GENERATED     LOG("switch done");
1433   GENERATED
1434 #               line 1435 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1435   GENERATED
1436   GENERATED     break;
1437   GENERATED
1438   GENERATED
1439 #               undef OP1
1440   GENERATED
1441   GENERATED
1442   GENERATED  case ICMD_LOOKUPSWITCH:
1443   GENERATED     /* (I--) */
1444   GENERATED     superblockend = true;
1445   GENERATED     CHECK_STACK_DEPTH(1);
1446   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
1447   GENERATED     stack += -1;
1448   GENERATED     /* CAUTION: stack pointer changed before custom code! */
1449   GENERATED
1450 #               define OP1 (&(stack[1]))
1451   GENERATED     /* may use stack[1] ... stack[1] */
1452   GENERATED
1453   GENERATED
1454 #               line 445 "src/vm/jit/verify/icmds.c"
1455   GENERATED     /* {RESULTNOW} */
1456   GENERATED     TYPECHECK_COUNT(stat_ins_switch);
1457   GENERATED
1458   GENERATED     lookup = IPTR->dst.lookup;
1459   GENERATED     i = IPTR->sx.s23.s2.lookupcount;
1460   GENERATED     REACH(IPTR->sx.s23.s3.lookupdefault);
1461   GENERATED
1462   GENERATED     while (--i >= 0) {
1463   GENERATED             REACH(lookup->target);
1464   GENERATED             lookup++;
1465   GENERATED     }
1466   GENERATED
1467   GENERATED     LOG("switch done");
1468   GENERATED
1469 #               line 1470 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1470   GENERATED
1471   GENERATED     break;
1472   GENERATED
1473   GENERATED
1474 #               undef OP1
1475   GENERATED
1476   GENERATED
1477   GENERATED  case ICMD_IRETURN:
1478   GENERATED     /* (I--) */
1479   GENERATED     superblockend = true;
1480   GENERATED     CHECK_STACK_DEPTH(1);
1481   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_INT);
1482   GENERATED
1483 #               define OP1 (&(stack[0]))
1484   GENERATED     /* may use stack[0] ... stack[0] */
1485   GENERATED
1486   GENERATED
1487 #               line 511 "src/vm/jit/verify/icmds.c"
1488   GENERATED     if (STATE->returntype.type != TYPE_INT)
1489   GENERATED             VERIFY_ERROR("Return type mismatch");
1490   GENERATED
1491 #               line 1492 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1492   GENERATED
1493   GENERATED     goto return_tail;
1494   GENERATED
1495   GENERATED
1496 #               undef OP1
1497   GENERATED
1498   GENERATED
1499   GENERATED  case ICMD_LRETURN:
1500   GENERATED     /* (L--) */
1501   GENERATED     superblockend = true;
1502   GENERATED     CHECK_STACK_DEPTH(2);
1503   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_LNG);
1504   GENERATED
1505 #               define OP1 (&(stack[-1]))
1506   GENERATED     /* may use stack[-1] ... stack[0] */
1507   GENERATED
1508   GENERATED
1509 #               line 516 "src/vm/jit/verify/icmds.c"
1510   GENERATED     if (STATE->returntype.type != TYPE_LNG)
1511   GENERATED             VERIFY_ERROR("Return type mismatch");
1512   GENERATED
1513 #               line 1514 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1514   GENERATED
1515   GENERATED     goto return_tail;
1516   GENERATED
1517   GENERATED
1518 #               undef OP1
1519   GENERATED
1520   GENERATED
1521   GENERATED  case ICMD_FRETURN:
1522   GENERATED     /* (F--) */
1523   GENERATED     superblockend = true;
1524   GENERATED     CHECK_STACK_DEPTH(1);
1525   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_FLT);
1526   GENERATED
1527 #               define OP1 (&(stack[0]))
1528   GENERATED     /* may use stack[0] ... stack[0] */
1529   GENERATED
1530   GENERATED
1531 #               line 521 "src/vm/jit/verify/icmds.c"
1532   GENERATED     if (STATE->returntype.type != TYPE_FLT)
1533   GENERATED             VERIFY_ERROR("Return type mismatch");
1534   GENERATED
1535 #               line 1536 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1536   GENERATED
1537   GENERATED     goto return_tail;
1538   GENERATED
1539   GENERATED
1540 #               undef OP1
1541   GENERATED
1542   GENERATED
1543   GENERATED  case ICMD_DRETURN:
1544   GENERATED     /* (D--) */
1545   GENERATED     superblockend = true;
1546   GENERATED     CHECK_STACK_DEPTH(2);
1547   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_DBL);
1548   GENERATED
1549 #               define OP1 (&(stack[-1]))
1550   GENERATED     /* may use stack[-1] ... stack[0] */
1551   GENERATED
1552   GENERATED
1553 #               line 526 "src/vm/jit/verify/icmds.c"
1554   GENERATED     if (STATE->returntype.type != TYPE_DBL)
1555   GENERATED             VERIFY_ERROR("Return type mismatch");
1556   GENERATED
1557 #               line 1558 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1558   GENERATED
1559   GENERATED     goto return_tail;
1560   GENERATED
1561   GENERATED
1562 #               undef OP1
1563   GENERATED
1564   GENERATED
1565   GENERATED  case ICMD_ARETURN:
1566   GENERATED     /* (A--) */
1567   GENERATED     maythrow = true;
1568   GENERATED     superblockend = true;
1569   GENERATED     CHECK_STACK_DEPTH(1);
1570   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_ADR);
1571   GENERATED
1572 #               define OP1 (&(stack[0]))
1573   GENERATED     /* may use stack[0] ... stack[0] */
1574   GENERATED
1575   GENERATED
1576 #               line 486 "src/vm/jit/verify/icmds.c"
1577   GENERATED     TYPECHECK_COUNT(stat_ins_areturn);
1578   GENERATED     if (!TYPEINFO_IS_REFERENCE(OP1->typeinfo))
1579   GENERATED             VERIFY_ERROR("illegal instruction: ARETURN on non-reference");
1580   GENERATED
1581   GENERATED     if (STATE->returntype.type != TYPE_ADR
1582   GENERATED                     || (r = typeinfo_is_assignable(&OP1->typeinfo,&(STATE->returntype.typeinfo)))
1583   GENERATED                     == typecheck_FALSE)
1584   GENERATED             VERIFY_ERROR("Return type mismatch");
1585   GENERATED     if (r == typecheck_FAIL)
1586   GENERATED             EXCEPTION;
1587   GENERATED     if (r == typecheck_MAYBE) {
1588   GENERATED             /* the check has to be postponed, we need a patcher */
1589   GENERATED             TYPECHECK_COUNT(stat_ins_areturn_unresolved);
1590   GENERATED             IPTR->sx.s23.s2.uc = create_unresolved_class(
1591   GENERATED                             METHOD,
1592   GENERATED                             METHOD->parseddesc->returntype.classref,
1593   GENERATED                             &OP1->typeinfo);
1594   GENERATED             IPTR->flags.bits |= INS_FLAG_UNRESOLVED;
1595   GENERATED     }
1596   GENERATED
1597 #               line 1598 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1598   GENERATED
1599   GENERATED     goto return_tail;
1600   GENERATED
1601   GENERATED
1602 #               undef OP1
1603   GENERATED
1604   GENERATED
1605   GENERATED  case ICMD_RETURN:
1606   GENERATED     /* (--) */
1607   GENERATED     superblockend = true;
1608   GENERATED
1609   GENERATED
1610 #               line 531 "src/vm/jit/verify/icmds.c"
1611   GENERATED     if (STATE->returntype.type != TYPE_VOID)
1612   GENERATED             VERIFY_ERROR("Return type mismatch");
1613   GENERATED
1614   GENERATED  return_tail:
1615   GENERATED     TYPECHECK_COUNT(stat_ins_primitive_return);
1616   GENERATED
1617   GENERATED     if (STATE->initmethod && METHOD->clazz != class_java_lang_Object) {
1618   GENERATED             /* Check if the 'this' instance has been initialized. */
1619   GENERATED             LOG("Checking <init> marker");
1620   GENERATED
1621 #            if defined(TYPECHECK_VARIABLESBASED)
1622   GENERATED             if (!typevector_checktype(jd->var,STATE->numlocals-1,TYPE_INT))
1623   GENERATED
1624 #            else
1625   GENERATED             if (STATE->locals[STATE->numlocals-1].type != TYPE_INT)
1626   GENERATED
1627 #            endif
1628   GENERATED                     VERIFY_ERROR("<init> method does not initialize 'this'");
1629   GENERATED     }
1630   GENERATED
1631 #               line 1632 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1632   GENERATED
1633   GENERATED     break;
1634   GENERATED
1635   GENERATED
1636   GENERATED  case ICMD_GETSTATIC:
1637   GENERATED     /* (--1|--2) */
1638   GENERATED     maythrow = true;
1639   GENERATED     /* variable number of outslots! */
1640   GENERATED
1641   GENERATED
1642 #               line 156 "src/vm/jit/verify/icmds.c"
1643   GENERATED     stack = typecheck_stackbased_verify_fieldaccess(STATE, NULL, NULL, stack);
1644   GENERATED     if (stack == NULL)
1645   GENERATED             EXCEPTION;
1646   GENERATED
1647 #               line 1648 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1648   GENERATED
1649   GENERATED     break;
1650   GENERATED
1651   GENERATED
1652   GENERATED  case ICMD_PUTSTATIC:
1653   GENERATED     /* (1--|2--) */
1654   GENERATED     maythrow = true;
1655   GENERATED     /* variable number of inslots! */
1656   GENERATED
1657   GENERATED
1658 #               line 138 "src/vm/jit/verify/icmds.c"
1659   GENERATED     CHECK_STACK_DEPTH(1);
1660   GENERATED     if (!IS_CAT1(stack[0])) {
1661   GENERATED             /* (stack depth >= 2 is guaranteed) */
1662   GENERATED             stack -= 1;
1663   GENERATED     }
1664   GENERATED     stack = typecheck_stackbased_verify_fieldaccess(STATE, NULL, stack, stack-1);
1665   GENERATED     if (stack == NULL)
1666   GENERATED             EXCEPTION;
1667   GENERATED
1668 #               line 1669 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1669   GENERATED
1670   GENERATED     break;
1671   GENERATED
1672   GENERATED
1673   GENERATED  case ICMD_GETFIELD:
1674   GENERATED     /* (A--1|A--2) */
1675   GENERATED     maythrow = true;
1676   GENERATED     CHECK_STACK_DEPTH(1);
1677   GENERATED     /* variable number of outslots! */
1678   GENERATED
1679   GENERATED
1680 #               line 149 "src/vm/jit/verify/icmds.c"
1681   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_ADR);
1682   GENERATED     stack = typecheck_stackbased_verify_fieldaccess(STATE, stack, NULL, stack-1);
1683   GENERATED     if (stack == NULL)
1684   GENERATED             EXCEPTION;
1685   GENERATED
1686 #               line 1687 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1687   GENERATED
1688   GENERATED     break;
1689   GENERATED
1690   GENERATED
1691   GENERATED  case ICMD_PUTFIELD:
1692   GENERATED     /* (A1--|A2--) */
1693   GENERATED     maythrow = true;
1694   GENERATED     /* variable number of inslots! */
1695   GENERATED
1696   GENERATED
1697 #               line 126 "src/vm/jit/verify/icmds.c"
1698   GENERATED     CHECK_STACK_DEPTH(2);
1699   GENERATED     if (!IS_CAT1(stack[0])) {
1700   GENERATED             CHECK_STACK_DEPTH(3);
1701   GENERATED             stack -= 1;
1702   GENERATED     }
1703   GENERATED     CHECK_STACK_TYPE(stack[-1], TYPE_ADR);
1704   GENERATED     stack = typecheck_stackbased_verify_fieldaccess(STATE, stack-1, stack, stack-2);
1705   GENERATED     if (stack == NULL)
1706   GENERATED             EXCEPTION;
1707   GENERATED
1708 #               line 1709 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1709   GENERATED
1710   GENERATED     break;
1711   GENERATED
1712   GENERATED
1713   GENERATED  case ICMD_INVOKEVIRTUAL:
1714   GENERATED  case ICMD_INVOKESPECIAL:
1715   GENERATED  case ICMD_INVOKESTATIC:
1716   GENERATED  case ICMD_INVOKEINTERFACE:
1717   GENERATED     /* (.--1|.--2|.--) */
1718   GENERATED     maythrow = true;
1719   GENERATED     /* variable number of inslots! */
1720   GENERATED     /* variable number of outslots! */
1721   GENERATED
1722   GENERATED
1723 #               line 602 "src/vm/jit/verify/icmds.c"
1724   GENERATED     TYPECHECK_COUNT(stat_ins_invoke);
1725   GENERATED
1726   GENERATED     INSTRUCTION_GET_METHODDESC(IPTR, md);
1727   GENERATED     CHECK_STACK_DEPTH(md->paramslots);
1728   GENERATED
1729   GENERATED     if (!typecheck_stackbased_verify_invocation(STATE, stack, stackfloor))
1730   GENERATED             EXCEPTION;
1731   GENERATED
1732   GENERATED     stack -= md->paramslots;
1733   GENERATED
1734   GENERATED     if (md->returntype.type != TYPE_VOID) {
1735   GENERATED             if (IS_2_WORD_TYPE(md->returntype.type)) {
1736   GENERATED                     CHECK_STACK_SPACE(2);
1737   GENERATED                     stack += 2;
1738   GENERATED                     stack[0].type = TYPE_VOID;
1739   GENERATED                     stack[-1].type = md->returntype.type;
1740   GENERATED             }
1741   GENERATED             else {
1742   GENERATED                     CHECK_STACK_SPACE(1);
1743   GENERATED                     stack += 1;
1744   GENERATED                     stack[0].type = md->returntype.type;
1745   GENERATED             }
1746   GENERATED     }
1747   GENERATED     TYPECHECK_COUNTIF(INSTRUCTION_IS_UNRESOLVED(IPTR), stat_ins_invoke_unresolved);
1748   GENERATED
1749 #               line 1750 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1750   GENERATED
1751   GENERATED     break;
1752   GENERATED
1753   GENERATED
1754   GENERATED  case ICMD_ARRAYLENGTH:
1755   GENERATED     /* (A--I) */
1756   GENERATED     maythrow = true;
1757   GENERATED     CHECK_STACK_DEPTH(1);
1758   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_ADR);
1759   GENERATED
1760 #               define OP1 (&(stack[0]))
1761   GENERATED
1762 #               define DST  (&(stack[0]))
1763   GENERATED     /* may use stack[0] ... stack[0] */
1764   GENERATED
1765   GENERATED
1766 #               line 231 "src/vm/jit/verify/icmds.c"
1767   GENERATED     if (!TYPEINFO_MAYBE_ARRAY(OP1->typeinfo)
1768   GENERATED                     && OP1->typeinfo.typeclass.cls != pseudo_class_Arraystub)
1769   GENERATED             VERIFY_ERROR("illegal instruction: ARRAYLENGTH on non-array");
1770   GENERATED
1771 #               line 1772 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1772   GENERATED
1773   GENERATED     stack[0].type = TYPE_INT;
1774   GENERATED     break;
1775   GENERATED
1776   GENERATED
1777 #               undef OP1
1778   GENERATED
1779 #               undef DST
1780   GENERATED
1781   GENERATED
1782   GENERATED  case ICMD_ATHROW:
1783   GENERATED     /* (A--) */
1784   GENERATED     maythrow = true;
1785   GENERATED     superblockend = true;
1786   GENERATED     CHECK_STACK_DEPTH(1);
1787   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_ADR);
1788   GENERATED
1789 #               define OP1 (&(stack[0]))
1790   GENERATED     /* may use stack[0] ... stack[0] */
1791   GENERATED
1792   GENERATED
1793 #               line 465 "src/vm/jit/verify/icmds.c"
1794   GENERATED     TYPECHECK_COUNT(stat_ins_athrow);
1795   GENERATED     r = typeinfo_is_assignable_to_class(&OP1->typeinfo,
1796   GENERATED                     CLASSREF_OR_CLASSINFO(class_java_lang_Throwable));
1797   GENERATED     if (r == typecheck_FALSE)
1798   GENERATED             VERIFY_ERROR("illegal instruction: ATHROW on non-Throwable");
1799   GENERATED     if (r == typecheck_FAIL)
1800   GENERATED             EXCEPTION;
1801   GENERATED     if (r == typecheck_MAYBE) {
1802   GENERATED             /* the check has to be postponed. we need a patcher */
1803   GENERATED             TYPECHECK_COUNT(stat_ins_athrow_unresolved);
1804   GENERATED             IPTR->sx.s23.s2.uc = create_unresolved_class(
1805   GENERATED                             METHOD,
1806   GENERATED                             /* XXX make this more efficient, use class_java_lang_Throwable
1807   GENERATED                              * directly */
1808   GENERATED                             class_get_classref(METHOD->clazz,utf_java_lang_Throwable),
1809   GENERATED                             &OP1->typeinfo);
1810   GENERATED             IPTR->flags.bits |= INS_FLAG_UNRESOLVED;
1811   GENERATED     }
1812   GENERATED
1813 #               line 1814 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1814   GENERATED
1815   GENERATED     stack += -1;
1816   GENERATED     break;
1817   GENERATED
1818   GENERATED
1819 #               undef OP1
1820   GENERATED
1821   GENERATED
1822   GENERATED  case ICMD_CHECKCAST:
1823   GENERATED     /* (A--A) */
1824   GENERATED     maythrow = true;
1825   GENERATED     CHECK_STACK_DEPTH(1);
1826   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_ADR);
1827   GENERATED
1828 #               define OP1 (&(stack[0]))
1829   GENERATED
1830 #               define DST  (&(stack[0]))
1831   GENERATED     /* may use stack[0] ... stack[0] */
1832   GENERATED
1833   GENERATED
1834 #               line 365 "src/vm/jit/verify/icmds.c"
1835   GENERATED
1836 #            if !defined(TYPECHECK_TYPEINFERER)
1837   GENERATED     /* returnAddress is not allowed */
1838   GENERATED     if (!TYPEINFO_IS_REFERENCE(OP1->typeinfo))
1839   GENERATED             VERIFY_ERROR("Illegal instruction: CHECKCAST on non-reference");
1840   GENERATED
1841 #            endif
1842   GENERATED
1843   GENERATED      /* XXX only if narrower */
1844   GENERATED     if (!typeinfo_init_class(&(DST->typeinfo),IPTR->sx.s23.s3.c))
1845   GENERATED             EXCEPTION;
1846   GENERATED
1847 #               line 1848 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1848   GENERATED
1849   GENERATED     break;
1850   GENERATED
1851   GENERATED
1852 #               undef OP1
1853   GENERATED
1854 #               undef DST
1855   GENERATED
1856   GENERATED
1857   GENERATED  case ICMD_INSTANCEOF:
1858   GENERATED     /* (A--I) */
1859   GENERATED     maythrow = true;
1860   GENERATED     CHECK_STACK_DEPTH(1);
1861   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_ADR);
1862   GENERATED
1863 #               define OP1 (&(stack[0]))
1864   GENERATED
1865 #               define DST  (&(stack[0]))
1866   GENERATED     /* may use stack[0] ... stack[0] */
1867   GENERATED
1868   GENERATED
1869 #               line 377 "src/vm/jit/verify/icmds.c"
1870   GENERATED     /* returnAddress is not allowed */
1871   GENERATED     if (!TYPEINFO_IS_REFERENCE(OP1->typeinfo))
1872   GENERATED             VERIFY_ERROR("Illegal instruction: INSTANCEOF on non-reference");
1873   GENERATED
1874   GENERATED     /* XXX should propagate type information to the following if-branches */
1875   GENERATED
1876 #               line 1877 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1877   GENERATED
1878   GENERATED     stack[0].type = TYPE_INT;
1879   GENERATED     break;
1880   GENERATED
1881   GENERATED
1882 #               undef OP1
1883   GENERATED
1884 #               undef DST
1885   GENERATED
1886   GENERATED
1887   GENERATED  case ICMD_MULTIANEWARRAY:
1888   GENERATED     /* (.--A) */
1889   GENERATED     maythrow = true;
1890   GENERATED     /* variable number of inslots! */
1891   GENERATED
1892   GENERATED
1893 #               line 640 "src/vm/jit/verify/icmds.c"
1894   GENERATED     if (!typecheck_stackbased_multianewarray(STATE, stack, stackfloor))
1895   GENERATED             EXCEPTION;
1896   GENERATED     stack -= (IPTR->s1.argcount - 1);
1897   GENERATED     stack[0].type = TYPE_ADR;
1898   GENERATED
1899 #               line 1900 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1900   GENERATED
1901   GENERATED     break;
1902   GENERATED
1903   GENERATED
1904   GENERATED  case ICMD_IFNULL:
1905   GENERATED  case ICMD_IFNONNULL:
1906   GENERATED     /* (A--) */
1907   GENERATED     CHECK_STACK_DEPTH(1);
1908   GENERATED     CHECK_STACK_TYPE(stack[0], TYPE_ADR);
1909   GENERATED     stack += -1;
1910   GENERATED     /* CAUTION: stack pointer changed before custom code! */
1911   GENERATED
1912 #               define OP1 (&(stack[1]))
1913   GENERATED     /* may use stack[1] ... stack[1] */
1914   GENERATED
1915   GENERATED
1916 #               line 389 "src/vm/jit/verify/icmds.c"
1917   GENERATED     /* {RESULTNOW} */
1918   GENERATED     TYPECHECK_COUNT(stat_ins_branch);
1919   GENERATED
1920   GENERATED     /* propagate stack and variables to the target block */
1921   GENERATED     REACH(IPTR->dst);
1922   GENERATED
1923 #               line 1924 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1924   GENERATED
1925   GENERATED     break;
1926   GENERATED
1927   GENERATED
1928 #               undef OP1
1929   GENERATED
1930   GENERATED
1931   GENERATED  case ICMD_BUILTIN:
1932   GENERATED     /* (.--1|.--2|.--) */
1933   GENERATED     maythrow = true;
1934   GENERATED     /* variable number of inslots! */
1935   GENERATED     /* variable number of outslots! */
1936   GENERATED
1937   GENERATED
1938 #               line 656 "src/vm/jit/verify/icmds.c"
1939   GENERATED     TYPECHECK_COUNT(stat_ins_builtin);
1940   GENERATED     if (!typecheck_stackbased_verify_builtin(STATE, stack, stackfloor))
1941   GENERATED             EXCEPTION;
1942   GENERATED
1943   GENERATED     /* pop operands and push return value */
1944   GENERATED     {
1945   GENERATED             u1 rtype = IPTR->sx.s23.s3.bte->md->returntype.type;
1946   GENERATED             stack -=  IPTR->sx.s23.s3.bte->md->paramslots;
1947   GENERATED             if (rtype != TYPE_VOID) {
1948   GENERATED                     if (IS_2_WORD_TYPE(rtype))
1949   GENERATED                             stack += 2;
1950   GENERATED                     else
1951   GENERATED                             stack += 1;
1952   GENERATED             }
1953   GENERATED     }
1954   GENERATED
1955 #               line 1956 "src/vm/jit/verify/typecheck-stackbased-gen.inc"
1956   GENERATED
1957   GENERATED     break;
1958   GENERATED
1959   GENERATED
1960 #undef GENERATED
1961 /* vim:filetype=c:
1962  */