/* -*- mode: C; c-basic-offset: 3; -*- */
/*
This file is part of MemCheck, a heavyweight Valgrind tool for
detecting memory errors.
Copyright (C) 2012-2017 Florian Krohm
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
*/
#include <stdio.h> // fprintf
#include <assert.h> // assert
#if defined(__APPLE__)
#include <machine/endian.h>
#define __BYTE_ORDER BYTE_ORDER
#define __LITTLE_ENDIAN LITTLE_ENDIAN
#elif defined(__sun)
#define __LITTLE_ENDIAN 1234
#define __BIG_ENDIAN 4321
# if defined(_LITTLE_ENDIAN)
# define __BYTE_ORDER __LITTLE_ENDIAN
# else
# define __BYTE_ORDER __BIG_ENDIAN
# endif
#else
#include <endian.h>
#endif
#include <inttypes.h>
#include "vbits.h"
#include "vtest.h"
/* Return the bits of V if they fit into 64-bit. If V has fewer than
64 bits, the bit pattern is zero-extended to the left. */
static uint64_t
get_bits64(vbits_t v)
{
switch (v.num_bits) {
case 1: return v.bits.u32;
case 8: return v.bits.u8;
case 16: return v.bits.u16;
case 32: return v.bits.u32;
case 64: return v.bits.u64;
case 128:
case 256:
/* fall through */
default:
panic(__func__);
}
}
void
print_vbits(FILE *fp, vbits_t v)
{
switch (v.num_bits) {
case 1: fprintf(fp, "%08x", v.bits.u32); break;
case 8: fprintf(fp, "%02x", v.bits.u8); break;
case 16: fprintf(fp, "%04x", v.bits.u16); break;
case 32: fprintf(fp, "%08x", v.bits.u32); break;
case 64: fprintf(fp, "%016"PRIx64, v.bits.u64); break;
case 128:
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
fprintf(fp, "%016"PRIx64, v.bits.u128[1]);
fprintf(fp, "%016"PRIx64, v.bits.u128[0]);
} else {
fprintf(fp, "%016"PRIx64, v.bits.u128[0]);
fprintf(fp, "%016"PRIx64, v.bits.u128[1]);
}
break;
case 256:
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
fprintf(fp, "%016"PRIx64, v.bits.u256[3]);
fprintf(fp, "%016"PRIx64, v.bits.u256[2]);
fprintf(fp, "%016"PRIx64, v.bits.u256[1]);
fprintf(fp, "%016"PRIx64, v.bits.u256[0]);
} else {
fprintf(fp, "%016"PRIx64, v.bits.u256[0]);
fprintf(fp, "%016"PRIx64, v.bits.u256[1]);
fprintf(fp, "%016"PRIx64, v.bits.u256[2]);
fprintf(fp, "%016"PRIx64, v.bits.u256[3]);
}
break;
default:
panic(__func__);
}
}
/* Return a value where all bits are set to undefined. */
vbits_t
undefined_vbits(unsigned num_bits)
{
vbits_t new = { .num_bits = num_bits };
switch (num_bits) {
case 1: new.bits.u32 = 0x01; break;
case 8: new.bits.u8 = 0xff; break;
case 16: new.bits.u16 = 0xffff; break;
case 32: new.bits.u32 = ~0; break;
case 64: new.bits.u64 = ~0ull; break;
case 128: new.bits.u128[0] = ~0ull;
new.bits.u128[1] = ~0ull;
break;
case 256: new.bits.u256[0] = ~0ull;
new.bits.u256[1] = ~0ull;
new.bits.u256[2] = ~0ull;
new.bits.u256[3] = ~0ull;
break;
default:
panic(__func__);
}
return new;
}
/* The following routines named undefined_vbits_BxE() return a 128-bit
* vector with E elements each of size bits. If any of the bits in an
* element is undefined, then return a value where all bits in that
* element are undefined.
*/
vbits_t
undefined_vbits_BxE(unsigned int bits, unsigned int elements, vbits_t v)
{
vbits_t new = { .num_bits = v.num_bits };
uint64_t mask = ~0ull >> (64 - bits);
int i, j;
assert ((elements % 2) == 0);
assert (bits <= 64);
for (i = 0; i<2; i++) {
new.bits.u128[i] = 0ull;
for (j = 0; j<elements/2; j++) {
if ((v.bits.u128[i] & (mask << (j*bits))) != 0)
new.bits.u128[i] |= (mask << (j*bits));
}
}
return new;
}
/* The following routines named undefined_vbits_BxE_rotate() return a 128-bit
* vector with E elements each of size bits. The bits in v are rotated
* left by the amounts in the corresponding element of val. Specified rotate
* amount field is assumed to be at most 8-bits wide.
*/
vbits_t
undefined_vbits_BxE_rotate(unsigned int bits, unsigned int elements,
vbits_t v, value_t val)
{
vbits_t new = { .num_bits = v.num_bits };
uint64_t mask = ~0ull >> (64 - bits);
uint64_t const shift_mask = 0xFF;
uint64_t element;
int i, j;
signed char shift;
assert ((elements % 2) == 0);
assert (bits <= 64);
for (i = 0; i<2; i++) {
new.bits.u128[i] = 0ull;
for (j = 0; j<elements/2; j++) {
element = (v.bits.u128[i] >> (j*bits)) & mask;
shift = (int)((val.u128[i] >> (j*bits)) & shift_mask);
if (shift < 0) {
/* right shift */
new.bits.u128[i] = element >> -shift;
/* OR in the bits shifted out into the top of the element */
new.bits.u128[i] |= element << (bits + shift);
} else {
/* left shift */
/* upper bits from shift */
new.bits.u128[i] = element << shift;
/* OR in the bits shifted out into the bottom of the element */
new.bits.u128[i] |= element >> (bits - shift);
}
}
}
return new;
}
/* Only the even elements of the input are used by the Iop*/
vbits_t
undefined_vbits_128_even_element(unsigned int bits, unsigned int elements,
vbits_t v)
{
int i;
uint64_t mask;
unsigned int const element_width = 128/elements;
vbits_t new = { .num_bits = v.num_bits };
assert ((elements % 2) == 0);
assert (bits <= 64);
/* Create a 128-bit mask with the bits in the even numbered
* elements are all ones.
*/
mask = ~0ull >> (64 - bits);
for (i = 2; i < elements/2; i=i+2) {
mask |= mask << (i * element_width);
}
new.bits.u128[0] = mask & v.bits.u128[0];
new.bits.u128[1] = mask & v.bits.u128[1];
return new;
}
/* Concatenate bit i from each byte j. Place concatenated 8 bit value into
* byte i of the result. Do for all i from 0 to 7 and j from 0 to 7 of each
* 64-bit element.
*/
vbits_t
undefined_vbits_64x2_transpose(vbits_t v)
{
vbits_t new = { .num_bits = v.num_bits };
unsigned int bit, byte, element;
uint64_t value, new_value, select_bit;
for (element = 0; element < 2; element++) {
value = v.bits.u128[element];
new_value = 0;
for (byte = 0; byte < 8; byte++) {
for (bit = 0; bit < 8; bit++) {
select_bit = 1ULL & (value >> (bit + 8*byte));
new_value |= select_bit << (bit*8 + byte);
}
}
new.bits.u128[element] = new_value;
}
return new;
}
/* The routine takes a 256-bit vector value stored across the two 128-bit
* source operands src1 and src2. The size of each element in the input is
* src_num_bits. The elements are narrowed to result_num_bits and packed
* into the result. If saturate is True, then the all the result bits are
* set to 1 if the source element can not be represented in result_num_bits.
*/
vbits_t
undefined_vbits_Narrow256_AtoB(unsigned int src_num_bits,
unsigned int result_num_bits,
vbits_t src1_v, value_t src1_value,
vbits_t src2_v, value_t src2_value,
bool saturate)
{
vbits_t new = { .num_bits = src1_v.num_bits };
unsigned int i;
uint64_t vbits, new_value;
uint64_t const src_mask = ~0x0ULL >> (64 - src_num_bits);
uint64_t const result_mask = ~0x0ULL >> (64 - result_num_bits);
unsigned int num_elements_per_64_bits = src_num_bits/64;
unsigned int shift;
/*
* NOTE: POWER PPC
* the saturated value is 0xFFFF for the vbit is in one of the lower
* 32-bits of the source. The saturated result is 0xFFFF0000 if the
* vbit is in the upper 32-bits of the source. Not sure what
* the saturated result is in general for a B-bit result.
*
* ONLY TESTED FOR 64 bit input, 32 bit result
*/
uint64_t const saturated_result = 0xFFFFULL;
/* Source elements are split between the two source operands */
assert(src_num_bits <= 64);
assert(result_num_bits < 64);
assert(result_num_bits < src_num_bits);
/* Narrow the elements from src1 to the upper 64-bits of result.
* Do each of the 64 bit values that make up a u128
*/
new_value = 0;
for (i = 0; i < num_elements_per_64_bits; i++) {
vbits = src1_v.bits.u128[0] >> (i * src_num_bits);
vbits &= src_mask;
shift = result_num_bits * i;
if (vbits) {
if (saturate) {
/* Value will not fit in B-bits, saturate the result as needed. */
if (vbits >> (src_num_bits/2))
/* vbit is upper half of the source */
new_value |= saturated_result << ( shift + result_num_bits/2);
else
new_value |= saturated_result << shift;
} else {
new_value |= (vbits & result_mask) << shift;
}
}
}
for (i = 0; i < num_elements_per_64_bits; i++) {
vbits = src1_v.bits.u128[1] >> (i * src_num_bits);
vbits &= src_mask;
shift = result_num_bits * i + (num_elements_per_64_bits
* result_num_bits);
if (vbits) {
if (saturate) {
/* Value will not fit in result_num_bits, saturate the result
* as needed.
*/
if (vbits >> (src_num_bits/2))
/* vbit is upper half of the source */
new_value |= saturated_result << (shift + result_num_bits/2);
else
new_value |= saturated_result << shift;
} else {
new_value |= (vbits & result_mask) << shift;
}
}
}
if (__BYTE_ORDER == __LITTLE_ENDIAN)
new.bits.u128[1] = new_value;
else
/* Big endian, swap the upper and lower 32-bits of new_value */
new.bits.u128[0] = (new_value << 32) | (new_value >> 32);
new_value = 0;
/* Narrow the elements from src2 to the lower 64-bits of result.
* Do each of the 64 bit values that make up a u128
*/
for (i = 0; i < num_elements_per_64_bits; i++) {
vbits = src2_v.bits.u128[0] >> (i * src_num_bits);
vbits &= src_mask;
shift = result_num_bits * i;
if (vbits) {
if (saturate) {
/* Value will not fit in result, saturate the result as needed. */
if (vbits >> (src_num_bits/2))
/* vbit is upper half of the source */
new_value |= saturated_result << (shift + result_num_bits/2);
else
new_value |= saturated_result << shift;
} else {
new_value |= (vbits & result_mask) << shift;
}
}
}
for (i = 0; i < num_elements_per_64_bits; i++) {
vbits = src2_v.bits.u128[1] >> (i * src_num_bits);
vbits &= src_mask;
if (vbits) {
if (saturate) {
/* Value will not fit in result_num_bits, saturate the result
* as needed.
*/
if (vbits >> (src_num_bits/2))
/* vbit is upper half of the source */
new_value |= saturated_result << (result_num_bits * i
+ result_num_bits/2
+ (num_elements_per_64_bits
* result_num_bits));
else
new_value |= saturated_result << (result_num_bits * i
+ (num_elements_per_64_bits
* result_num_bits));
} else {
new_value |= (vbits & result_mask) << (result_num_bits * i
+ (num_elements_per_64_bits
* result_num_bits));
}
}
}
if (__BYTE_ORDER == __LITTLE_ENDIAN)
new.bits.u128[0] = new_value;
else
/* Big endian, swap the upper and lower 32-bits of new_value */
new.bits.u128[1] = (new_value << 32) | (new_value >> 32);
return new;
}
/* Return a value where all bits are set to defined. */
vbits_t
defined_vbits(unsigned num_bits)
{
vbits_t new = { .num_bits = num_bits };
switch (num_bits) {
case 1: new.bits.u32 = 0x0; break;
case 8: new.bits.u8 = 0x0; break;
case 16: new.bits.u16 = 0x0; break;
case 32: new.bits.u32 = 0x0; break;
case 64: new.bits.u64 = 0x0; break;
case 128: new.bits.u128[0] = 0x0;
new.bits.u128[1] = 0x0;
break;
case 256: new.bits.u256[0] = 0x0;
new.bits.u256[1] = 0x0;
new.bits.u256[2] = 0x0;
new.bits.u256[3] = 0x0;
break;
default:
panic(__func__);
}
return new;
}
/* Return 1, if equal. */
int
equal_vbits(vbits_t v1, vbits_t v2)
{
assert(v1.num_bits == v2.num_bits);
switch (v1.num_bits) {
case 1: return v1.bits.u32 == v2.bits.u32;
case 8: return v1.bits.u8 == v2.bits.u8;
case 16: return v1.bits.u16 == v2.bits.u16;
case 32: return v1.bits.u32 == v2.bits.u32;
case 64: return v1.bits.u64 == v2.bits.u64;
case 128: return v1.bits.u128[0] == v2.bits.u128[0] &&
v1.bits.u128[1] == v2.bits.u128[1];
case 256: return v1.bits.u256[0] == v2.bits.u256[0] &&
v1.bits.u256[1] == v2.bits.u256[1] &&
v1.bits.u256[2] == v2.bits.u256[2] &&
v1.bits.u256[3] == v2.bits.u256[3];
default:
panic(__func__);
}
}
/* Truncate the bit pattern in V1 to NUM_BITS bits */
vbits_t
truncate_vbits(vbits_t v, unsigned num_bits)
{
assert(num_bits <= v.num_bits);
if (num_bits == v.num_bits) return v;
vbits_t new = { .num_bits = num_bits };
if (num_bits <= 64) {
uint64_t bits;
if (v.num_bits <= 64)
bits = get_bits64(v);
else if (v.num_bits == 128)
if (__BYTE_ORDER == __LITTLE_ENDIAN)
bits = v.bits.u128[0];
else
bits = v.bits.u128[1];
else if (v.num_bits == 256)
if (__BYTE_ORDER == __LITTLE_ENDIAN)
bits = v.bits.u256[0];
else
bits = v.bits.u256[3];
else
panic(__func__);
switch (num_bits) {
case 1: new.bits.u32 = bits & 0x01; break;
case 8: new.bits.u8 = bits & 0xff; break;
case 16: new.bits.u16 = bits & 0xffff; break;
case 32: new.bits.u32 = bits & ~0u; break;
case 64: new.bits.u64 = bits & ~0ll; break;
default:
panic(__func__);
}
return new;
}
if (num_bits == 128) {
assert(v.num_bits == 256);
/* From 256 bits to 128 */
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
new.bits.u128[0] = v.bits.u256[0];
new.bits.u128[1] = v.bits.u256[1];
} else {
new.bits.u128[0] = v.bits.u256[2];
new.bits.u128[1] = v.bits.u256[3];
}
return new;
}
/* Cannot truncate to 256 bits from something larger */
panic(__func__);
}
/* Helper function to compute left_vbits */
static uint64_t
left64(uint64_t x)
{
// left(x) = x | -x
return x | (~x + 1);
}
vbits_t
left_vbits(vbits_t v, unsigned num_bits)
{
assert(num_bits >= v.num_bits);
vbits_t new = { .num_bits = num_bits };
if (v.num_bits <= 64) {
uint64_t bits = left64(get_bits64(v));
switch (num_bits) {
case 8: new.bits.u8 = bits & 0xff; break;
case 16: new.bits.u16 = bits & 0xffff; break;
case 32: new.bits.u32 = bits & ~0u; break;
case 64: new.bits.u64 = bits & ~0ll; break;
case 128:
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
new.bits.u128[0] = bits;
if (bits & (1ull << 63)) { // MSB is set
new.bits.u128[1] = ~0ull;
} else {
new.bits.u128[1] = 0;
}
} else {
new.bits.u128[1] = bits;
if (bits & (1ull << 63)) { // MSB is set
new.bits.u128[0] = ~0ull;
} else {
new.bits.u128[0] = 0;
}
}
break;
case 256:
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
new.bits.u256[0] = bits;
if (bits & (1ull << 63)) { // MSB is set
new.bits.u256[1] = ~0ull;
new.bits.u256[2] = ~0ull;
new.bits.u256[3] = ~0ull;
} else {
new.bits.u256[1] = 0;
new.bits.u256[2] = 0;
new.bits.u256[3] = 0;
}
} else {
new.bits.u256[3] = bits;
if (bits & (1ull << 63)) { // MSB is set
new.bits.u256[0] = ~0ull;
new.bits.u256[1] = ~0ull;
new.bits.u256[2] = ~0ull;
} else {
new.bits.u256[0] = 0;
new.bits.u256[1] = 0;
new.bits.u256[2] = 0;
}
}
break;
default:
panic(__func__);
}
return new;
}
if (v.num_bits == 128) {
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
if (v.bits.u128[1] != 0) {
new.bits.u128[0] = v.bits.u128[0];
new.bits.u128[1] = left64(v.bits.u128[1]);
} else {
new.bits.u128[0] = left64(v.bits.u128[0]);
if (new.bits.u128[0] & (1ull << 63)) { // MSB is set
new.bits.u128[1] = ~0ull;
} else {
new.bits.u128[1] = 0;
}
}
} else {
if (v.bits.u128[0] != 0) {
new.bits.u128[0] = left64(v.bits.u128[0]);
new.bits.u128[1] = v.bits.u128[1];
} else {
new.bits.u128[1] = left64(v.bits.u128[1]);
if (new.bits.u128[1] & (1ull << 63)) { // MSB is set
new.bits.u128[0] = ~0ull;
} else {
new.bits.u128[0] = 0;
}
}
}
if (num_bits == 128) return new;
assert(num_bits == 256);
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
uint64_t b1 = new.bits.u128[1];
uint64_t b0 = new.bits.u128[0];
new.bits.u256[0] = b0;
new.bits.u256[1] = b1;
if (new.bits.u256[1] & (1ull << 63)) { // MSB is set
new.bits.u256[2] = ~0ull;
new.bits.u256[3] = ~0ull;
} else {
new.bits.u256[2] = 0;
new.bits.u256[3] = 0;
}
} else {
uint64_t b1 = new.bits.u128[0];
uint64_t b0 = new.bits.u128[1];
new.bits.u256[2] = b0;
new.bits.u256[3] = b1;
if (new.bits.u256[2] & (1ull << 63)) { // MSB is set
new.bits.u256[0] = ~0ull;
new.bits.u256[1] = ~0ull;
} else {
new.bits.u256[0] = 0;
new.bits.u256[1] = 0;
}
}
return new;
}
panic(__func__);
}
vbits_t
or_vbits(vbits_t v1, vbits_t v2)
{
assert(v1.num_bits == v2.num_bits);
vbits_t new = { .num_bits = v1.num_bits };
switch (v1.num_bits) {
case 8: new.bits.u8 = v1.bits.u8 | v2.bits.u8; break;
case 16: new.bits.u16 = v1.bits.u16 | v2.bits.u16; break;
case 32: new.bits.u32 = v1.bits.u32 | v2.bits.u32; break;
case 64: new.bits.u64 = v1.bits.u64 | v2.bits.u64; break;
case 128: new.bits.u128[0] = v1.bits.u128[0] | v2.bits.u128[0];
new.bits.u128[1] = v1.bits.u128[1] | v2.bits.u128[1];
break;
case 256: new.bits.u256[0] = v1.bits.u256[0] | v2.bits.u256[0];
new.bits.u256[1] = v1.bits.u256[1] | v2.bits.u256[1];
new.bits.u256[2] = v1.bits.u256[2] | v2.bits.u256[2];
new.bits.u256[3] = v1.bits.u256[3] | v2.bits.u256[3];
break;
default:
panic(__func__);
}
return new;
}
vbits_t
and_vbits(vbits_t v1, vbits_t v2)
{
assert(v1.num_bits == v2.num_bits);
vbits_t new = { .num_bits = v1.num_bits };
switch (v1.num_bits) {
case 8: new.bits.u8 = v1.bits.u8 & v2.bits.u8; break;
case 16: new.bits.u16 = v1.bits.u16 & v2.bits.u16; break;
case 32: new.bits.u32 = v1.bits.u32 & v2.bits.u32; break;
case 64: new.bits.u64 = v1.bits.u64 & v2.bits.u64; break;
case 128: new.bits.u128[0] = v1.bits.u128[0] & v2.bits.u128[0];
new.bits.u128[1] = v1.bits.u128[1] & v2.bits.u128[1];
break;
case 256: new.bits.u256[0] = v1.bits.u256[0] & v2.bits.u256[0];
new.bits.u256[1] = v1.bits.u256[1] & v2.bits.u256[1];
new.bits.u256[2] = v1.bits.u256[2] & v2.bits.u256[2];
new.bits.u256[3] = v1.bits.u256[3] & v2.bits.u256[3];
break;
default:
panic(__func__);
}
return new;
}
vbits_t
concat_vbits(vbits_t v1, vbits_t v2)
{
assert(v1.num_bits == v2.num_bits);
vbits_t new = { .num_bits = v1.num_bits * 2 };
switch (v1.num_bits) {
case 8: new.bits.u16 = v1.bits.u8;
new.bits.u16 = (new.bits.u16 << 8) | v2.bits.u8; break;
case 16: new.bits.u32 = v1.bits.u16;
new.bits.u32 = (new.bits.u32 << 16) | v2.bits.u16; break;
case 32: new.bits.u64 = v1.bits.u32;
new.bits.u64 = (new.bits.u64 << 32) | v2.bits.u32; break;
case 64:
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
new.bits.u128[0] = v2.bits.u64;
new.bits.u128[1] = v1.bits.u64;
} else {
new.bits.u128[0] = v1.bits.u64;
new.bits.u128[1] = v2.bits.u64;
}
break;
case 128:
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
new.bits.u256[0] = v2.bits.u128[0];
new.bits.u256[1] = v2.bits.u128[1];
new.bits.u256[2] = v1.bits.u128[0];
new.bits.u256[3] = v1.bits.u128[1];
} else {
new.bits.u256[0] = v1.bits.u128[0];
new.bits.u256[1] = v1.bits.u128[1];
new.bits.u256[2] = v2.bits.u128[0];
new.bits.u256[3] = v2.bits.u128[1];
}
break;
case 256: /* Fall through */
default:
panic(__func__);
}
return new;
}
vbits_t
upper_vbits(vbits_t v)
{
vbits_t new = { .num_bits = v.num_bits / 2 };
switch (v.num_bits) {
case 16: new.bits.u8 = v.bits.u16 >> 8; break;
case 32: new.bits.u16 = v.bits.u32 >> 16; break;
case 64: new.bits.u32 = v.bits.u64 >> 32; break;
case 128:
if (__BYTE_ORDER == __LITTLE_ENDIAN)
new.bits.u64 = v.bits.u128[1];
else
new.bits.u64 = v.bits.u128[0];
break;
case 256:
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
new.bits.u128[0] = v.bits.u256[2];
new.bits.u128[1] = v.bits.u256[3];
} else {
new.bits.u128[0] = v.bits.u256[0];
new.bits.u128[1] = v.bits.u256[1];
}
break;
case 8:
default:
panic(__func__);
}
return new;
}
vbits_t
zextend_vbits(vbits_t v, unsigned num_bits)
{
assert(num_bits >= v.num_bits);
if (num_bits == v.num_bits) return v;
vbits_t new = { .num_bits = num_bits };
if (v.num_bits <= 64) {
uint64_t bits = get_bits64(v);
switch (num_bits) {
case 8: new.bits.u8 = bits; break;
case 16: new.bits.u16 = bits; break;
case 32: new.bits.u32 = bits; break;
case 64: new.bits.u64 = bits; break;
case 128:
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
new.bits.u128[0] = bits;
new.bits.u128[1] = 0;
} else {
new.bits.u128[0] = 0;
new.bits.u128[1] = bits;
}
break;
case 256:
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
new.bits.u256[0] = bits;
new.bits.u256[1] = 0;
new.bits.u256[2] = 0;
new.bits.u256[3] = 0;
} else {
new.bits.u256[0] = 0;
new.bits.u256[1] = 0;
new.bits.u256[2] = 0;
new.bits.u256[3] = bits;
}
break;
default:
panic(__func__);
}
return new;
}
if (v.num_bits == 128) {
assert(num_bits == 256);
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
new.bits.u256[0] = v.bits.u128[0];
new.bits.u256[1] = v.bits.u128[1];
new.bits.u256[2] = 0;
new.bits.u256[3] = 0;
} else {
new.bits.u256[0] = 0;
new.bits.u256[1] = 0;
new.bits.u256[2] = v.bits.u128[1];
new.bits.u256[3] = v.bits.u128[0];
}
return new;
}
/* Cannot zero-extend a 256-bit value to something larger */
panic(__func__);
}
vbits_t
sextend_vbits(vbits_t v, unsigned num_bits)
{
assert(num_bits >= v.num_bits);
int sextend = 0;
switch (v.num_bits) {
case 8: if (v.bits.u8 == 0x80) sextend = 1; break;
case 16: if (v.bits.u16 == 0x8000) sextend = 1; break;
case 32: if (v.bits.u32 == 0x80000000) sextend = 1; break;
case 64: if (v.bits.u64 == (1ull << 63)) sextend = 1; break;
case 128: if (v.bits.u128[1] == (1ull << 63)) sextend = 1; break;
case 256: if (v.bits.u256[3] == (1ull << 63)) sextend = 1; break;
default:
panic(__func__);
}
return sextend ? left_vbits(v, num_bits) : zextend_vbits(v, num_bits);
}
vbits_t
onehot_vbits(unsigned bitno, unsigned num_bits)
{
assert(bitno < num_bits);
vbits_t new = { .num_bits = num_bits };
switch (num_bits) {
case 1: new.bits.u32 = 1 << bitno; break;
case 8: new.bits.u8 = 1 << bitno; break;
case 16: new.bits.u16 = 1 << bitno; break;
case 32: new.bits.u32 = 1u << bitno; break;
case 64: new.bits.u64 = 1ull << bitno; break;
case 128:
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
if (bitno < 64) {
new.bits.u128[0] = 1ull << bitno;
new.bits.u128[1] = 0;
} else {
new.bits.u128[0] = 0;
new.bits.u128[1] = 1ull << (bitno - 64);
}
} else {
if (bitno < 64) {
new.bits.u128[0] = 0;
new.bits.u128[1] = 1ull << bitno;
} else {
new.bits.u128[0] = 1ull << (bitno - 64);
new.bits.u128[1] = 0;
}
}
break;
case 256:
if (__BYTE_ORDER == __LITTLE_ENDIAN) {
if (bitno < 64) {
new.bits.u256[0] = 1ull << bitno;
new.bits.u256[1] = 0;
new.bits.u256[2] = 0;
new.bits.u256[3] = 0;
} else if (bitno < 128) {
new.bits.u256[0] = 0;
new.bits.u256[1] = 1ull << (bitno - 64);
new.bits.u256[2] = 0;
new.bits.u256[3] = 0;
} else if (bitno < 192) {
new.bits.u256[0] = 0;
new.bits.u256[1] = 0;
new.bits.u256[2] = 1ull << (bitno - 128);
new.bits.u256[3] = 0;
} else {
new.bits.u256[0] = 0;
new.bits.u256[1] = 0;
new.bits.u256[2] = 0;
new.bits.u256[3] = 1ull << (bitno - 192);
}
} else {
if (bitno < 64) {
new.bits.u256[0] = 0;
new.bits.u256[1] = 0;
new.bits.u256[2] = 0;
new.bits.u256[3] = 1ull << bitno;
} else if (bitno < 128) {
new.bits.u256[0] = 0;
new.bits.u256[1] = 0;
new.bits.u256[2] = 1ull << (bitno - 64);
new.bits.u256[3] = 0;
} else if (bitno < 192) {
new.bits.u256[0] = 0;
new.bits.u256[1] = 1ull << (bitno - 128);
new.bits.u256[2] = 0;
new.bits.u256[3] = 0;
} else {
new.bits.u256[0] = 1ull << (bitno - 192);
new.bits.u256[1] = 0;
new.bits.u256[2] = 0;
new.bits.u256[3] = 0;
}
}
break;
default:
panic(__func__);
}
return new;
}
int
completely_defined_vbits(vbits_t v)
{
return equal_vbits(v, defined_vbits(v.num_bits));
}
vbits_t
shl_vbits(vbits_t v, unsigned shift_amount)
{
assert(shift_amount < v.num_bits);
vbits_t new = v;
switch (v.num_bits) {
case 8: new.bits.u8 <<= shift_amount; break;
case 16: new.bits.u16 <<= shift_amount; break;
case 32: new.bits.u32 <<= shift_amount; break;
case 64: new.bits.u64 <<= shift_amount; break;
case 128: /* fall through */
case 256: /* fall through */
default:
panic(__func__);
}
return new;
}
vbits_t
shr_vbits(vbits_t v, unsigned shift_amount)
{
assert(shift_amount < v.num_bits);
vbits_t new = v;
switch (v.num_bits) {
case 8: new.bits.u8 >>= shift_amount; break;
case 16: new.bits.u16 >>= shift_amount; break;
case 32: new.bits.u32 >>= shift_amount; break;
case 64: new.bits.u64 >>= shift_amount; break;
case 128: /* fall through */
case 256: /* fall through */
default:
panic(__func__);
}
return new;
}
vbits_t
sar_vbits(vbits_t v, unsigned shift_amount)
{
assert(shift_amount < v.num_bits);
vbits_t new = v;
int msb;
switch (v.num_bits) {
case 8:
new.bits.u8 >>= shift_amount;
msb = (v.bits.u8 & 0x80) != 0;
break;
case 16:
new.bits.u16 >>= shift_amount;
msb = (v.bits.u16 & 0x8000) != 0;
break;
case 32:
new.bits.u32 >>= shift_amount;
msb = (v.bits.u32 & (1u << 31)) != 0;
break;
case 64:
new.bits.u64 >>= shift_amount;
msb = (v.bits.u64 & (1ull << 63)) != 0;
break;
case 128: /* fall through */
case 256: /* fall through */
default:
panic(__func__);
}
if (msb)
new = left_vbits(new, new.num_bits);
return new;
}
/* Return a value for the POWER Iop_CmpORD class iops */
vbits_t
cmpord_vbits(unsigned v1_num_bits, unsigned v2_num_bits)
{
vbits_t new = { .num_bits = v1_num_bits };
/* Size of values being compared must be the same */
assert( v1_num_bits == v2_num_bits);
/* Comparison only produces 32-bit or 64-bit value where
* the lower 3 bits are set to indicate, less than, equal and greater than.
*/
switch (v1_num_bits) {
case 32:
new.bits.u32 = 0xE;
break;
case 64:
new.bits.u64 = 0xE;
break;
default:
panic(__func__);
}
return new;
}