Potential bug on extract int64

[Yu-zh]

It seems that the fast path and slow path for extracting int64 in littleendian are inconsistent. I have the following program, where I expect f and g to print the result.

let f bits =
  match%bitstring bits with
  | {| a:4; b:60:littleendian; _:-1:bitstring |} ->
    print_string (Int.to_string a);
    print_endline "";
    print_string (Int64.to_string b);
    print_endline ""
  | {|_|} -> failwith "run_test5"
;;

let g bits =
  match%bitstring bits with
  | {| b:60:littleendian; a:4; _:-1:bitstring |} ->
    print_string (Int.to_string a);
    print_endline "";
    print_string (Int64.to_string b);
    print_endline ""
  | {|_|} -> failwith "run_test6"
;;

let () =
  f (Bitstring.bitstring_of_string "\xA0\x00\x00\x00\x00\x00\x00\x00");
  g (Bitstring.bitstring_of_string "\x00\x00\x00\x00\x00\x00\x00\x0A")
;;

However, the result I got is:

10                                 
0
10
720575940379279360

It seems the fast path for extracting int64 does not properly handle the case when reading less than 64 bit. Or did I misunderstand anything?

[xguerin]

The fast path requires whole integers (8, 16, 32 and 64 bits), so it should not be used in this case. Let me investigate.

[xguerin]

You have an endianness problem. f is indeed in little endian, but g is in big endian. Replacing littleendian by bigendian in g has the expected behavior.

[Yu-zh]

You have an endianness problem. f is indeed in little endian, but g is in big endian. Replacing littleendian by bigendian in g has the expected behavior.

Thanks for a quick response!

The input to g is "\x00\x00\x00\x00\x00\x00\x00\x0A" so the first 60 bits are all 0s. I don't think littleendian or bitendian should be different in such case. And in the case for 32bit I have tested the following program:

let f bits =
  match%bitstring bits with
  | {| a:4; b:28:littleendian; _:-1:bitstring |} ->
    print_string (Int.to_string a);
    print_endline "";
    print_string (Int.to_string b);
    print_endline ""
  | {|_|} -> failwith "f"
;;

let g bits =
  match%bitstring bits with
  | {| b:28:littleendian; a:4; _:-1:bitstring |} ->
    print_string (Int.to_string a);
    print_endline "";
    print_string (Int.to_string b);
    print_endline ""
  | {|_|} -> failwith "g"
;;

let () =
  f (Bitstring.bitstring_of_string "\xA0\x00\x00\x00");
  g (Bitstring.bitstring_of_string "\x00\x00\x00\x0A")
;;

Both f and g print the same result. Did I misunderstand anything?

[xguerin]

You are right. The I64 logic for handling partial masking on little endian is fishy. I took a stab at a fix here: #39, which seems to produce the desired outcome. I'll let you take a look.

[Yu-zh]

You are right. The I64 logic for handling partial masking on little endian is fishy. I took a stab at a fix here: #39, which seems to produce the desired outcome. I'll let you take a look.

Thanks. The fix looks good!