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