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

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