diff mbox

[v4] bitops.h: Add functions to extract and deposit bitfields

Message ID 1341586080-24117-1-git-send-email-peter.maydell@linaro.org
State New
Headers show

Commit Message

Peter Maydell July 6, 2012, 2:48 p.m. UTC 
Add functions deposit32(), deposit64(), extract32() and extract64()
to extract and deposit bitfields in 32 and 64 bit words. Based on
ideas by Jia Liu and Avi Kivity.

Suggested-by: Jia Liu <proljc@gmail.com>
Suggested-by: Avi Kivity <avi@redhat.com>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Andreas Färber <afaerber@suse.de>
---
Changes:
 v1->v2: added missing brackets
 v2->v3: renamed field32,field64 to extract32,extract64
         added deposit32,deposit64 at Avi's suggestion
         fixed assertion as per Jay Foad's suggestion
 v3->v4: fixed gtk-doc comment formats, expanded doc comments slightly

I took the liberty of leaving Eric and Andreas' Reviewed-by: tags
on since there are no code changes in v4, only doc comments.

 bitops.h |   90 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 90 insertions(+), 0 deletions(-)

Comments

Blue Swirl July 7, 2012, 9:22 a.m. UTC | #1 
On Fri, Jul 6, 2012 at 2:48 PM, Peter Maydell <peter.maydell@linaro.org> wrote:
> Add functions deposit32(), deposit64(), extract32() and extract64()
> to extract and deposit bitfields in 32 and 64 bit words. Based on
> ideas by Jia Liu and Avi Kivity.
>
> Suggested-by: Jia Liu <proljc@gmail.com>
> Suggested-by: Avi Kivity <avi@redhat.com>
> Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
> Reviewed-by: Eric Blake <eblake@redhat.com>
> Reviewed-by: Andreas Färber <afaerber@suse.de>

Thanks, applied.

> ---
> Changes:
>  v1->v2: added missing brackets
>  v2->v3: renamed field32,field64 to extract32,extract64
>          added deposit32,deposit64 at Avi's suggestion
>          fixed assertion as per Jay Foad's suggestion
>  v3->v4: fixed gtk-doc comment formats, expanded doc comments slightly
>
> I took the liberty of leaving Eric and Andreas' Reviewed-by: tags
> on since there are no code changes in v4, only doc comments.
>
>  bitops.h |   90 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  1 files changed, 90 insertions(+), 0 deletions(-)
>
> diff --git a/bitops.h b/bitops.h
> index 07d1a06..b967ef3 100644
> --- a/bitops.h
> +++ b/bitops.h
> @@ -269,4 +269,94 @@ static inline unsigned long hweight_long(unsigned long w)
>      return count;
>  }
>
> +/**
> + * extract32:
> + * @value: the value to extract the bit field from
> + * @start: the lowest bit in the bit field (numbered from 0)
> + * @length: the length of the bit field
> + *
> + * Extract from the 32 bit input @value the bit field specified by the
> + * @start and @length parameters, and return it. The bit field must
> + * lie entirely within the 32 bit word. It is valid to request that
> + * all 32 bits are returned (ie @length 32 and @start 0).
> + *
> + * Returns: the value of the bit field extracted from the input value.
> + */
> +static inline uint32_t extract32(uint32_t value, int start, int length)
> +{
> +    assert(start >= 0 && length > 0 && length <= 32 - start);
> +    return (value >> start) & (~0U >> (32 - length));
> +}
> +
> +/**
> + * extract64:
> + * @value: the value to extract the bit field from
> + * @start: the lowest bit in the bit field (numbered from 0)
> + * @length: the length of the bit field
> + *
> + * Extract from the 64 bit input @value the bit field specified by the
> + * @start and @length parameters, and return it. The bit field must
> + * lie entirely within the 64 bit word. It is valid to request that
> + * all 64 bits are returned (ie @length 64 and @start 0).
> + *
> + * Returns: the value of the bit field extracted from the input value.
> + */
> +static inline uint64_t extract64(uint64_t value, int start, int length)
> +{
> +    assert(start >= 0 && length > 0 && length <= 64 - start);
> +    return (value >> start) & (~0ULL >> (64 - length));
> +}
> +
> +/**
> + * deposit32:
> + * @value: initial value to insert bit field into
> + * @start: the lowest bit in the bit field (numbered from 0)
> + * @length: the length of the bit field
> + * @fieldval: the value to insert into the bit field
> + *
> + * Deposit @fieldval into the 32 bit @value at the bit field specified
> + * by the @start and @length parameters, and return the modified
> + * @value. Bits of @value outside the bit field are not modified.
> + * Bits of @fieldval above the least significant @length bits are
> + * ignored. The bit field must lie entirely within the 32 bit word.
> + * It is valid to request that all 64 bits are modified (ie @length
> + * 64 and @start 0).
> + *
> + * Returns: the modified @value.
> + */
> +static inline uint32_t deposit32(uint32_t value, int start, int length,
> +                                 uint32_t fieldval)
> +{
> +    uint32_t mask;
> +    assert(start >= 0 && length > 0 && length <= 32 - start);
> +    mask = (~0U >> (32 - length)) << start;
> +    return (value & ~mask) | ((fieldval << start) & mask);
> +}
> +
> +/**
> + * deposit32:
> + * @value: initial value to insert bit field into
> + * @start: the lowest bit in the bit field (numbered from 0)
> + * @length: the length of the bit field
> + * @fieldval: the value to insert into the bit field
> + *
> + * Deposit @fieldval into the 64 bit @value at the bit field specified
> + * by the @start and @length parameters, and return the modified
> + * @value. Bits of @value outside the bit field are not modified.
> + * Bits of @fieldval above the least significant @length bits are
> + * ignored. The bit field must lie entirely within the 32 bit word.
> + * It is valid to request that all 64 bits are modified (ie @length
> + * 64 and @start 0).
> + *
> + * Returns: the modified @value.
> + */
> +static inline uint64_t deposit64(uint64_t value, int start, int length,
> +                                 uint64_t fieldval)
> +{
> +    uint64_t mask;
> +    assert(start >= 0 && length > 0 && length <= 64 - start);
> +    mask = (~0ULL >> (64 - length)) << start;
> +    return (value & ~mask) | ((fieldval << start) & mask);
> +}
> +
>  #endif
> --
> 1.7.1
>
Lluís Vilanova July 8, 2012, 9:55 a.m. UTC | #2 
Peter Maydell writes:
[...] 
> +/**
> + * extract32:
> + * @value: the value to extract the bit field from
> + * @start: the lowest bit in the bit field (numbered from 0)
> + * @length: the length of the bit field
> + *
> + * Extract from the 32 bit input @value the bit field specified by the
> + * @start and @length parameters, and return it. The bit field must
> + * lie entirely within the 32 bit word. It is valid to request that
> + * all 32 bits are returned (ie @length 32 and @start 0).
> + *
> + * Returns: the value of the bit field extracted from the input value.
> + */
> +static inline uint32_t extract32(uint32_t value, int start, int length)
> +{
> +    assert(start >= 0 && length > 0 && length <= 32 - start);
> +    return (value >> start) & (~0U >> (32 - length));
> +}
[...]

Wouldn't it be better to use "unsigned int" instead on all the "start" and
"length" arguments?


Lluis
Peter Maydell July 8, 2012, 10:01 a.m. UTC | #3 
On 8 July 2012 10:55, Lluís Vilanova <vilanova@ac.upc.edu> wrote:
> Wouldn't it be better to use "unsigned int" instead on all the "start" and
> "length" arguments?

See the arguments about this on one of the previous patch series:
http://lists.gnu.org/archive/html/qemu-devel/2012-06/msg04304.html

-- PMM
Stefan Weil July 8, 2012, 10:59 a.m. UTC | #4 
Am 08.07.2012 12:01, schrieb Peter Maydell:
> On 8 July 2012 10:55, Lluís Vilanova <vilanova@ac.upc.edu> wrote:
>> Wouldn't it be better to use "unsigned int" instead on all the "start" and
>> "length" arguments?
> See the arguments about this on one of the previous patch series:
> http://lists.gnu.org/archive/html/qemu-devel/2012-06/msg04304.html
>
> -- PMM

I just read that arguments and now agree with Blue and with
Lluís that 'unsigned' would be better.

Cheers,

Stefan W.
Peter Maydell July 8, 2012, 11:13 a.m. UTC | #5 
On 8 July 2012 11:59, Stefan Weil <sw@weilnetz.de> wrote:
> Am 08.07.2012 12:01, schrieb Peter Maydell:
>> On 8 July 2012 10:55, Lluís Vilanova <vilanova@ac.upc.edu> wrote:
>>> Wouldn't it be better to use "unsigned int" instead on all the "start"
>>> and "length" arguments?
>>
>> See the arguments about this on one of the previous patch series:
>> http://lists.gnu.org/archive/html/qemu-devel/2012-06/msg04304.html

> I just read that arguments and now agree with Blue and with
> Lluís that 'unsigned' would be better.

...whereas I still agree with Markus (and with the people who wrote
the Linux kernel bitops functions that we borrowed elsewhere in
bitops.h) that we should be using plain 'int'.

-- PMM
diff mbox

Patch

diff --git a/bitops.h b/bitops.h
index 07d1a06..b967ef3 100644
--- a/bitops.h
+++ b/bitops.h
@@ -269,4 +269,94 @@  static inline unsigned long hweight_long(unsigned long w)
     return count;
 }
 
+/**
+ * extract32:
+ * @value: the value to extract the bit field from
+ * @start: the lowest bit in the bit field (numbered from 0)
+ * @length: the length of the bit field
+ *
+ * Extract from the 32 bit input @value the bit field specified by the
+ * @start and @length parameters, and return it. The bit field must
+ * lie entirely within the 32 bit word. It is valid to request that
+ * all 32 bits are returned (ie @length 32 and @start 0).
+ *
+ * Returns: the value of the bit field extracted from the input value.
+ */
+static inline uint32_t extract32(uint32_t value, int start, int length)
+{
+    assert(start >= 0 && length > 0 && length <= 32 - start);
+    return (value >> start) & (~0U >> (32 - length));
+}
+
+/**
+ * extract64:
+ * @value: the value to extract the bit field from
+ * @start: the lowest bit in the bit field (numbered from 0)
+ * @length: the length of the bit field
+ *
+ * Extract from the 64 bit input @value the bit field specified by the
+ * @start and @length parameters, and return it. The bit field must
+ * lie entirely within the 64 bit word. It is valid to request that
+ * all 64 bits are returned (ie @length 64 and @start 0).
+ *
+ * Returns: the value of the bit field extracted from the input value.
+ */
+static inline uint64_t extract64(uint64_t value, int start, int length)
+{
+    assert(start >= 0 && length > 0 && length <= 64 - start);
+    return (value >> start) & (~0ULL >> (64 - length));
+}
+
+/**
+ * deposit32:
+ * @value: initial value to insert bit field into
+ * @start: the lowest bit in the bit field (numbered from 0)
+ * @length: the length of the bit field
+ * @fieldval: the value to insert into the bit field
+ *
+ * Deposit @fieldval into the 32 bit @value at the bit field specified
+ * by the @start and @length parameters, and return the modified
+ * @value. Bits of @value outside the bit field are not modified.
+ * Bits of @fieldval above the least significant @length bits are
+ * ignored. The bit field must lie entirely within the 32 bit word.
+ * It is valid to request that all 64 bits are modified (ie @length
+ * 64 and @start 0).
+ *
+ * Returns: the modified @value.
+ */
+static inline uint32_t deposit32(uint32_t value, int start, int length,
+                                 uint32_t fieldval)
+{
+    uint32_t mask;
+    assert(start >= 0 && length > 0 && length <= 32 - start);
+    mask = (~0U >> (32 - length)) << start;
+    return (value & ~mask) | ((fieldval << start) & mask);
+}
+
+/**
+ * deposit32:
+ * @value: initial value to insert bit field into
+ * @start: the lowest bit in the bit field (numbered from 0)
+ * @length: the length of the bit field
+ * @fieldval: the value to insert into the bit field
+ *
+ * Deposit @fieldval into the 64 bit @value at the bit field specified
+ * by the @start and @length parameters, and return the modified
+ * @value. Bits of @value outside the bit field are not modified.
+ * Bits of @fieldval above the least significant @length bits are
+ * ignored. The bit field must lie entirely within the 32 bit word.
+ * It is valid to request that all 64 bits are modified (ie @length
+ * 64 and @start 0).
+ *
+ * Returns: the modified @value.
+ */
+static inline uint64_t deposit64(uint64_t value, int start, int length,
+                                 uint64_t fieldval)
+{
+    uint64_t mask;
+    assert(start >= 0 && length > 0 && length <= 64 - start);
+    mask = (~0ULL >> (64 - length)) << start;
+    return (value & ~mask) | ((fieldval << start) & mask);
+}
+
 #endif