llvm dev - Apr 2018 - llvm::PointerIntPair -- is this by design or a bug?

On 4 Apr 2018, at 11:01, Florian Hahn via llvm-dev <llvm-dev at
lists.llvm.org> wrote:
> 
> Hi,
> 
> On 04/04/2018 05:34, Riyaz Puthiyapurayil via llvm-dev wrote:
>> llvm::PointerIntPair<double*, 3, signed> P;
>> P.setInt(-4);
>> Ideally, the value range for a 3-bit signed integer should be [-4,3].
But the above call to setInt will fail. Essentially, the signed int field in
PointerIntPair is behaving the same as an 3-bit unsigned field which has the
legal value range of [0,7]. Is this by design? Are negative values not allowed
in PointerIntPair?
> 
> I think that's by design. setInt only allows you to set integer values
that fit into the available bits. It won't move the sign bit, so negative
values won't fit, unless you have a 3 bit signed type ;)
That doesn’t sound right (for any computer made in the last few decades), the
representation of -3 will be 1111…1111101.  Storing the low bits will yield 101,
which is a 3-bit negative three.  When you then sign extend this to any other
signed type, you will get -3 in that representation.  It sounds as if the signed
specialisation of PointerIntPair is simply not doing the sign extension.

David

On 04/04/2018 11:15, David Chisnall wrote:
> On 4 Apr 2018, at 11:01, Florian Hahn via llvm-dev <llvm-dev at
lists.llvm.org> wrote:
>>
>> Hi,
>>
>> On 04/04/2018 05:34, Riyaz Puthiyapurayil via llvm-dev wrote:
>>> llvm::PointerIntPair<double*, 3, signed> P;
>>> P.setInt(-4);
>>> Ideally, the value range for a 3-bit signed integer should be
[-4,3]. But the above call to setInt will fail. Essentially, the signed int
field in PointerIntPair is behaving the same as an 3-bit unsigned field which
has the legal value range of [0,7]. Is this by design? Are negative values not
allowed in PointerIntPair?
>>
>> I think that's by design. setInt only allows you to set integer
values that fit into the available bits. It won't move the sign bit, so
negative values won't fit, unless you have a 3 bit signed type ;)
> 
> That doesn’t sound right (for any computer made in the last few decades),
the representation of -3 will be 1111…1111101.  Storing the low bits will yield
101, which is a 3-bit negative three.  When you then sign extend this to any
other signed type, you will get -3 in that representation.  It sounds as if the
signed specialisation of PointerIntPair is simply not doing the sign extension.
> 
Yep, I meant it looks like it currently does not do a sign extension, it 
expects only the available bits to be set, no others. In any case, it is 
probably worth documenting the behaviour.

Cheers,
Florian

It won't move the sign bit, so negative values won't fit, unless you
have a 3 bit signed type ;)

Note that if you assign negative values to and then read from a signed
bit-field, you would do sign extension. So 3-bit signed types do exist in C++.

It begs the question why PointerIntPair supports signed int types if it always
loses the sign. Is it just to avoid signed/unsigned comparison when comparing
the return value of getInt with signed types? Or to use enums that default to a
signed type? In any case, this should be clearly documented if there is no
intention to fix it.

/ Riyaz

On Apr 4, 2018, at 4:04 AM, Florian Hahn <florian.hahn at
arm.com<mailto:florian.hahn at arm.com>> wrote:



On 04/04/2018 11:15, David Chisnall wrote:
On 4 Apr 2018, at 11:01, Florian Hahn via llvm-dev <llvm-dev at
lists.llvm.org<mailto:llvm-dev at lists.llvm.org>> wrote:

Hi,

On 04/04/2018 05:34, Riyaz Puthiyapurayil via llvm-dev wrote:
llvm::PointerIntPair<double*, 3, signed> P;
P.setInt(-4);
Ideally, the value range for a 3-bit signed integer should be [-4,3]. But the
above call to setInt will fail. Essentially, the signed int field in
PointerIntPair is behaving the same as an 3-bit unsigned field which has the
legal value range of [0,7]. Is this by design? Are negative values not allowed
in PointerIntPair?

I think that's by design. setInt only allows you to set integer values that
fit into the available bits. It won't move the sign bit, so negative values
won't fit, unless you have a 3 bit signed type ;)
That doesn’t sound right (for any computer made in the last few decades), the
representation of -3 will be 1111…1111101.  Storing the low bits will yield 101,
which is a 3-bit negative three.  When you then sign extend this to any other
signed type, you will get -3 in that representation.  It sounds as if the signed
specialisation of PointerIntPair is simply not doing the sign extension.

Yep, I meant it looks like it currently does not do a sign extension, it expects
only the available bits to be set, no others. In any case, it is probably worth
documenting the behaviour.

Cheers,
Florian
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20180404/e0d354d4/attachment.html>