1/*
2 * Copyright (c) 2013, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23package org.graalvm.compiler.word;
24
25import org.graalvm.compiler.core.common.LocationIdentity;
26import org.graalvm.compiler.word.Word.Opcode;
27import org.graalvm.compiler.word.Word.Operation;
28
29/**
30 * Low-level memory access for Objects. Similarly to the readXxx and writeXxx methods defined for
31 * {@link Pointer}, these methods access the raw memory without any null checks, read- or write
32 * barriers. When the VM uses compressed pointers, then readObject and writeObject methods access
33 * compressed pointers.
34 */
35public final class ObjectAccess {
36
37    /**
38     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
39     * <p>
40     * The offset is always treated as a {@link Signed} value. However, the static type is
41     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
42     * knows that the highest-order bit of the unsigned value is never used).
43     *
44     * @param object the base object for the memory access
45     * @param offset the signed offset for the memory access
46     * @param locationIdentity the identity of the read
47     * @return the result of the memory access
48     */
49    @Operation(opcode = Opcode.READ_OBJECT)
50    public static native byte readByte(Object object, WordBase offset, LocationIdentity locationIdentity);
51
52    /**
53     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
54     * <p>
55     * The offset is always treated as a {@link Signed} value. However, the static type is
56     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
57     * knows that the highest-order bit of the unsigned value is never used).
58     *
59     * @param object the base object for the memory access
60     * @param offset the signed offset for the memory access
61     * @param locationIdentity the identity of the read
62     * @return the result of the memory access
63     */
64    @Operation(opcode = Opcode.READ_OBJECT)
65    public static native char readChar(Object object, WordBase offset, LocationIdentity locationIdentity);
66
67    /**
68     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
69     * <p>
70     * The offset is always treated as a {@link Signed} value. However, the static type is
71     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
72     * knows that the highest-order bit of the unsigned value is never used).
73     *
74     * @param object the base object for the memory access
75     * @param offset the signed offset for the memory access
76     * @param locationIdentity the identity of the read
77     * @return the result of the memory access
78     */
79    @Operation(opcode = Opcode.READ_OBJECT)
80    public static native short readShort(Object object, WordBase offset, LocationIdentity locationIdentity);
81
82    /**
83     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
84     * <p>
85     * The offset is always treated as a {@link Signed} value. However, the static type is
86     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
87     * knows that the highest-order bit of the unsigned value is never used).
88     *
89     * @param object the base object for the memory access
90     * @param offset the signed offset for the memory access
91     * @param locationIdentity the identity of the read
92     * @return the result of the memory access
93     */
94    @Operation(opcode = Opcode.READ_OBJECT)
95    public static native int readInt(Object object, WordBase offset, LocationIdentity locationIdentity);
96
97    /**
98     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
99     * <p>
100     * The offset is always treated as a {@link Signed} value. However, the static type is
101     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
102     * knows that the highest-order bit of the unsigned value is never used).
103     *
104     * @param object the base object for the memory access
105     * @param offset the signed offset for the memory access
106     * @param locationIdentity the identity of the read
107     * @return the result of the memory access
108     */
109    @Operation(opcode = Opcode.READ_OBJECT)
110    public static native long readLong(Object object, WordBase offset, LocationIdentity locationIdentity);
111
112    /**
113     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
114     * <p>
115     * The offset is always treated as a {@link Signed} value. However, the static type is
116     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
117     * knows that the highest-order bit of the unsigned value is never used).
118     *
119     * @param object the base object for the memory access
120     * @param offset the signed offset for the memory access
121     * @param locationIdentity the identity of the read
122     * @return the result of the memory access
123     */
124    @Operation(opcode = Opcode.READ_OBJECT)
125    public static native float readFloat(Object object, WordBase offset, LocationIdentity locationIdentity);
126
127    /**
128     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
129     * <p>
130     * The offset is always treated as a {@link Signed} value. However, the static type is
131     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
132     * knows that the highest-order bit of the unsigned value is never used).
133     *
134     * @param object the base object for the memory access
135     * @param offset the signed offset for the memory access
136     * @param locationIdentity the identity of the read
137     * @return the result of the memory access
138     */
139    @Operation(opcode = Opcode.READ_OBJECT)
140    public static native double readDouble(Object object, WordBase offset, LocationIdentity locationIdentity);
141
142    /**
143     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
144     * <p>
145     * The offset is always treated as a {@link Signed} value. However, the static type is
146     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
147     * knows that the highest-order bit of the unsigned value is never used).
148     *
149     * @param object the base object for the memory access
150     * @param offset the signed offset for the memory access
151     * @param locationIdentity the identity of the read
152     * @return the result of the memory access
153     */
154    @Operation(opcode = Opcode.READ_OBJECT)
155    public static native Word readWord(Object object, WordBase offset, LocationIdentity locationIdentity);
156
157    /**
158     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
159     * <p>
160     * The offset is always treated as a {@link Signed} value. However, the static type is
161     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
162     * knows that the highest-order bit of the unsigned value is never used).
163     *
164     * @param object the base object for the memory access
165     * @param offset the signed offset for the memory access
166     * @param locationIdentity the identity of the read
167     * @return the result of the memory access
168     */
169    @Operation(opcode = Opcode.READ_OBJECT)
170    public static native Object readObject(Object object, WordBase offset, LocationIdentity locationIdentity);
171
172    /**
173     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
174     *
175     * @param object the base object for the memory access
176     * @param offset the signed offset for the memory access
177     * @param locationIdentity the identity of the read
178     * @return the result of the memory access
179     */
180    @Operation(opcode = Opcode.READ_OBJECT)
181    public static native byte readByte(Object object, int offset, LocationIdentity locationIdentity);
182
183    /**
184     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
185     *
186     * @param object the base object for the memory access
187     * @param offset the signed offset for the memory access
188     * @param locationIdentity the identity of the read
189     * @return the result of the memory access
190     */
191    @Operation(opcode = Opcode.READ_OBJECT)
192    public static native char readChar(Object object, int offset, LocationIdentity locationIdentity);
193
194    /**
195     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
196     *
197     * @param object the base object for the memory access
198     * @param offset the signed offset for the memory access
199     * @param locationIdentity the identity of the read
200     * @return the result of the memory access
201     */
202    @Operation(opcode = Opcode.READ_OBJECT)
203    public static native short readShort(Object object, int offset, LocationIdentity locationIdentity);
204
205    /**
206     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
207     *
208     * @param object the base object for the memory access
209     * @param offset the signed offset for the memory access
210     * @param locationIdentity the identity of the read
211     * @return the result of the memory access
212     */
213    @Operation(opcode = Opcode.READ_OBJECT)
214    public static native int readInt(Object object, int offset, LocationIdentity locationIdentity);
215
216    /**
217     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
218     *
219     * @param object the base object for the memory access
220     * @param offset the signed offset for the memory access
221     * @param locationIdentity the identity of the read
222     * @return the result of the memory access
223     */
224    @Operation(opcode = Opcode.READ_OBJECT)
225    public static native long readLong(Object object, int offset, LocationIdentity locationIdentity);
226
227    /**
228     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
229     *
230     * @param object the base object for the memory access
231     * @param offset the signed offset for the memory access
232     * @param locationIdentity the identity of the read
233     * @return the result of the memory access
234     */
235    @Operation(opcode = Opcode.READ_OBJECT)
236    public static native float readFloat(Object object, int offset, LocationIdentity locationIdentity);
237
238    /**
239     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
240     *
241     * @param object the base object for the memory access
242     * @param offset the signed offset for the memory access
243     * @param locationIdentity the identity of the read
244     * @return the result of the memory access
245     */
246    @Operation(opcode = Opcode.READ_OBJECT)
247    public static native double readDouble(Object object, int offset, LocationIdentity locationIdentity);
248
249    /**
250     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
251     *
252     * @param object the base object for the memory access
253     * @param offset the signed offset for the memory access
254     * @param locationIdentity the identity of the read
255     * @return the result of the memory access
256     */
257    @Operation(opcode = Opcode.READ_OBJECT)
258    public static native Word readWord(Object object, int offset, LocationIdentity locationIdentity);
259
260    /**
261     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
262     *
263     * @param object the base object for the memory access
264     * @param offset the signed offset for the memory access
265     * @param locationIdentity the identity of the read
266     * @return the result of the memory access
267     */
268    @Operation(opcode = Opcode.READ_OBJECT)
269    public static native Object readObject(Object object, int offset, LocationIdentity locationIdentity);
270
271    /**
272     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
273     * <p>
274     * The offset is always treated as a {@link Signed} value. However, the static type is
275     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
276     * knows that the highest-order bit of the unsigned value is never used).
277     *
278     * @param object the base object for the memory access
279     * @param offset the signed offset for the memory access
280     * @param locationIdentity the identity of the write
281     * @param val the value to be written to memory
282     */
283    @Operation(opcode = Opcode.WRITE_OBJECT)
284    public static native void writeByte(Object object, WordBase offset, byte val, LocationIdentity locationIdentity);
285
286    /**
287     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
288     * <p>
289     * The offset is always treated as a {@link Signed} value. However, the static type is
290     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
291     * knows that the highest-order bit of the unsigned value is never used).
292     *
293     * @param object the base object for the memory access
294     * @param offset the signed offset for the memory access
295     * @param locationIdentity the identity of the write
296     * @param val the value to be written to memory
297     */
298    @Operation(opcode = Opcode.WRITE_OBJECT)
299    public static native void writeChar(Object object, WordBase offset, char val, LocationIdentity locationIdentity);
300
301    /**
302     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
303     * <p>
304     * The offset is always treated as a {@link Signed} value. However, the static type is
305     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
306     * knows that the highest-order bit of the unsigned value is never used).
307     *
308     * @param object the base object for the memory access
309     * @param offset the signed offset for the memory access
310     * @param locationIdentity the identity of the write
311     * @param val the value to be written to memory
312     */
313    @Operation(opcode = Opcode.WRITE_OBJECT)
314    public static native void writeShort(Object object, WordBase offset, short val, LocationIdentity locationIdentity);
315
316    /**
317     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
318     * <p>
319     * The offset is always treated as a {@link Signed} value. However, the static type is
320     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
321     * knows that the highest-order bit of the unsigned value is never used).
322     *
323     * @param object the base object for the memory access
324     * @param offset the signed offset for the memory access
325     * @param locationIdentity the identity of the write
326     * @param val the value to be written to memory
327     */
328    @Operation(opcode = Opcode.WRITE_OBJECT)
329    public static native void writeInt(Object object, WordBase offset, int val, LocationIdentity locationIdentity);
330
331    /**
332     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
333     * <p>
334     * The offset is always treated as a {@link Signed} value. However, the static type is
335     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
336     * knows that the highest-order bit of the unsigned value is never used).
337     *
338     * @param object the base object for the memory access
339     * @param offset the signed offset for the memory access
340     * @param locationIdentity the identity of the write
341     * @param val the value to be written to memory
342     */
343    @Operation(opcode = Opcode.WRITE_OBJECT)
344    public static native void writeLong(Object object, WordBase offset, long val, LocationIdentity locationIdentity);
345
346    /**
347     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
348     * <p>
349     * The offset is always treated as a {@link Signed} value. However, the static type is
350     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
351     * knows that the highest-order bit of the unsigned value is never used).
352     *
353     * @param object the base object for the memory access
354     * @param offset the signed offset for the memory access
355     * @param locationIdentity the identity of the write
356     * @param val the value to be written to memory
357     */
358    @Operation(opcode = Opcode.WRITE_OBJECT)
359    public static native void writeFloat(Object object, WordBase offset, float val, LocationIdentity locationIdentity);
360
361    /**
362     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
363     * <p>
364     * The offset is always treated as a {@link Signed} value. However, the static type is
365     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
366     * knows that the highest-order bit of the unsigned value is never used).
367     *
368     * @param object the base object for the memory access
369     * @param offset the signed offset for the memory access
370     * @param locationIdentity the identity of the write
371     * @param val the value to be written to memory
372     */
373    @Operation(opcode = Opcode.WRITE_OBJECT)
374    public static native void writeDouble(Object object, WordBase offset, double val, LocationIdentity locationIdentity);
375
376    /**
377     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
378     * <p>
379     * The offset is always treated as a {@link Signed} value. However, the static type is
380     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
381     * knows that the highest-order bit of the unsigned value is never used).
382     *
383     * @param object the base object for the memory access
384     * @param offset the signed offset for the memory access
385     * @param locationIdentity the identity of the write
386     * @param val the value to be written to memory
387     */
388    @Operation(opcode = Opcode.WRITE_OBJECT)
389    public static native void writeWord(Object object, WordBase offset, WordBase val, LocationIdentity locationIdentity);
390
391    /**
392     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
393     * <p>
394     * The offset is always treated as a {@link Signed} value. However, the static type is
395     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
396     * knows that the highest-order bit of the unsigned value is never used).
397     *
398     * @param object the base object for the memory access
399     * @param offset the signed offset for the memory access
400     * @param locationIdentity the identity of the write
401     * @param val the value to be written to memory
402     */
403    @Operation(opcode = Opcode.WRITE_OBJECT)
404    public static native void writeObject(Object object, WordBase offset, Object val, LocationIdentity locationIdentity);
405
406    /**
407     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
408     *
409     * @param object the base object for the memory access
410     * @param offset the signed offset for the memory access
411     * @param locationIdentity the identity of the write
412     * @param val the value to be written to memory
413     */
414    @Operation(opcode = Opcode.WRITE_OBJECT)
415    public static native void writeByte(Object object, int offset, byte val, LocationIdentity locationIdentity);
416
417    /**
418     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
419     *
420     * @param object the base object for the memory access
421     * @param offset the signed offset for the memory access
422     * @param locationIdentity the identity of the write
423     * @param val the value to be written to memory
424     */
425    @Operation(opcode = Opcode.WRITE_OBJECT)
426    public static native void writeChar(Object object, int offset, char val, LocationIdentity locationIdentity);
427
428    /**
429     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
430     *
431     * @param object the base object for the memory access
432     * @param offset the signed offset for the memory access
433     * @param locationIdentity the identity of the write
434     * @param val the value to be written to memory
435     */
436    @Operation(opcode = Opcode.WRITE_OBJECT)
437    public static native void writeShort(Object object, int offset, short val, LocationIdentity locationIdentity);
438
439    /**
440     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
441     *
442     * @param object the base object for the memory access
443     * @param offset the signed offset for the memory access
444     * @param locationIdentity the identity of the write
445     * @param val the value to be written to memory
446     */
447    @Operation(opcode = Opcode.WRITE_OBJECT)
448    public static native void writeInt(Object object, int offset, int val, LocationIdentity locationIdentity);
449
450    /**
451     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
452     *
453     * @param object the base object for the memory access
454     * @param offset the signed offset for the memory access
455     * @param locationIdentity the identity of the write
456     * @param val the value to be written to memory
457     */
458    @Operation(opcode = Opcode.WRITE_OBJECT)
459    public static native void writeLong(Object object, int offset, long val, LocationIdentity locationIdentity);
460
461    /**
462     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
463     *
464     * @param object the base object for the memory access
465     * @param offset the signed offset for the memory access
466     * @param locationIdentity the identity of the write
467     * @param val the value to be written to memory
468     */
469    @Operation(opcode = Opcode.WRITE_OBJECT)
470    public static native void writeFloat(Object object, int offset, float val, LocationIdentity locationIdentity);
471
472    /**
473     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
474     *
475     * @param object the base object for the memory access
476     * @param offset the signed offset for the memory access
477     * @param locationIdentity the identity of the write
478     * @param val the value to be written to memory
479     */
480    @Operation(opcode = Opcode.WRITE_OBJECT)
481    public static native void writeDouble(Object object, int offset, double val, LocationIdentity locationIdentity);
482
483    /**
484     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
485     *
486     * @param object the base object for the memory access
487     * @param offset the signed offset for the memory access
488     * @param locationIdentity the identity of the write
489     * @param val the value to be written to memory
490     */
491    @Operation(opcode = Opcode.WRITE_OBJECT)
492    public static native void writeWord(Object object, int offset, WordBase val, LocationIdentity locationIdentity);
493
494    /**
495     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
496     *
497     * @param object the base object for the memory access
498     * @param offset the signed offset for the memory access
499     * @param locationIdentity the identity of the write
500     * @param val the value to be written to memory
501     */
502    @Operation(opcode = Opcode.WRITE_OBJECT)
503    public static native void writeObject(Object object, int offset, Object val, LocationIdentity locationIdentity);
504
505    /**
506     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
507     * <p>
508     * The offset is always treated as a {@link Signed} value. However, the static type is
509     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
510     * knows that the highest-order bit of the unsigned value is never used).
511     *
512     * @param object the base object for the memory access
513     * @param offset the signed offset for the memory access
514     * @return the result of the memory access
515     */
516    @Operation(opcode = Opcode.READ_OBJECT)
517    public static native byte readByte(Object object, WordBase offset);
518
519    /**
520     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
521     * <p>
522     * The offset is always treated as a {@link Signed} value. However, the static type is
523     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
524     * knows that the highest-order bit of the unsigned value is never used).
525     *
526     * @param object the base object for the memory access
527     * @param offset the signed offset for the memory access
528     * @return the result of the memory access
529     */
530    @Operation(opcode = Opcode.READ_OBJECT)
531    public static native char readChar(Object object, WordBase offset);
532
533    /**
534     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
535     * <p>
536     * The offset is always treated as a {@link Signed} value. However, the static type is
537     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
538     * knows that the highest-order bit of the unsigned value is never used).
539     *
540     * @param object the base object for the memory access
541     * @param offset the signed offset for the memory access
542     * @return the result of the memory access
543     */
544    @Operation(opcode = Opcode.READ_OBJECT)
545    public static native short readShort(Object object, WordBase offset);
546
547    /**
548     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
549     * <p>
550     * The offset is always treated as a {@link Signed} value. However, the static type is
551     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
552     * knows that the highest-order bit of the unsigned value is never used).
553     *
554     * @param object the base object for the memory access
555     * @param offset the signed offset for the memory access
556     * @return the result of the memory access
557     */
558    @Operation(opcode = Opcode.READ_OBJECT)
559    public static native int readInt(Object object, WordBase offset);
560
561    /**
562     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
563     * <p>
564     * The offset is always treated as a {@link Signed} value. However, the static type is
565     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
566     * knows that the highest-order bit of the unsigned value is never used).
567     *
568     * @param object the base object for the memory access
569     * @param offset the signed offset for the memory access
570     * @return the result of the memory access
571     */
572    @Operation(opcode = Opcode.READ_OBJECT)
573    public static native long readLong(Object object, WordBase offset);
574
575    /**
576     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
577     * <p>
578     * The offset is always treated as a {@link Signed} value. However, the static type is
579     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
580     * knows that the highest-order bit of the unsigned value is never used).
581     *
582     * @param object the base object for the memory access
583     * @param offset the signed offset for the memory access
584     * @return the result of the memory access
585     */
586    @Operation(opcode = Opcode.READ_OBJECT)
587    public static native float readFloat(Object object, WordBase offset);
588
589    /**
590     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
591     * <p>
592     * The offset is always treated as a {@link Signed} value. However, the static type is
593     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
594     * knows that the highest-order bit of the unsigned value is never used).
595     *
596     * @param object the base object for the memory access
597     * @param offset the signed offset for the memory access
598     * @return the result of the memory access
599     */
600    @Operation(opcode = Opcode.READ_OBJECT)
601    public static native double readDouble(Object object, WordBase offset);
602
603    /**
604     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
605     * <p>
606     * The offset is always treated as a {@link Signed} value. However, the static type is
607     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
608     * knows that the highest-order bit of the unsigned value is never used).
609     *
610     * @param object the base object for the memory access
611     * @param offset the signed offset for the memory access
612     * @return the result of the memory access
613     */
614    @Operation(opcode = Opcode.READ_OBJECT)
615    public static native Word readWord(Object object, WordBase offset);
616
617    /**
618     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
619     * <p>
620     * The offset is always treated as a {@link Signed} value. However, the static type is
621     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
622     * knows that the highest-order bit of the unsigned value is never used).
623     *
624     * @param object the base object for the memory access
625     * @param offset the signed offset for the memory access
626     * @return the result of the memory access
627     */
628    @Operation(opcode = Opcode.READ_OBJECT)
629    public static native Object readObject(Object object, WordBase offset);
630
631    /**
632     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
633     *
634     * @param object the base object for the memory access
635     * @param offset the signed offset for the memory access
636     * @return the result of the memory access
637     */
638    @Operation(opcode = Opcode.READ_OBJECT)
639    public static native byte readByte(Object object, int offset);
640
641    /**
642     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
643     *
644     * @param object the base object for the memory access
645     * @param offset the signed offset for the memory access
646     * @return the result of the memory access
647     */
648    @Operation(opcode = Opcode.READ_OBJECT)
649    public static native char readChar(Object object, int offset);
650
651    /**
652     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
653     *
654     * @param object the base object for the memory access
655     * @param offset the signed offset for the memory access
656     * @return the result of the memory access
657     */
658    @Operation(opcode = Opcode.READ_OBJECT)
659    public static native short readShort(Object object, int offset);
660
661    /**
662     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
663     *
664     * @param object the base object for the memory access
665     * @param offset the signed offset for the memory access
666     * @return the result of the memory access
667     */
668    @Operation(opcode = Opcode.READ_OBJECT)
669    public static native int readInt(Object object, int offset);
670
671    /**
672     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
673     *
674     * @param object the base object for the memory access
675     * @param offset the signed offset for the memory access
676     * @return the result of the memory access
677     */
678    @Operation(opcode = Opcode.READ_OBJECT)
679    public static native long readLong(Object object, int offset);
680
681    /**
682     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
683     *
684     * @param object the base object for the memory access
685     * @param offset the signed offset for the memory access
686     * @return the result of the memory access
687     */
688    @Operation(opcode = Opcode.READ_OBJECT)
689    public static native float readFloat(Object object, int offset);
690
691    /**
692     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
693     *
694     * @param object the base object for the memory access
695     * @param offset the signed offset for the memory access
696     * @return the result of the memory access
697     */
698    @Operation(opcode = Opcode.READ_OBJECT)
699    public static native double readDouble(Object object, int offset);
700
701    /**
702     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
703     *
704     * @param object the base object for the memory access
705     * @param offset the signed offset for the memory access
706     * @return the result of the memory access
707     */
708    @Operation(opcode = Opcode.READ_OBJECT)
709    public static native Word readWord(Object object, int offset);
710
711    /**
712     * Reads the memory at address {@code (object + offset)}. The offset is in bytes.
713     *
714     * @param object the base object for the memory access
715     * @param offset the signed offset for the memory access
716     * @return the result of the memory access
717     */
718    @Operation(opcode = Opcode.READ_OBJECT)
719    public static native Object readObject(Object object, int offset);
720
721    /**
722     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
723     * <p>
724     * The offset is always treated as a {@link Signed} value. However, the static type is
725     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
726     * knows that the highest-order bit of the unsigned value is never used).
727     *
728     * @param object the base object for the memory access
729     * @param offset the signed offset for the memory access
730     * @param val the value to be written to memory
731     */
732    @Operation(opcode = Opcode.WRITE_OBJECT)
733    public static native void writeByte(Object object, WordBase offset, byte val);
734
735    /**
736     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
737     * <p>
738     * The offset is always treated as a {@link Signed} value. However, the static type is
739     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
740     * knows that the highest-order bit of the unsigned value is never used).
741     *
742     * @param object the base object for the memory access
743     * @param offset the signed offset for the memory access
744     * @param val the value to be written to memory
745     */
746    @Operation(opcode = Opcode.WRITE_OBJECT)
747    public static native void writeChar(Object object, WordBase offset, char val);
748
749    /**
750     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
751     * <p>
752     * The offset is always treated as a {@link Signed} value. However, the static type is
753     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
754     * knows that the highest-order bit of the unsigned value is never used).
755     *
756     * @param object the base object for the memory access
757     * @param offset the signed offset for the memory access
758     * @param val the value to be written to memory
759     */
760    @Operation(opcode = Opcode.WRITE_OBJECT)
761    public static native void writeShort(Object object, WordBase offset, short val);
762
763    /**
764     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
765     * <p>
766     * The offset is always treated as a {@link Signed} value. However, the static type is
767     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
768     * knows that the highest-order bit of the unsigned value is never used).
769     *
770     * @param object the base object for the memory access
771     * @param offset the signed offset for the memory access
772     * @param val the value to be written to memory
773     */
774    @Operation(opcode = Opcode.WRITE_OBJECT)
775    public static native void writeInt(Object object, WordBase offset, int val);
776
777    /**
778     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
779     * <p>
780     * The offset is always treated as a {@link Signed} value. However, the static type is
781     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
782     * knows that the highest-order bit of the unsigned value is never used).
783     *
784     * @param object the base object for the memory access
785     * @param offset the signed offset for the memory access
786     * @param val the value to be written to memory
787     */
788    @Operation(opcode = Opcode.WRITE_OBJECT)
789    public static native void writeLong(Object object, WordBase offset, long val);
790
791    /**
792     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
793     * <p>
794     * The offset is always treated as a {@link Signed} value. However, the static type is
795     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
796     * knows that the highest-order bit of the unsigned value is never used).
797     *
798     * @param object the base object for the memory access
799     * @param offset the signed offset for the memory access
800     * @param val the value to be written to memory
801     */
802    @Operation(opcode = Opcode.WRITE_OBJECT)
803    public static native void writeFloat(Object object, WordBase offset, float val);
804
805    /**
806     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
807     * <p>
808     * The offset is always treated as a {@link Signed} value. However, the static type is
809     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
810     * knows that the highest-order bit of the unsigned value is never used).
811     *
812     * @param object the base object for the memory access
813     * @param offset the signed offset for the memory access
814     * @param val the value to be written to memory
815     */
816    @Operation(opcode = Opcode.WRITE_OBJECT)
817    public static native void writeDouble(Object object, WordBase offset, double val);
818
819    /**
820     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
821     * <p>
822     * The offset is always treated as a {@link Signed} value. However, the static type is
823     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
824     * knows that the highest-order bit of the unsigned value is never used).
825     *
826     * @param object the base object for the memory access
827     * @param offset the signed offset for the memory access
828     * @param val the value to be written to memory
829     */
830    @Operation(opcode = Opcode.WRITE_OBJECT)
831    public static native void writeWord(Object object, WordBase offset, WordBase val);
832
833    /**
834     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
835     * <p>
836     * The offset is always treated as a {@link Signed} value. However, the static type is
837     * {@link WordBase} to avoid the frequent casts of {@link Unsigned} values (where the caller
838     * knows that the highest-order bit of the unsigned value is never used).
839     *
840     * @param object the base object for the memory access
841     * @param offset the signed offset for the memory access
842     * @param val the value to be written to memory
843     */
844    @Operation(opcode = Opcode.WRITE_OBJECT)
845    public static native void writeObject(Object object, WordBase offset, Object val);
846
847    /**
848     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
849     *
850     * @param object the base object for the memory access
851     * @param offset the signed offset for the memory access
852     * @param val the value to be written to memory
853     */
854    @Operation(opcode = Opcode.WRITE_OBJECT)
855    public static native void writeByte(Object object, int offset, byte val);
856
857    /**
858     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
859     *
860     * @param object the base object for the memory access
861     * @param offset the signed offset for the memory access
862     * @param val the value to be written to memory
863     */
864    @Operation(opcode = Opcode.WRITE_OBJECT)
865    public static native void writeChar(Object object, int offset, char val);
866
867    /**
868     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
869     *
870     * @param object the base object for the memory access
871     * @param offset the signed offset for the memory access
872     * @param val the value to be written to memory
873     */
874    @Operation(opcode = Opcode.WRITE_OBJECT)
875    public static native void writeShort(Object object, int offset, short val);
876
877    /**
878     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
879     *
880     * @param object the base object for the memory access
881     * @param offset the signed offset for the memory access
882     * @param val the value to be written to memory
883     */
884    @Operation(opcode = Opcode.WRITE_OBJECT)
885    public static native void writeInt(Object object, int offset, int val);
886
887    /**
888     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
889     *
890     * @param object the base object for the memory access
891     * @param offset the signed offset for the memory access
892     * @param val the value to be written to memory
893     */
894    @Operation(opcode = Opcode.WRITE_OBJECT)
895    public static native void writeLong(Object object, int offset, long val);
896
897    /**
898     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
899     *
900     * @param object the base object for the memory access
901     * @param offset the signed offset for the memory access
902     * @param val the value to be written to memory
903     */
904    @Operation(opcode = Opcode.WRITE_OBJECT)
905    public static native void writeFloat(Object object, int offset, float val);
906
907    /**
908     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
909     *
910     * @param object the base object for the memory access
911     * @param offset the signed offset for the memory access
912     * @param val the value to be written to memory
913     */
914    @Operation(opcode = Opcode.WRITE_OBJECT)
915    public static native void writeDouble(Object object, int offset, double val);
916
917    /**
918     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
919     *
920     * @param object the base object for the memory access
921     * @param offset the signed offset for the memory access
922     * @param val the value to be written to memory
923     */
924    @Operation(opcode = Opcode.WRITE_OBJECT)
925    public static native void writeWord(Object object, int offset, WordBase val);
926
927    /**
928     * Writes the memory at address {@code (object + offset)}. The offset is in bytes.
929     *
930     * @param object the base object for the memory access
931     * @param offset the signed offset for the memory access
932     * @param val the value to be written to memory
933     */
934    @Operation(opcode = Opcode.WRITE_OBJECT)
935    public static native void writeObject(Object object, int offset, Object val);
936}
937