modules/cldc-compact/src/main/java/cc/squirreljme/jvm/Assembly.java

   1 // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the GNU General Public License v3+, or later.
   7 // See license.mkd for licensing and copyright information.
   8 // ---------------------------------------------------------------------------
   9
  10 package cc.squirreljme.jvm;
  11
  12 import cc.squirreljme.jvm.mle.brackets.TypeBracket;
  13 import cc.squirreljme.runtime.cldc.annotation.Exported;
  14
  15 /**
  16  * This class is used special by the compiler to transform all the various
  17  * operations into regular instructions rather than method calls.
  18  *
  19  * The compiler will take all of the method arguments and instead use their
  20  * inputs and outputs from the values of registers instead. However due to
  21  * this, this means that these instructions are purely primitive in that
  22  * they must not depend on any aspect of the virtual machine.
  23  *
  24  * @since 2019/04/20
  25  */
  26 @Exported
  27 @SuppressWarnings({"NewMethodNamingConvention", "OverlyComplexClass"})
  28 public final class Assembly
  29 {
  30         /**
  31          * Not used.
  32          *
  33          * @since 2019/04/20
  34          */
  35         private Assembly()
  36         {
  37         }
  38
  39         /**
  40          * Returns the array length of the given object.
  41          *
  42          * @param __o The object to get the length of.
  43          * @return The length of the array, will return a negative value if not
  44          * an array.
  45          * @since 2020/02/23
  46          */
  47         public static native int arrayLength(int __o);
  48
  49         /**
  50          * Returns the array length of the given object.
  51          *
  52          * @param __o The object to get the length of.
  53          * @return The length of the array, will return a negative value if not
  54          * an array.
  55          * @since 2019/05/24
  56          */
  57         public static native int arrayLength(Object __o);
  58
  59         /**
  60          * Atomic comparison and set.
  61          *
  62          * @param __comp The value to compare and if matches, {@code __set} is
  63          * written.
  64          * @param __set The value to set if matched.
  65          * @param __addr The address to write to.
  66          * @return The value that was read before the set.
  67          * @since 2019/07/01
  68          */
  69         public static native int atomicCompareGetAndSet(int __comp, int __set,
  70                 long __addr);
  71
  72         /**
  73          * Atomically decrements a value and returns the result.
  74          *
  75          * @param __addr The address to decrement.
  76          * @return The get value.
  77          * @since 2019/07/01
  78          */
  79         public static native int atomicDecrementAndGet(long __addr);
  80
  81         /**
  82          * Atomically increments a value.
  83          *
  84          * @param __addr The address to increment.
  85          * @since 2019/07/01
  86          */
  87         public static native void atomicIncrement(long __addr);
  88
  89         /**
  90          * Trigger breakpoint within the virtual machine.
  91          *
  92          * @since 2019/04/21
  93          */
  94         public static native void breakpoint();
  95
  96         /**
  97          * Packs the given two integers to a double value.
  98          *
  99          * @param __lo The low value.
 100          * @param __hi The high value.
 101          * @return The double value.
 102          * @since 2019/06/21
 103          */
 104         public static native double doublePack(int __lo, int __hi);
 105
 106         /**
 107          * Double to raw long bits.
 108          *
 109          * @param __d The input double.
 110          * @return The raw long bits.
 111          * @since 2018/11/03
 112          */
 113         public static native long doubleToRawLongBits(double __d);
 114
 115         /**
 116          * Unpacks the high value of a double.
 117          *
 118          * @param __d The double to unpack.
 119          * @return The unpacked high value.
 120          * @since 2020/02/24
 121          */
 122         @Exported
 123         public static native int doubleUnpackHigh(double __d);
 124
 125         /**
 126          * Unpacks the low value of a double.
 127          *
 128          * @param __d The double to unpack.
 129          * @return The unpacked low value.
 130          * @since 2020/02/24
 131          */
 132         @Exported
 133         public static native int doubleUnpackLow(double __d);
 134
 135         /**
 136          * Performs explicit exception handling.
 137          *
 138          * @since 2019/04/28
 139          */
 140         public static native void exceptionHandle();
 141
 142         /**
 143          * Float to raw int bits.
 144          *
 145          * @param __f The input float.
 146          * @return The raw int bits.
 147          * @since 2018/11/04
 148          */
 149         public static native int floatToRawIntBits(float __f);
 150
 151         /**
 152          * Integer bits to float.
 153          *
 154          * @param __b The input bits.
 155          * @return The resulting float.
 156          * @since 2018/11/04
 157          */
 158         public static native float intBitsToFloat(int __b);
 159
 160         /**
 161          * Invoke method at pointer.
 162          *
 163          * @param __addr The address to invoke.
 164          * @param __pool The pool address to load.
 165          * @since 2019/04/28
 166          */
 167         public static native void invoke(int __addr, int __pool);
 168
 169         /**
 170          * Invoke method at pointer, with arguments.
 171          *
 172          * @param __addr The address to invoke.
 173          * @param __pool The pool address to load.
 174          * @param __a Argument.
 175          * @since 2019/04/28
 176          */
 177         public static native void invoke(int __addr, int __pool, int __a);
 178
 179         /**
 180          * Invoke method at pointer, with arguments.
 181          *
 182          * @param __addr The address to invoke.
 183          * @param __pool The pool address to load.
 184          * @param __a Argument.
 185          * @param __b Argument.
 186          * @since 2019/04/28
 187          */
 188         public static native void invoke(int __addr, int __pool, int __a,
 189                 int __b);
 190
 191         /**
 192          * Invoke method at pointer, with arguments.
 193          *
 194          * @param __addr The address to invoke.
 195          * @param __pool The pool address to load.
 196          * @param __a Argument.
 197          * @param __b Argument.
 198          * @param __c Argument.
 199          * @since 2019/04/28
 200          */
 201         public static native void invoke(int __addr, int __pool, int __a,
 202                 int __b, int __c);
 203
 204         /**
 205          * Invoke method at pointer, with arguments.
 206          *
 207          * @param __addr The address to invoke.
 208          * @param __pool The pool address to load.
 209          * @param __a Argument.
 210          * @param __b Argument.
 211          * @param __c Argument.
 212          * @param __d Argument.
 213          * @since 2019/04/28
 214          */
 215         public static native void invoke(int __addr, int __pool, int __a,
 216                 int __b, int __c, int __d);
 217
 218         /**
 219          * Invoke method at pointer, with arguments.
 220          *
 221          * @param __addr The address to invoke.
 222          * @param __pool The pool address to load.
 223          * @param __a Argument.
 224          * @param __b Argument.
 225          * @param __c Argument.
 226          * @param __d Argument.
 227          * @param __e Argument.
 228          * @since 2019/04/28
 229          */
 230         public static native void invoke(int __addr, int __pool, int __a,
 231                 int __b, int __c, int __d, int __e);
 232
 233         /**
 234          * Invoke method at pointer, with arguments.
 235          *
 236          * @param __addr The address to invoke.
 237          * @param __pool The pool address to load.
 238          * @param __a Argument.
 239          * @param __b Argument.
 240          * @param __c Argument.
 241          * @param __d Argument.
 242          * @param __e Argument.
 243          * @param __f Argument.
 244          * @since 2019/04/28
 245          */
 246         public static native void invoke(int __addr, int __pool, int __a,
 247                 int __b, int __c, int __d, int __e, int __f);
 248
 249         /**
 250          * Invoke method at pointer, with arguments.
 251          *
 252          * @param __addr The address to invoke.
 253          * @param __pool The pool address to load.
 254          * @param __a Argument.
 255          * @param __b Argument.
 256          * @param __c Argument.
 257          * @param __d Argument.
 258          * @param __e Argument.
 259          * @param __f Argument.
 260          * @param __g Argument.
 261          * @since 2019/04/28
 262          */
 263         public static native void invoke(int __addr, int __pool, int __a,
 264                 int __b, int __c, int __d, int __e, int __f, int __g);
 265
 266         /**
 267          * Invoke method at pointer, with arguments.
 268          *
 269          * @param __addr The address to invoke.
 270          * @param __pool The pool address to load.
 271          * @param __a Argument.
 272          * @param __b Argument.
 273          * @param __c Argument.
 274          * @param __d Argument.
 275          * @param __e Argument.
 276          * @param __f Argument.
 277          * @param __g Argument.
 278          * @param __h Argument.
 279          * @since 2019/04/28
 280          */
 281         public static native void invoke(int __addr, int __pool, int __a,
 282                 int __b, int __c, int __d, int __e, int __f, int __g, int __h);
 283
 284         /**
 285          * Invoke method at pointer.
 286          *
 287          * @param __addr The address to invoke.
 288          * @param __pool The pool address to load.
 289          * @return The result of the invocation.
 290          * @since 2019/04/28
 291          */
 292         public static native int invokeV(int __addr, int __pool);
 293
 294         /**
 295          * Invoke method at pointer, with arguments.
 296          *
 297          * @param __addr The address to invoke.
 298          * @param __pool The pool address to load.
 299          * @param __a Argument.
 300          * @return The result of the invocation.
 301          * @since 2019/04/28
 302          */
 303         public static native int invokeV(int __addr, int __pool, int __a);
 304
 305         /**
 306          * Invoke method at pointer, with arguments.
 307          *
 308          * @param __addr The address to invoke.
 309          * @param __pool The pool address to load.
 310          * @param __a Argument.
 311          * @param __b Argument.
 312          * @return The result of the invocation.
 313          * @since 2019/04/28
 314          */
 315         public static native int invokeV(int __addr, int __pool, int __a,
 316                 int __b);
 317
 318         /**
 319          * Invoke method at pointer, with arguments.
 320          *
 321          * @param __addr The address to invoke.
 322          * @param __pool The pool address to load.
 323          * @param __a Argument.
 324          * @param __b Argument.
 325          * @param __c Argument.
 326          * @return The result of the invocation.
 327          * @since 2019/04/28
 328          */
 329         public static native int invokeV(int __addr, int __pool, int __a,
 330                 int __b, int __c);
 331
 332         /**
 333          * Invoke method at pointer, with arguments.
 334          *
 335          * @param __addr The address to invoke.
 336          * @param __pool The pool address to load.
 337          * @param __a Argument.
 338          * @param __b Argument.
 339          * @param __c Argument.
 340          * @param __d Argument.
 341          * @return The result of the invocation.
 342          * @since 2019/04/28
 343          */
 344         public static native int invokeV(int __addr, int __pool, int __a,
 345                 int __b, int __c, int __d);
 346
 347         /**
 348          * Invoke method at pointer, with arguments.
 349          *
 350          * @param __addr The address to invoke.
 351          * @param __pool The pool address to load.
 352          * @param __a Argument.
 353          * @param __b Argument.
 354          * @param __c Argument.
 355          * @param __d Argument.
 356          * @param __e Argument.
 357          * @return The result of the invocation.
 358          * @since 2019/04/28
 359          */
 360         public static native int invokeV(int __addr, int __pool, int __a,
 361                 int __b, int __c, int __d, int __e);
 362
 363         /**
 364          * Invoke method at pointer, with arguments.
 365          *
 366          * @param __addr The address to invoke.
 367          * @param __pool The pool address to load.
 368          * @param __a Argument.
 369          * @param __b Argument.
 370          * @param __c Argument.
 371          * @param __d Argument.
 372          * @param __e Argument.
 373          * @param __f Argument.
 374          * @return The result of the invocation.
 375          * @since 2019/04/28
 376          */
 377         public static native int invokeV(int __addr, int __pool, int __a,
 378                 int __b, int __c, int __d, int __e, int __f);
 379
 380         /**
 381          * Invoke method at pointer, with arguments.
 382          *
 383          * @param __addr The address to invoke.
 384          * @param __pool The pool address to load.
 385          * @param __a Argument.
 386          * @param __b Argument.
 387          * @param __c Argument.
 388          * @param __d Argument.
 389          * @param __e Argument.
 390          * @param __f Argument.
 391          * @param __g Argument.
 392          * @return The result of the invocation.
 393          * @since 2019/04/28
 394          */
 395         public static native int invokeV(int __addr, int __pool, int __a,
 396                 int __b, int __c, int __d, int __e, int __f, int __g);
 397
 398         /**
 399          * Invoke method at pointer, with arguments.
 400          *
 401          * @param __addr The address to invoke.
 402          * @param __pool The pool address to load.
 403          * @param __a Argument.
 404          * @param __b Argument.
 405          * @param __c Argument.
 406          * @param __d Argument.
 407          * @param __e Argument.
 408          * @param __f Argument.
 409          * @param __g Argument.
 410          * @param __h Argument.
 411          * @return The result of the invocation.
 412          * @since 2019/04/28
 413          */
 414         public static native int invokeV(int __addr, int __pool, int __a,
 415                 int __b, int __c, int __d, int __e, int __f, int __g, int __h);
 416
 417         /**
 418          * Invoke method at pointer.
 419          *
 420          * @param __addr The address to invoke.
 421          * @param __pool The pool address to load.
 422          * @return The result of the invocation.
 423          * @since 2019/12/08
 424          */
 425         public static native long invokeVL(int __addr, int __pool);
 426
 427         /**
 428          * Invoke method at pointer, with arguments.
 429          *
 430          * @param __addr The address to invoke.
 431          * @param __pool The pool address to load.
 432          * @param __a Argument.
 433          * @return The result of the invocation.
 434          * @since 2019/12/08
 435          */
 436         public static native long invokeVL(int __addr, int __pool, int __a);
 437
 438         /**
 439          * Invoke method at pointer, with arguments.
 440          *
 441          * @param __addr The address to invoke.
 442          * @param __pool The pool address to load.
 443          * @param __a Argument.
 444          * @param __b Argument.
 445          * @return The result of the invocation.
 446          * @since 2019/12/08
 447          */
 448         public static native long invokeVL(int __addr, int __pool, int __a,
 449                 int __b);
 450
 451         /**
 452          * Invoke method at pointer, with arguments.
 453          *
 454          * @param __addr The address to invoke.
 455          * @param __pool The pool address to load.
 456          * @param __a Argument.
 457          * @param __b Argument.
 458          * @param __c Argument.
 459          * @return The result of the invocation.
 460          * @since 2019/12/08
 461          */
 462         public static native long invokeVL(int __addr, int __pool, int __a,
 463                 int __b, int __c);
 464
 465         /**
 466          * Invoke method at pointer, with arguments.
 467          *
 468          * @param __addr The address to invoke.
 469          * @param __pool The pool address to load.
 470          * @param __a Argument.
 471          * @param __b Argument.
 472          * @param __c Argument.
 473          * @param __d Argument.
 474          * @return The result of the invocation.
 475          * @since 2019/12/08
 476          */
 477         public static native long invokeVL(int __addr, int __pool, int __a,
 478                 int __b, int __c, int __d);
 479
 480         /**
 481          * Invoke method at pointer, with arguments.
 482          *
 483          * @param __addr The address to invoke.
 484          * @param __pool The pool address to load.
 485          * @param __a Argument.
 486          * @param __b Argument.
 487          * @param __c Argument.
 488          * @param __d Argument.
 489          * @param __e Argument.
 490          * @return The result of the invocation.
 491          * @since 2019/12/08
 492          */
 493         public static native long invokeVL(int __addr, int __pool, int __a,
 494                 int __b, int __c, int __d, int __e);
 495
 496         /**
 497          * Invoke method at pointer, with arguments.
 498          *
 499          * @param __addr The address to invoke.
 500          * @param __pool The pool address to load.
 501          * @param __a Argument.
 502          * @param __b Argument.
 503          * @param __c Argument.
 504          * @param __d Argument.
 505          * @param __e Argument.
 506          * @param __f Argument.
 507          * @return The result of the invocation.
 508          * @since 2019/12/08
 509          */
 510         public static native long invokeVL(int __addr, int __pool, int __a,
 511                 int __b, int __c, int __d, int __e, int __f);
 512
 513         /**
 514          * Invoke method at pointer, with arguments.
 515          *
 516          * @param __addr The address to invoke.
 517          * @param __pool The pool address to load.
 518          * @param __a Argument.
 519          * @param __b Argument.
 520          * @param __c Argument.
 521          * @param __d Argument.
 522          * @param __e Argument.
 523          * @param __f Argument.
 524          * @param __g Argument.
 525          * @return The result of the invocation.
 526          * @since 2019/12/08
 527          */
 528         public static native long invokeVL(int __addr, int __pool, int __a,
 529                 int __b, int __c, int __d, int __e, int __f, int __g);
 530
 531         /**
 532          * Invoke method at pointer, with arguments.
 533          *
 534          * @param __addr The address to invoke.
 535          * @param __pool The pool pointer to load.
 536          * @param __a Argument.
 537          * @param __b Argument.
 538          * @param __c Argument.
 539          * @param __d Argument.
 540          * @param __e Argument.
 541          * @param __f Argument.
 542          * @param __g Argument.
 543          * @param __h Argument.
 544          * @return The result of the invocation.
 545          * @since 2019/12/08
 546          */
 547         public static native long invokeVL(int __addr, int __pool, int __a,
 548                 int __b, int __c, int __d, int __e, int __f, int __g, int __h);
 549
 550         /**
 551          * Long bits to double.
 552          *
 553          * @param __b The input bits.
 554          * @return The resulting double.
 555          * @since 2018/11/03
 556          */
 557         public static native double longBitsToDouble(long __b);
 558
 559         /**
 560          * Packs the given two integers to a long value.
 561          *
 562          * @param __lo The low value.
 563          * @param __hi The high value.
 564          * @return The long value.
 565          * @since 2019/06/21
 566          */
 567         @Exported
 568         public static native long longPack(int __lo, int __hi);
 569
 570         /**
 571          * Unpack high value from long.
 572          *
 573          * @param __v The long value.
 574          * @return The unpacked fragment.
 575          * @since 2019/06/21
 576          */
 577         @Exported
 578         public static native int longUnpackHigh(long __v);
 579
 580         /**
 581          * Unpack low value from long.
 582          *
 583          * @param __v The long value.
 584          * @return The unpacked fragment.
 585          * @since 2019/06/21
 586          */
 587         @Exported
 588         public static native int longUnpackLow(long __v);
 589
 590         /**
 591          * Reads the given value from the memory handle.
 592          *
 593          * @param __mh The handle to read from.
 594          * @param __off The offset into the handle.
 595          * @return The value that was read.
 596          * @since 2021/01/23
 597          */
 598         public static native int memHandleReadByte(Object __mh, int __off);
 599
 600         /**
 601          * Reads the given value from the memory handle.
 602          *
 603          * @param __mh The handle to read from.
 604          * @param __off The offset into the handle.
 605          * @return The value that was read.
 606          * @since 2021/01/23
 607          */
 608         public static native int memHandleReadByte(int __mh, int __off);
 609
 610         /**
 611          * Reads the given value from the memory handle.
 612          *
 613          * @param __mh The handle to read from.
 614          * @param __off The offset into the handle.
 615          * @return The value that was read.
 616          * @since 2021/01/23
 617          */
 618         public static native double memHandleReadDouble(Object __mh, int __off);
 619
 620         /**
 621          * Reads the given value from the memory handle.
 622          *
 623          * @param __mh The handle to read from.
 624          * @param __off The offset into the handle.
 625          * @return The value that was read.
 626          * @since 2021/01/23
 627          */
 628         public static native double memHandleReadDouble(int __mh, int __off);
 629
 630         /**
 631          * Reads the given value from the memory handle.
 632          *
 633          * @param __mh The handle to read from.
 634          * @param __off The offset into the handle.
 635          * @return The value that was read.
 636          * @since 2021/01/23
 637          */
 638         public static native float memHandleReadFloat(Object __mh, int __off);
 639
 640         /**
 641          * Reads the given value from the memory handle.
 642          *
 643          * @param __mh The handle to read from.
 644          * @param __off The offset into the handle.
 645          * @return The value that was read.
 646          * @since 2021/01/23
 647          */
 648         public static native float memHandleReadFloat(int __mh, int __off);
 649
 650         /**
 651          * Reads the given value from the memory handle.
 652          *
 653          * @param __mh The handle to read from.
 654          * @param __off The offset into the handle.
 655          * @return The value that was read.
 656          * @since 2021/01/23
 657          */
 658         public static native int memHandleReadInt(Object __mh, int __off);
 659
 660         /**
 661          * Reads the given value from the memory handle.
 662          *
 663          * @param __mh The handle to read from.
 664          * @param __off The offset into the handle.
 665          * @return The value that was read.
 666          * @since 2021/01/23
 667          */
 668         public static native int memHandleReadInt(int __mh, int __off);
 669
 670         /**
 671          * Reads the given value from the memory handle.
 672          *
 673          * @param __mh The handle to read from.
 674          * @param __off The offset into the handle.
 675          * @return The value that was read.
 676          * @since 2021/01/23
 677          */
 678         public static native long memHandleReadLong(Object __mh, int __off);
 679
 680         /**
 681          * Reads the given value from the memory handle.
 682          *
 683          * @param __mh The handle to read from.
 684          * @param __off The offset into the handle.
 685          * @return The value that was read.
 686          * @since 2021/01/23
 687          */
 688         public static native long memHandleReadLong(int __mh, int __off);
 689
 690         /**
 691          * Reads the given value from the memory handle.
 692          *
 693          * @param __mh The handle to read from.
 694          * @param __off The offset into the handle.
 695          * @return The value that was read.
 696          * @since 2021/01/23
 697          */
 698         public static native Object memHandleReadObject(Object __mh, int __off);
 699
 700         /**
 701          * Reads the given value from the memory handle.
 702          *
 703          * @param __mh The handle to read from.
 704          * @param __off The offset into the handle.
 705          * @return The value that was read.
 706          * @since 2021/01/23
 707          */
 708         public static native Object memHandleReadObject(int __mh, int __off);
 709
 710         /**
 711          * Reads the given value from the memory handle.
 712          *
 713          * @param __mh The handle to read from.
 714          * @param __off The offset into the handle.
 715          * @return The value that was read.
 716          * @since 2021/01/23
 717          */
 718         public static native int memHandleReadShort(Object __mh, int __off);
 719
 720         /**
 721          * Reads the given value from the memory handle.
 722          *
 723          * @param __mh The handle to read from.
 724          * @param __off The offset into the handle.
 725          * @return The value that was read.
 726          * @since 2021/01/23
 727          */
 728         public static native int memHandleReadShort(int __mh, int __off);
 729
 730         /**
 731          * Writes the given value to the memory handle.
 732          *
 733          * @param __mh The handle to write to.
 734          * @param __off The offset into the handle.
 735          * @param __v The value to write.
 736          * @since 2021/01/23
 737          */
 738         public static native void memHandleWriteByte(Object __mh, int __off,
 739                 int __v);
 740
 741         /**
 742          * Writes the given value to the memory handle.
 743          *
 744          * @param __mh The handle to write to.
 745          * @param __off The offset into the handle.
 746          * @param __v The value to write.
 747          * @since 2021/01/23
 748          */
 749         public static native void memHandleWriteByte(int __mh, int __off,
 750                 int __v);
 751
 752         /**
 753          * Writes the given value to the memory handle.
 754          *
 755          * @param __mh The handle to write to.
 756          * @param __off The offset into the handle.
 757          * @param __v The value to write.
 758          * @since 2021/01/23
 759          */
 760         public static native void memHandleWriteCharacter(Object __mh, int __off,
 761                 char __v);
 762
 763         /**
 764          * Writes the given value to the memory handle.
 765          *
 766          * @param __mh The handle to write to.
 767          * @param __off The offset into the handle.
 768          * @param __v The value to write.
 769          * @since 2021/01/23
 770          */
 771         public static native void memHandleWriteCharacter(int __mh, int __off,
 772                 char __v);
 773
 774         /**
 775          * Writes the given value to the memory handle.
 776          *
 777          * @param __mh The handle to write to.
 778          * @param __off The offset into the handle.
 779          * @param __v The value to write.
 780          * @since 2021/01/23
 781          */
 782         public static native void memHandleWriteDouble(Object __mh, int __off,
 783                 double __v);
 784
 785         /**
 786          * Writes the given value to the memory handle.
 787          *
 788          * @param __mh The handle to write to.
 789          * @param __off The offset into the handle.
 790          * @param __v The value to write.
 791          * @since 2021/01/23
 792          */
 793         public static native void memHandleWriteDouble(int __mh, int __off,
 794                 double __v);
 795
 796         /**
 797          * Writes the given value to the memory handle.
 798          *
 799          * @param __mh The handle to write to.
 800          * @param __off The offset into the handle.
 801          * @param __v The value to write.
 802          * @since 2021/01/23
 803          */
 804         public static native void memHandleWriteFloat(Object __mh, int __off,
 805                 float __v);
 806
 807         /**
 808          * Writes the given value to the memory handle.
 809          *
 810          * @param __mh The handle to write to.
 811          * @param __off The offset into the handle.
 812          * @param __v The value to write.
 813          * @since 2021/01/23
 814          */
 815         public static native void memHandleWriteFloat(int __mh, int __off,
 816                 float __v);
 817
 818         /**
 819          * Writes the given value to the memory handle.
 820          *
 821          * @param __mh The handle to write to.
 822          * @param __off The offset into the handle.
 823          * @param __v The value to write.
 824          * @since 2021/01/23
 825          */
 826         public static native void memHandleWriteInt(Object __mh, int __off,
 827                 int __v);
 828
 829         /**
 830          * Writes the given value to the memory handle.
 831          *
 832          * @param __mh The handle to write to.
 833          * @param __off The offset into the handle.
 834          * @param __v The value to write.
 835          * @since 2021/01/23
 836          */
 837         public static native void memHandleWriteInt(int __mh, int __off,
 838                 int __v);
 839
 840         /**
 841          * Writes the given value to the memory handle.
 842          *
 843          * @param __mh The handle to write to.
 844          * @param __off The offset into the handle.
 845          * @param __v The value to write.
 846          * @since 2021/01/23
 847          */
 848         public static native void memHandleWriteLong(Object __mh, int __off,
 849                 long __v);
 850
 851         /**
 852          * Writes the given value to the memory handle.
 853          *
 854          * @param __mh The handle to write to.
 855          * @param __off The offset into the handle.
 856          * @param __v The value to write.
 857          * @since 2021/01/23
 858          */
 859         public static native void memHandleWriteLong(int __mh, int __off,
 860                 long __v);
 861
 862         /**
 863          * Writes the given value to the memory handle.
 864          *
 865          * @param __mh The handle to write to.
 866          * @param __off The offset into the handle.
 867          * @param __v The value to write.
 868          * @since 2021/01/23
 869          */
 870         public static native void memHandleWriteObject(Object __mh, int __off,
 871                 Object __v);
 872
 873         /**
 874          * Writes the given value to the memory handle.
 875          *
 876          * @param __mh The handle to write to.
 877          * @param __off The offset into the handle.
 878          * @param __v The value to write.
 879          * @since 2021/01/23
 880          */
 881         public static native void memHandleWriteObject(int __mh, int __off,
 882                 Object __v);
 883
 884         /**
 885          * Writes the given value to the memory handle.
 886          *
 887          * @param __mh The handle to write to.
 888          * @param __off The offset into the handle.
 889          * @param __v The value to write.
 890          * @since 2021/01/23
 891          */
 892         public static native void memHandleWriteShort(Object __mh, int __off,
 893                 int __v);
 894
 895         /**
 896          * Writes the given value to the memory handle.
 897          *
 898          * @param __mh The handle to write to.
 899          * @param __off The offset into the handle.
 900          * @param __v The value to write.
 901          * @since 2021/01/23
 902          */
 903         public static native void memHandleWriteShort(int __mh, int __off,
 904                 int __v);
 905
 906         /**
 907          * Reads byte from address.
 908          *
 909          * @param __p The pointer.
 910          * @param __o The offset.
 911          * @return The result of the read.
 912          * @since 2019/04/22
 913          */
 914         public static native int memReadByte(long __p, int __o);
 915
 916         /**
 917          * Reads character from address.
 918          *
 919          * @param __p The pointer.
 920          * @param __o The offset.
 921          * @return The result of the read.
 922          * @since 2021/02/14
 923          */
 924         public static native char memReadCharacter(long __p, int __o);
 925
 926         /**
 927          * Reads double from address.
 928          *
 929          * @param __p The pointer.
 930          * @param __o The offset.
 931          * @return The result of the read.
 932          * @since 2021/02/14
 933          */
 934         public static native double memReadDouble(long __p, int __o);
 935
 936         /**
 937          * Reads float from address.
 938          *
 939          * @param __p The pointer.
 940          * @param __o The offset.
 941          * @return The result of the read.
 942          * @since 2021/02/14
 943          */
 944         public static native float memReadFloat(long __p, int __o);
 945
 946         /**
 947          * Reads integer from address.
 948          *
 949          * @param __p The pointer.
 950          * @param __o The offset.
 951          * @return The result of the read.
 952          * @since 2019/04/21
 953          */
 954         public static native int memReadInt(long __p, int __o);
 955
 956         /**
 957          * Reads long from address.
 958          *
 959          * @param __p The pointer.
 960          * @param __o The offset.
 961          * @return The result of the read.
 962          * @since 2019/04/22
 963          */
 964         public static native long memReadLong(long __p, int __o);
 965
 966         /**
 967          * Reads object from address.
 968          *
 969          * @param __p The pointer.
 970          * @param __o The offset.
 971          * @return The result of the read.
 972          * @since 2021/02/14
 973          */
 974         public static native Object memReadObject(long __p, int __o);
 975
 976         /**
 977          * Reads short from address.
 978          *
 979          * @param __p The pointer.
 980          * @param __o The offset.
 981          * @return The result of the read.
 982          * @since 2019/04/22
 983          */
 984         public static native int memReadShort(long __p, int __o);
 985
 986         /**
 987          * Writes byte to address.
 988          *
 989          * @param __p The pointer.
 990          * @param __o The offset.
 991          * @param __v The value to write.
 992          * @since 2019/04/21
 993          */
 994         public static native void memWriteByte(long __p, int __o, int __v);
 995
 996         /**
 997          * Writes double to address.
 998          *
 999          * @param __p The pointer.
1000          * @param __o The offset.
1001          * @param __v The value to write.
1002          * @since 2020/02/14
1003          */
1004         public static native void memWriteDouble(long __p, int __o, double __v);
1005
1006         /**
1007          * Writes float to address.
1008          *
1009          * @param __p The pointer.
1010          * @param __o The offset.
1011          * @param __v The value to write.
1012          * @since 2020/02/14
1013          */
1014         public static native void memWriteFloat(long __p, int __o, double __v);
1015
1016         /**
1017          * Writes integer to address.
1018          *
1019          * @param __p The pointer.
1020          * @param __o The offset.
1021          * @param __v The value to write.
1022          * @since 2019/04/21
1023          */
1024         public static native void memWriteInt(long __p, int __o, int __v);
1025
1026         /**
1027          * Writes long to address.
1028          *
1029          * @param __p The pointer.
1030          * @param __o The offset.
1031          * @param __v The value to write.
1032          * @since 2020/02/24
1033          */
1034         public static native void memWriteLong(long __p, int __o, long __v);
1035
1036         /**
1037          * Writes object to address.
1038          *
1039          * @param __p The pointer.
1040          * @param __o The offset.
1041          * @param __v The value to write.
1042          * @since 2020/02/14
1043          */
1044         public static native void memWriteObject(long __p, int __o, Object __v);
1045
1046         /**
1047          * Writes short to address.
1048          *
1049          * @param __p The pointer.
1050          * @param __o The offset.
1051          * @param __v The value to write.
1052          * @since 2019/04/21
1053          */
1054         public static native void memWriteShort(long __p, int __o, int __v);
1055
1056         /**
1057          * Atomically decrements an object's monitor count.
1058          *
1059          * @param __p The object to count.
1060          * @return The resulting value.
1061          * @since 2020/02/24
1062          */
1063         public static native int monitorCountDecrementAndGetAtomic(long __p);
1064
1065         /**
1066          * Atomically decrements an object's monitor count.
1067          *
1068          * @param __p The object to count.
1069          * @return The resulting value.
1070          * @since 2020/02/24
1071          */
1072         public static native int monitorCountDecrementAndGetAtomic(Object __p);
1073
1074         /**
1075          * Atomically increments an object's monitor count.
1076          *
1077          * @param __p The object to count.
1078          * @return The resulting value.
1079          * @since 2020/02/24
1080          */
1081         public static native int monitorCountIncrementAndGetAtomic(long __p);
1082
1083         /**
1084          * Atomically increments an object's monitor count.
1085          *
1086          * @param __p The object to count.
1087          * @return The resulting value.
1088          * @since 2020/02/24
1089          */
1090         public static native int monitorCountIncrementAndGetAtomic(Object __p);
1091
1092         /**
1093          * Atomically reads the object's monitor count.
1094          *
1095          * @param __p The object to read.
1096          * @return The current monitor count.
1097          * @since 2020/02/24
1098          */
1099         public static native int monitorCountGetAtomic(long __p);
1100
1101         /**
1102          * Atomically reads the object's monitor count.
1103          *
1104          * @param __p The object to read.
1105          * @return The current monitor count.
1106          * @since 2020/02/24
1107          */
1108         public static native int monitorCountGetAtomic(Object __p);
1109
1110         /**
1111          * Atomically writes the object's monitor count.
1112          *
1113          * @param __p The object to write.
1114          * @param __v The count to write.
1115          * @since 2020/02/24
1116          */
1117         public static native void monitorCountSetAtomic(long __p, int __v);
1118
1119         /**
1120          * Atomically writes the object's monitor count.
1121          *
1122          * @param __p The object to write.
1123          * @param __v The count to write.
1124          * @since 2020/02/24
1125          */
1126         public static native void monitorCountSetAtomic(Object __p, int __v);
1127
1128         /**
1129          * Atomically compares the owner of the object's monitor and sets it,
1130          * returning the value before it was set (or was unchanged).
1131          *
1132          * @param __p The object to potentially modify.
1133          * @param __comp The owner to compare against.
1134          * @param __set The owner to set to, if the comparison succeeds.
1135          * @return The owner that originally was set.
1136          * @since 2020/02/24
1137          */
1138         public static native Thread monitorOwnerCompareGetAndSetAtomic(
1139                 long __p, long __comp, long __set);
1140
1141         /**
1142          * Atomically compares the owner of the object's monitor and sets it,
1143          * returning the value before it was set (or was unchanged).
1144          *
1145          * @param __p The object to potentially modify.
1146          * @param __comp The owner to compare against.
1147          * @param __set The owner to set to, if the comparison succeeds.
1148          * @return The owner that originally was set.
1149          * @since 2020/02/24
1150          */
1151         public static native Thread monitorOwnerCompareGetAndSetAtomic(
1152                 Object __p, long __comp, long __set);
1153
1154         /**
1155          * Atomically compares the owner of the object's monitor and sets it,
1156          * returning the value before it was set (or was unchanged).
1157          *
1158          * @param __p The object to potentially modify.
1159          * @param __comp The owner to compare against.
1160          * @param __set The owner to set to, if the comparison succeeds.
1161          * @return The owner that originally was set.
1162          * @since 2020/02/24
1163          */
1164         public static native Thread monitorOwnerCompareGetAndSetAtomic(
1165                 long __p, Thread __comp, Thread __set);
1166
1167         /**
1168          * Atomically compares the owner of the object's monitor and sets it,
1169          * returning the value before it was set (or was unchanged).
1170          *
1171          * @param __p The object to potentially modify.
1172          * @param __comp The owner to compare against.
1173          * @param __set The owner to set to, if the comparison succeeds.
1174          * @return The owner that originally was set.
1175          * @since 2020/02/24
1176          */
1177         public static native Thread monitorOwnerCompareGetAndSetAtomic(
1178                 Object __p, Thread __comp, Thread __set);
1179
1180         /**
1181          * Atomically compares the owner of the object's monitor and sets it,
1182          * returning the value before it was set (or was unchanged).
1183          *
1184          * @param __p The object to potentially modify.
1185          * @param __comp The owner to compare against.
1186          * @param __set The owner to set to, if the comparison succeeds.
1187          * @return The owner that originally was set.
1188          * @since 2020/02/24
1189          */
1190         public static native long monitorOwnerCompareGetAndSetAtomicPointer(
1191                 long __p, long __comp, long __set);
1192
1193         /**
1194          * Atomically compares the owner of the object's monitor and sets it,
1195          * returning the value before it was set (or was unchanged).
1196          *
1197          * @param __p The object to potentially modify.
1198          * @param __comp The owner to compare against.
1199          * @param __set The owner to set to, if the comparison succeeds.
1200          * @return The owner that originally was set.
1201          * @since 2020/02/24
1202          */
1203         public static native long monitorOwnerCompareGetAndSetAtomicPointer(
1204                 Object __p, long __comp, long __set);
1205
1206         /**
1207          * Atomically compares the owner of the object's monitor and sets it,
1208          * returning the value before it was set (or was unchanged).
1209          *
1210          * @param __p The object to potentially modify.
1211          * @param __comp The owner to compare against.
1212          * @param __set The owner to set to, if the comparison succeeds.
1213          * @return The owner that originally was set.
1214          * @since 2020/02/24
1215          */
1216         public static native long monitorOwnerCompareGetAndSetAtomicPointer(
1217                 long __p, Thread __comp, Thread __set);
1218
1219         /**
1220          * Atomically compares the owner of the object's monitor and sets it,
1221          * returning the value before it was set (or was unchanged).
1222          *
1223          * @param __p The object to potentially modify.
1224          * @param __comp The owner to compare against.
1225          * @param __set The owner to set to, if the comparison succeeds.
1226          * @return The owner that originally was set.
1227          * @since 2020/02/24
1228          */
1229         public static native long monitorOwnerCompareGetAndSetAtomicPointer(
1230                 Object __p, Thread __comp, Thread __set);
1231
1232         /**
1233          * Returns the owner of an object's monitor.
1234          *
1235          * @param __p The object to get the owner from.
1236          * @return The owner of the object's monitor.
1237          * @since 2020/02/24
1238          */
1239         public static native Thread monitorOwnerGetAtomic(long __p);
1240
1241         /**
1242          * Returns the owner of an object's monitor.
1243          *
1244          * @param __p The object to get the owner from.
1245          * @return The owner of the object's monitor.
1246          * @since 2020/02/24
1247          */
1248         public static native Thread monitorOwnerGetAtomic(Object __p);
1249
1250         /**
1251          * Returns the owner of an object's monitor.
1252          *
1253          * @param __p The object to get the owner from.
1254          * @return The owner of the object's monitor.
1255          * @since 2020/02/24
1256          */
1257         public static native long monitorOwnerGetPointerAtomic(long __p);
1258
1259         /**
1260          * Returns the owner of an object's monitor.
1261          *
1262          * @param __p The object to get the owner from.
1263          * @return The owner of the object's monitor.
1264          * @since 2020/02/24
1265          */
1266         public static native long monitorOwnerGetPointerAtomic(Object __p);
1267
1268         /**
1269          * Sets the owner of an object's monitor.
1270          *
1271          * @param __p The object which will be set the new owner.
1272          * @param __t The owner to set.
1273          * @since 2020/02/24
1274          */
1275         public static native void monitorOwnerSetAtomic(long __p, long __t);
1276
1277         /**
1278          * Sets the owner of an object's monitor.
1279          *
1280          * @param __p The object which will be set the new owner.
1281          * @param __t The owner to set.
1282          * @since 2020/02/24
1283          */
1284         public static native void monitorOwnerSetAtomic(long __p, Thread __t);
1285
1286         /**
1287          * Sets the owner of an object's monitor.
1288          *
1289          * @param __p The object which will be set the new owner.
1290          * @param __t The owner to set.
1291          * @since 2020/02/24
1292          */
1293         public static native void monitorOwnerSetAtomic(Object __p, long __t);
1294
1295         /**
1296          * Sets the owner of an object's monitor.
1297          *
1298          * @param __p The object which will be set the new owner.
1299          * @param __t The owner to set.
1300          * @since 2020/02/24
1301          */
1302         public static native void monitorOwnerSetAtomic(Object __p, Thread __t);
1303
1304         /**
1305          * Used to convert an object to a pointer.
1306          *
1307          * @param __o The object.
1308          * @return The pointer of the object.
1309          * @since 2020/11/29
1310          */
1311         public static native int objectToPointer(Object __o);
1312
1313         /**
1314          * Used to convert an object to a pointer, do use reference queing for it
1315          * so that if the object is a candidate for reference counting it will
1316          * be uncounted.
1317          *
1318          * @param __o The object.
1319          * @return The pointer of the object.
1320          * @since 2019/04/21
1321          */
1322         public static native int objectToPointerRefQueue(Object __o);
1323
1324         /**
1325          * Generates a ping, similar to a breakpoint but not fatal.
1326          *
1327          * @since 2021/01/24
1328          */
1329         public static native void ping();
1330
1331         /**
1332          * Converts a pointer to {@link TypeBracket}.
1333          *
1334          * @param __p The pointer.
1335          * @return The object of the pointer.
1336          * @since 2021/01/24
1337          */
1338         public static native TypeBracket pointerToTypeBracket(int __p);
1339
1340         /**
1341          * Used to convert a pointer to an object.
1342          *
1343          * @param __p The pointer.
1344          * @return The object of the pointer.
1345          * @since 2019/04/21
1346          */
1347         public static native Object pointerToObject(int __p);
1348
1349         /**
1350          * Loads a value from the constant pool at the given index.
1351          *
1352          * @param __p The memory address of the pool to access.
1353          * @param __i The index to load.
1354          * @return The read value.
1355          * @since 2020/02/24
1356          */
1357         public static native int poolLoad(int __p, int __i);
1358
1359         /**
1360          * Loads a value from the constant pool at the given index.
1361          *
1362          * @param __p The object representation of the pool to access.
1363          * @param __i The index to load.
1364          * @return The read value.
1365          * @since 2020/02/24
1366          */
1367         public static native int poolLoad(Object __p, int __i);
1368
1369         /**
1370          * Perform reference counting logic on object.
1371          *
1372          * @param __p The object to count up.
1373          * @since 2019/05/25
1374          */
1375         public static native void refCount(int __p);
1376
1377         /**
1378          * Perform reference counting logic on object.
1379          *
1380          * @param __p The object to count up.
1381          * @since 2020/02/24
1382          */
1383         public static native void refCount(Object __p);
1384
1385         /**
1386          * Get reference count of object.
1387          *
1388          * @param __p The object to get the count for.
1389          * @return The reference count of the object.
1390          * @since 2020/02/24
1391          */
1392         public static native int refGetCount(int __p);
1393
1394         /**
1395          * Get reference count of object.
1396          *
1397          * @param __p The object to get the count for.
1398          * @return The reference count of the object.
1399          * @since 2020/02/24
1400          */
1401         public static native int refGetCount(Object __p);
1402
1403         /**
1404          * Set reference count of object.
1405          *
1406          * @param __p The object to set the count for.
1407          * @param __v The value to set.
1408          * @since 2020/02/24
1409          */
1410         public static native void refSetCount(int __p, int __v);
1411
1412         /**
1413          * Set reference count of object.
1414          *
1415          * @param __p The object to set the count for.
1416          * @param __v The value to set.
1417          * @since 2020/02/24
1418          */
1419         public static native void refSetCount(Object __p, int __v);
1420
1421         /**
1422          * Perform reference uncounting logic on object.
1423          *
1424          * @param __p The object to count down.
1425          * @since 2019/05/25
1426          */
1427         public static native void refUncount(int __p);
1428
1429         /**
1430          * Perform reference uncounting logic on object.
1431          *
1432          * @param __p The object to count down.
1433          * @since 2020/02/24
1434          */
1435         public static native void refUncount(Object __p);
1436
1437         /**
1438          * Return from the current frame.
1439          *
1440          * @since 2019/04/21
1441          */
1442         public static native void returnFrame();
1443
1444         /**
1445          * Returns from the current frame, returning the given value.
1446          *
1447          * @param __v The value to return.
1448          * @since 2019/04/28
1449          */
1450         public static native void returnFrame(int __v);
1451
1452         /**
1453          * Returns from the current frame, returning both values.
1454          *
1455          * @param __h The high value.
1456          * @param __l The low value.
1457          * @since 2019/04/28
1458          */
1459         public static native void returnFrame(int __h, int __l);
1460
1461         /**
1462          * Returns from the current frame, returning a long value.
1463          *
1464          * @param __v The value.
1465          * @since 2020/02/24
1466          */
1467         public static native void returnFrameLong(long __v);
1468
1469         /**
1470          * Returns the exception register.
1471          *
1472          * @return The exception register.
1473          * @since 2020/02/24
1474          */
1475         public static native Object specialGetExceptionRegister();
1476
1477         /**
1478          * Returns the exception register.
1479          *
1480          * @return The exception register.
1481          * @since 2020/02/24
1482          */
1483         public static native Throwable specialGetExceptionRegisterThrowable();
1484
1485         /**
1486          * Returns the exception register.
1487          *
1488          * @return The exception register.
1489          * @since 2019/04/28
1490          */
1491         public static native long specialGetExceptionRegisterPointer();
1492
1493         /**
1494          * Returns the value of the current pool register.
1495          *
1496          * @return The value of the pool register.
1497          * @since 2020/02/24
1498          */
1499         public static native Object specialGetPoolRegister();
1500
1501         /**
1502          * Returns the value of the current pool register.
1503          *
1504          * @return The value of the pool register.
1505          * @since 2019/05/01
1506          */
1507         public static native long specialGetPoolRegisterPointer();
1508
1509         /**
1510          * Returns the value of the return register, for long return values this
1511          * is the first high register.
1512          *
1513          * @return The value of the return register.
1514          * @since 2019/04/28
1515          */
1516         public static native int specialGetReturnRegister();
1517
1518         /**
1519          * Reads the long value from the return register, treating it as a long
1520          * value.
1521          *
1522          * @return The value of the return register.
1523          * @since 2020/02/24
1524          */
1525         public static native long specialGetReturnRegisterLong();
1526
1527         /**
1528          * Returns the register representing the current thread.
1529          *
1530          * @return The current thread register.
1531          * @since 2019/04/22
1532          */
1533         public static native Thread specialGetThreadRegister();
1534
1535         /**
1536          * Returns the register representing the current thread.
1537          *
1538          * @return The current thread register.
1539          * @since 2020/02/24
1540          */
1541         public static native long specialGetThreadRegisterPointer();
1542
1543         /**
1544          * Sets the value of the exception register.
1545          *
1546          * @param __v The value to use.
1547          * @since 2019/04/28
1548          */
1549         public static native void specialSetExceptionRegister(long __v);
1550
1551         /**
1552          * Sets the value of the exception register.
1553          *
1554          * @param __v The value to use.
1555          * @since 2020/02/24
1556          */
1557         public static native void specialSetExceptionRegister(Object __v);
1558
1559         /**
1560          * Sets the value of the constant pool register.
1561          *
1562          * @param __v The new value of the constant pool register.
1563          * @since 2019/05/01
1564          */
1565         public static native void specialSetPoolRegister(long __v);
1566
1567         /**
1568          * Sets the value of the constant pool register.
1569          *
1570          * @param __v The new value of the constant pool register.
1571          * @since 2020/02/24
1572          */
1573         public static native void specialSetPoolRegister(Object __v);
1574
1575         /**
1576          * Sets the current thread pointer.
1577          *
1578          * @param __v The value to use.
1579          * @since 2019/04/27
1580          */
1581         public static native void specialSetThreadRegister(long __v);
1582
1583         /**
1584          * Sets the current thread pointer.
1585          *
1586          * @param __v The value to use.
1587          * @since 2020/02/24
1588          */
1589         public static native void specialSetThreadRegister(Thread __v);
1590 }