Array of booleans

[Maurizio Cimadamore]

On 18/03/2021 18:44, John Rose wrote:
> A JVM which implements packed boolean arrays
> with 1-bit elements will not be distinguishable from
> a one which uses some other format, such as 2-bit
> or 8-bit or 32-bit elements.

I get all this. Whetever the internal format, boolean has to be 
"convertible" to and from bytes.

I *think* my point remains though - the rules you give are "operational" 
- but when it comes to definitions, there is a gap between integral 
types and boolean:


> The integral types are:
>
>  *
>
>     |byte|, whose values are 8-bit signed two's-complement integers,
>     and whose default value is zero
>
>  *
>
>     |short|, whose values are 16-bit signed two's-complement integers,
>     and whose default value is zero
>
>  *
>
>     |int|, whose values are 32-bit signed two's-complement integers,
>     and whose default value is zero
>
>  *
>
>     |long|, whose values are 64-bit signed two's-complement integers,
>     and whose default value is zero
>
>  *
>
>     |char|, whose values are 16-bit unsigned integers representing
>     Unicode code points in the Basic Multilingual Plane, encoded with
>     UTF-16, and whose default value is the null code point (|'\u0000'|)
>
Here - sizes are clearly spelled out. Again, having a MemoryLayout 
somewhere which depends on these definition would be seen as totally ok.

This is what JVMS says for boolean types:

> Although the Java Virtual Machine defines a |boolean| type, it only 
> provides very limited support for it. There are no Java Virtual 
> Machine instructions solely dedicated to operations on |boolean| 
> values. Instead, expressions in the Java programming language that 
> operate on |boolean| values are compiled to use values of the Java 
> Virtual Machine |int| data type.
>
> The Java Virtual Machine does directly support |boolean| arrays. Its 
> /newarray/ instruction (§/newarray/ 
> <https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5.newarray>) 
> enables creation of |boolean| arrays. Arrays of type |boolean| are 
> accessed and modified using the |byte| array instructions /baload/ and 
> /bastore/ (§/baload/ 
> <https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5.baload>, 
> §/bastore/ 
> <https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5.bastore>). 
>
>
> In Oracle’s Java Virtual Machine implementation, |boolean| arrays in 
> the Java programming language are encoded as Java Virtual Machine 
> |byte| arrays, using 8 bits per |boolean| element.
>
> The Java Virtual Machine encodes |boolean| array components using |1| 
> to represent |true| and |0| to represent |false|. Where Java 
> programming language |boolean| values are mapped by compilers to 
> values of Java Virtual Machine type |int|, the compilers must use the 
> same encoding.
>

Here there is nothing that tells me (or the memory access API) what the 
layout of a boolean is.

So I don't agree with the conclusion that

> It’s messy but it’s all there in the specs.  Use or toss, as
> appropriate!

I think it would be more correct to say that the spec would _support_ 
converting 8bit values to and fro Java booleans, since that's JVM bread 
and butter (as noted in the spec you reference).

In other words - the spec text you provided would allow the memory 
access API to support boolean.class as a possible carrier for var 
handles - but not IMHO to have a layout constant for JAVA_BOOLEAN.

Maurizio