mirror of
https://github.com/xemu-project/xemu.git
synced 2024-12-01 07:21:09 +00:00
9c22687ea8
Move index and size fields from int to long. We need that for migration. long is 64 bits on sane architectures, and 32bits should be enough on all the 32bits architectures. Signed-off-by: Juan Quintela <quintela@redhat.com> Reviewed-by: Eric Blake <eblake@redhat.com> Reviewed-by: Orit Wasserman <owasserm@redhat.com>
407 lines
12 KiB
C
407 lines
12 KiB
C
/*
|
|
* Bitops Module
|
|
*
|
|
* Copyright (C) 2010 Corentin Chary <corentin.chary@gmail.com>
|
|
*
|
|
* Mostly inspired by (stolen from) linux/bitmap.h and linux/bitops.h
|
|
*
|
|
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
*/
|
|
|
|
#ifndef BITOPS_H
|
|
#define BITOPS_H
|
|
|
|
#include "qemu-common.h"
|
|
#include "host-utils.h"
|
|
|
|
#define BITS_PER_BYTE CHAR_BIT
|
|
#define BITS_PER_LONG (sizeof (unsigned long) * BITS_PER_BYTE)
|
|
|
|
#define BIT(nr) (1UL << (nr))
|
|
#define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG))
|
|
#define BIT_WORD(nr) ((nr) / BITS_PER_LONG)
|
|
#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
|
|
|
|
/**
|
|
* set_bit - Set a bit in memory
|
|
* @nr: the bit to set
|
|
* @addr: the address to start counting from
|
|
*/
|
|
static inline void set_bit(long nr, unsigned long *addr)
|
|
{
|
|
unsigned long mask = BIT_MASK(nr);
|
|
unsigned long *p = addr + BIT_WORD(nr);
|
|
|
|
*p |= mask;
|
|
}
|
|
|
|
/**
|
|
* clear_bit - Clears a bit in memory
|
|
* @nr: Bit to clear
|
|
* @addr: Address to start counting from
|
|
*/
|
|
static inline void clear_bit(long nr, unsigned long *addr)
|
|
{
|
|
unsigned long mask = BIT_MASK(nr);
|
|
unsigned long *p = addr + BIT_WORD(nr);
|
|
|
|
*p &= ~mask;
|
|
}
|
|
|
|
/**
|
|
* change_bit - Toggle a bit in memory
|
|
* @nr: Bit to change
|
|
* @addr: Address to start counting from
|
|
*/
|
|
static inline void change_bit(long nr, unsigned long *addr)
|
|
{
|
|
unsigned long mask = BIT_MASK(nr);
|
|
unsigned long *p = addr + BIT_WORD(nr);
|
|
|
|
*p ^= mask;
|
|
}
|
|
|
|
/**
|
|
* test_and_set_bit - Set a bit and return its old value
|
|
* @nr: Bit to set
|
|
* @addr: Address to count from
|
|
*/
|
|
static inline int test_and_set_bit(long nr, unsigned long *addr)
|
|
{
|
|
unsigned long mask = BIT_MASK(nr);
|
|
unsigned long *p = addr + BIT_WORD(nr);
|
|
unsigned long old = *p;
|
|
|
|
*p = old | mask;
|
|
return (old & mask) != 0;
|
|
}
|
|
|
|
/**
|
|
* test_and_clear_bit - Clear a bit and return its old value
|
|
* @nr: Bit to clear
|
|
* @addr: Address to count from
|
|
*/
|
|
static inline int test_and_clear_bit(long nr, unsigned long *addr)
|
|
{
|
|
unsigned long mask = BIT_MASK(nr);
|
|
unsigned long *p = addr + BIT_WORD(nr);
|
|
unsigned long old = *p;
|
|
|
|
*p = old & ~mask;
|
|
return (old & mask) != 0;
|
|
}
|
|
|
|
/**
|
|
* test_and_change_bit - Change a bit and return its old value
|
|
* @nr: Bit to change
|
|
* @addr: Address to count from
|
|
*/
|
|
static inline int test_and_change_bit(long nr, unsigned long *addr)
|
|
{
|
|
unsigned long mask = BIT_MASK(nr);
|
|
unsigned long *p = addr + BIT_WORD(nr);
|
|
unsigned long old = *p;
|
|
|
|
*p = old ^ mask;
|
|
return (old & mask) != 0;
|
|
}
|
|
|
|
/**
|
|
* test_bit - Determine whether a bit is set
|
|
* @nr: bit number to test
|
|
* @addr: Address to start counting from
|
|
*/
|
|
static inline int test_bit(long nr, const unsigned long *addr)
|
|
{
|
|
return 1UL & (addr[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG-1)));
|
|
}
|
|
|
|
/**
|
|
* find_last_bit - find the last set bit in a memory region
|
|
* @addr: The address to start the search at
|
|
* @size: The maximum size to search
|
|
*
|
|
* Returns the bit number of the first set bit, or size.
|
|
*/
|
|
unsigned long find_last_bit(const unsigned long *addr,
|
|
unsigned long size);
|
|
|
|
/**
|
|
* find_next_bit - find the next set bit in a memory region
|
|
* @addr: The address to base the search on
|
|
* @offset: The bitnumber to start searching at
|
|
* @size: The bitmap size in bits
|
|
*/
|
|
unsigned long find_next_bit(const unsigned long *addr,
|
|
unsigned long size, unsigned long offset);
|
|
|
|
/**
|
|
* find_next_zero_bit - find the next cleared bit in a memory region
|
|
* @addr: The address to base the search on
|
|
* @offset: The bitnumber to start searching at
|
|
* @size: The bitmap size in bits
|
|
*/
|
|
|
|
unsigned long find_next_zero_bit(const unsigned long *addr,
|
|
unsigned long size,
|
|
unsigned long offset);
|
|
|
|
/**
|
|
* find_first_bit - find the first set bit in a memory region
|
|
* @addr: The address to start the search at
|
|
* @size: The maximum size to search
|
|
*
|
|
* Returns the bit number of the first set bit.
|
|
*/
|
|
static inline unsigned long find_first_bit(const unsigned long *addr,
|
|
unsigned long size)
|
|
{
|
|
return find_next_bit(addr, size, 0);
|
|
}
|
|
|
|
/**
|
|
* find_first_zero_bit - find the first cleared bit in a memory region
|
|
* @addr: The address to start the search at
|
|
* @size: The maximum size to search
|
|
*
|
|
* Returns the bit number of the first cleared bit.
|
|
*/
|
|
static inline unsigned long find_first_zero_bit(const unsigned long *addr,
|
|
unsigned long size)
|
|
{
|
|
return find_next_zero_bit(addr, size, 0);
|
|
}
|
|
|
|
static inline unsigned long hweight_long(unsigned long w)
|
|
{
|
|
unsigned long count;
|
|
|
|
for (count = 0; w; w >>= 1) {
|
|
count += w & 1;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* rol8 - rotate an 8-bit value left
|
|
* @word: value to rotate
|
|
* @shift: bits to roll
|
|
*/
|
|
static inline uint8_t rol8(uint8_t word, unsigned int shift)
|
|
{
|
|
return (word << shift) | (word >> (8 - shift));
|
|
}
|
|
|
|
/**
|
|
* ror8 - rotate an 8-bit value right
|
|
* @word: value to rotate
|
|
* @shift: bits to roll
|
|
*/
|
|
static inline uint8_t ror8(uint8_t word, unsigned int shift)
|
|
{
|
|
return (word >> shift) | (word << (8 - shift));
|
|
}
|
|
|
|
/**
|
|
* rol16 - rotate a 16-bit value left
|
|
* @word: value to rotate
|
|
* @shift: bits to roll
|
|
*/
|
|
static inline uint16_t rol16(uint16_t word, unsigned int shift)
|
|
{
|
|
return (word << shift) | (word >> (16 - shift));
|
|
}
|
|
|
|
/**
|
|
* ror16 - rotate a 16-bit value right
|
|
* @word: value to rotate
|
|
* @shift: bits to roll
|
|
*/
|
|
static inline uint16_t ror16(uint16_t word, unsigned int shift)
|
|
{
|
|
return (word >> shift) | (word << (16 - shift));
|
|
}
|
|
|
|
/**
|
|
* rol32 - rotate a 32-bit value left
|
|
* @word: value to rotate
|
|
* @shift: bits to roll
|
|
*/
|
|
static inline uint32_t rol32(uint32_t word, unsigned int shift)
|
|
{
|
|
return (word << shift) | (word >> (32 - shift));
|
|
}
|
|
|
|
/**
|
|
* ror32 - rotate a 32-bit value right
|
|
* @word: value to rotate
|
|
* @shift: bits to roll
|
|
*/
|
|
static inline uint32_t ror32(uint32_t word, unsigned int shift)
|
|
{
|
|
return (word >> shift) | (word << (32 - shift));
|
|
}
|
|
|
|
/**
|
|
* rol64 - rotate a 64-bit value left
|
|
* @word: value to rotate
|
|
* @shift: bits to roll
|
|
*/
|
|
static inline uint64_t rol64(uint64_t word, unsigned int shift)
|
|
{
|
|
return (word << shift) | (word >> (64 - shift));
|
|
}
|
|
|
|
/**
|
|
* ror64 - rotate a 64-bit value right
|
|
* @word: value to rotate
|
|
* @shift: bits to roll
|
|
*/
|
|
static inline uint64_t ror64(uint64_t word, unsigned int shift)
|
|
{
|
|
return (word >> shift) | (word << (64 - shift));
|
|
}
|
|
|
|
/**
|
|
* 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));
|
|
}
|
|
|
|
/**
|
|
* sextract32:
|
|
* @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, sign extended to
|
|
* an int32_t (ie with the most significant bit of the field propagated
|
|
* to all the upper bits of the return value). 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 sign extended value of the bit field extracted from the
|
|
* input value.
|
|
*/
|
|
static inline int32_t sextract32(uint32_t value, int start, int length)
|
|
{
|
|
assert(start >= 0 && length > 0 && length <= 32 - start);
|
|
/* Note that this implementation relies on right shift of signed
|
|
* integers being an arithmetic shift.
|
|
*/
|
|
return ((int32_t)(value << (32 - length - start))) >> (32 - length);
|
|
}
|
|
|
|
/**
|
|
* sextract64:
|
|
* @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, sign extended to
|
|
* an int64_t (ie with the most significant bit of the field propagated
|
|
* to all the upper bits of the return value). 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 sign extended value of the bit field extracted from the
|
|
* input value.
|
|
*/
|
|
static inline uint64_t sextract64(uint64_t value, int start, int length)
|
|
{
|
|
assert(start >= 0 && length > 0 && length <= 64 - start);
|
|
/* Note that this implementation relies on right shift of signed
|
|
* integers being an arithmetic shift.
|
|
*/
|
|
return ((int64_t)(value << (64 - length - start))) >> (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 32 bits are modified (ie @length
|
|
* 32 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);
|
|
}
|
|
|
|
/**
|
|
* deposit64:
|
|
* @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 64 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
|