}
info->has_virtual_memory = true;
- assert(util_is_power_of_two(dma.available_rings + 1));
- assert(util_is_power_of_two(compute.available_rings + 1));
+ assert(util_is_power_of_two_or_zero(dma.available_rings + 1));
+ assert(util_is_power_of_two_or_zero(compute.available_rings + 1));
info->num_sdma_rings = util_bitcount(dma.available_rings);
info->num_compute_rings = util_bitcount(compute.available_rings);
AddrSurfInfoIn->bpp) {
unsigned alignment = 256 / (AddrSurfInfoIn->bpp / 8);
- assert(util_is_power_of_two(AddrSurfInfoIn->bpp));
+ assert(util_is_power_of_two_or_zero(AddrSurfInfoIn->bpp));
AddrSurfInfoIn->width = align(AddrSurfInfoIn->width, alignment);
}
tiled |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
}
}
- if (tiled && util_is_power_of_two(vk_format_get_blocksize(format)) && !scaled) {
+ if (tiled && util_is_power_of_two_or_zero(vk_format_get_blocksize(format)) && !scaled) {
tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR |
VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
}
}
- if (linear && util_is_power_of_two(vk_format_get_blocksize(format)) && !scaled) {
+ if (linear && util_is_power_of_two_or_zero(vk_format_get_blocksize(format)) && !scaled) {
linear |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR |
VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
}
ntq_get_alu_src(struct v3d_compile *c, nir_alu_instr *instr,
unsigned src)
{
- assert(util_is_power_of_two(instr->dest.write_mask));
+ assert(util_is_power_of_two_or_zero(instr->dest.write_mask));
unsigned chan = ffs(instr->dest.write_mask) - 1;
struct qreg r = ntq_get_src(c, instr->src[src].src,
instr->src[src].swizzle[chan]);
/* We have a scalar result, so the instruction should only have a
* single channel written to.
*/
- assert(util_is_power_of_two(instr->dest.write_mask));
+ assert(util_is_power_of_two_or_zero(instr->dest.write_mask));
ntq_store_dest(c, &instr->dest.dest,
ffs(instr->dest.write_mask) - 1, result);
}
if(b == 2 && bld->type.floating)
return lp_build_add(bld, a, a);
- if(util_is_power_of_two(b)) {
+ if(util_is_power_of_two_or_zero(b)) {
unsigned shift = ffs(b) - 1;
if(bld->type.floating) {
extern "C" boolean
lp_check_alignment(const void *ptr, unsigned alignment)
{
- assert(util_is_power_of_two(alignment));
+ assert(util_is_power_of_two_or_zero(alignment));
return ((uintptr_t)ptr & (alignment - 1)) == 0;
}
if (format_matches_type(format_desc, type) &&
format_desc->block.bits <= type.width * 4 &&
/* XXX this shouldn't be needed */
- util_is_power_of_two(format_desc->block.bits)) {
+ util_is_power_of_two_or_zero(format_desc->block.bits)) {
LLVMValueRef packed;
LLVMTypeRef dst_vec_type = lp_build_vec_type(gallivm, type);
struct lp_type fetch_type;
format_desc->block.width == 1 &&
format_desc->block.height == 1 &&
/* XXX this shouldn't be needed */
- util_is_power_of_two(format_desc->block.bits) &&
+ util_is_power_of_two_or_zero(format_desc->block.bits) &&
format_desc->block.bits <= 32 &&
format_desc->is_bitmask &&
!format_desc->is_mixed &&
*/
if (!aligned) {
LLVMSetAlignment(res, 1);
- } else if (!util_is_power_of_two(src_width)) {
+ } else if (!util_is_power_of_two_or_zero(src_width)) {
/*
* Full alignment is impossible, assume the caller really meant
* the individual elements were aligned (e.g. 3x32bit format).
* this should cover all the 3-channel formats.
*/
if (((src_width / 24) * 24 == src_width) &&
- util_is_power_of_two(src_width / 24)) {
+ util_is_power_of_two_or_zero(src_width / 24)) {
LLVMSetAlignment(res, src_width / 24);
} else {
LLVMSetAlignment(res, 1);
*/
if (!aligned) {
LLVMSetAlignment(res, 1);
- } else if (!util_is_power_of_two(src_width)) {
+ } else if (!util_is_power_of_two_or_zero(src_width)) {
/*
* Full alignment is impossible, assume the caller really meant
* the individual elements were aligned (e.g. 3x32bit format).
* this should cover all the 3-channel formats.
*/
if (((src_width / 24) * 24 == src_width) &&
- util_is_power_of_two(src_width / 24)) {
+ util_is_power_of_two_or_zero(src_width / 24)) {
LLVMSetAlignment(res, src_width / 24);
} else {
LLVMSetAlignment(res, 1);
LLVMValueRef shuffles[LP_MAX_VECTOR_LENGTH];
assert(src_type.length * num_vectors <= ARRAY_SIZE(shuffles));
- assert(util_is_power_of_two(num_vectors));
+ assert(util_is_power_of_two_or_zero(num_vectors));
new_length = src_type.length;
state->swizzle_a = view->swizzle_a;
state->target = view->target;
- state->pot_width = util_is_power_of_two(texture->width0);
- state->pot_height = util_is_power_of_two(texture->height0);
- state->pot_depth = util_is_power_of_two(texture->depth0);
+ state->pot_width = util_is_power_of_two_or_zero(texture->width0);
+ state->pot_height = util_is_power_of_two_or_zero(texture->height0);
+ state->pot_depth = util_is_power_of_two_or_zero(texture->depth0);
state->level_zero_only = !view->u.tex.last_level;
/*
return util_fast_exp2(util_fast_log2(x) * y);
}
-/* Note that this counts zero as a power of two.
- */
-static inline boolean
-util_is_power_of_two( unsigned v )
-{
- return (v & (v-1)) == 0;
-}
-
/**
* Floor(x), returned as int.
if (x <= 1)
return 1;
- if (util_is_power_of_two(x))
+ if (util_is_power_of_two_or_zero(x))
return x;
val--;
if (!ring)
return NULL;
- assert(util_is_power_of_two(dwords));
+ assert(util_is_power_of_two_or_zero(dwords));
ring->buf = MALLOC( dwords * sizeof(unsigned) );
if (ring->buf == NULL)
static void
emit_blt_inplace(struct etna_cmd_stream *stream, const struct blt_inplace_op *op)
{
- assert(op->bpp > 0 && util_is_power_of_two(op->bpp));
+ assert(op->bpp > 0 && util_is_power_of_two_or_zero(op->bpp));
etna_cmd_stream_reserve(stream, 64*2); /* Never allow BLT sequences to be broken up */
etna_set_state(stream, VIVS_BLT_ENABLE, 0x00000001);
etna_set_state(stream, VIVS_BLT_CONFIG,
/* Workaround for npot textures -- it appears that only CLAMP_TO_EDGE is
* supported when the appropriate capability is not set. */
if (!ctx->specs.npot_tex_any_wrap &&
- (!util_is_power_of_two(res->base.width0) || !util_is_power_of_two(res->base.height0))) {
+ (!util_is_power_of_two_or_zero(res->base.width0) ||
+ !util_is_power_of_two_or_zero(res->base.height0))) {
sv->TE_SAMPLER_CONFIG0_MASK = ~(VIVS_TE_SAMPLER_CONFIG0_UWRAP__MASK |
VIVS_TE_SAMPLER_CONFIG0_VWRAP__MASK);
sv->TE_SAMPLER_CONFIG0 |=
struct fd_hw_sample *samp = slab_alloc_st(&batch->ctx->sample_pool);
pipe_reference_init(&samp->reference, 1);
samp->size = size;
- debug_assert(util_is_power_of_two(size));
+ debug_assert(util_is_power_of_two_or_zero(size));
batch->next_sample_offset = align(batch->next_sample_offset, size);
samp->offset = batch->next_sample_offset;
/* NOTE: slab_alloc_st() does not zero out the buffer: */
int first_level = view->u.tex.first_level;
const uint num_levels = pt->last_level - first_level;
unsigned max_lod = num_levels * 4;
- bool is_npot = (!util_is_power_of_two(pt->width0) || !util_is_power_of_two(pt->height0));
+ bool is_npot = (!util_is_power_of_two_or_zero(pt->width0) ||
+ !util_is_power_of_two_or_zero(pt->height0));
uint format, pitch;
/*
if (dst_count > src_count) {
if ((dst_type.width == 8 || dst_type.width == 16) &&
- util_is_power_of_two(dst_type.length) &&
+ util_is_power_of_two_or_zero(dst_type.length) &&
dst_type.length * dst_type.width < 128) {
/*
* Never try to load values as 4xi8 which we will then
bytes = size / 8;
- if (!util_is_power_of_two(bytes)) {
+ if (!util_is_power_of_two_or_zero(bytes)) {
bytes /= desc->nr_channels;
}
bool
ImmediateValue::isPow2() const
{
- return util_is_power_of_two(reg.data.u32);
+ return util_is_power_of_two_or_zero(reg.data.u32);
}
void
src->op == OP_SHR &&
src->src(1).getImmediate(imm1) &&
i->src(t).mod == Modifier(0) &&
- util_is_power_of_two(imm0.reg.data.u32 + 1)) {
+ util_is_power_of_two_or_zero(imm0.reg.data.u32 + 1)) {
// low byte = offset, high byte = width
uint32_t ext = (util_last_bit(imm0.reg.data.u32) << 8) | imm1.reg.data.u32;
i->op = OP_EXTBF;
} else if (src->op == OP_SHL &&
src->src(1).getImmediate(imm1) &&
i->src(t).mod == Modifier(0) &&
- util_is_power_of_two(~imm0.reg.data.u32 + 1) &&
+ util_is_power_of_two_or_zero(~imm0.reg.data.u32 + 1) &&
util_last_bit(~imm0.reg.data.u32) <= imm1.reg.data.u32) {
i->op = OP_MOV;
i->setSrc(s, NULL);
if ((pt->target == PIPE_TEXTURE_RECT) ||
(pt->bind & PIPE_BIND_SCANOUT) ||
- !util_is_power_of_two(pt->width0) ||
- !util_is_power_of_two(pt->height0) ||
- !util_is_power_of_two(pt->depth0) ||
+ !util_is_power_of_two_or_zero(pt->width0) ||
+ !util_is_power_of_two_or_zero(pt->height0) ||
+ !util_is_power_of_two_or_zero(pt->depth0) ||
util_format_is_compressed(pt->format) ||
util_format_is_float(pt->format) || mt->ms_mode) {
mt->uniform_pitch = util_format_get_nblocksx(pt->format, w) * blocksz;
}
if (nr_cbufs == 0 && !fb->zsbuf) {
- assert(util_is_power_of_two(fb->samples));
+ assert(util_is_power_of_two_or_zero(fb->samples));
assert(fb->samples <= 8);
nvc0_fb_set_null_rt(push, 0, fb->layers);
static void r300_setup_flags(struct r300_resource *tex)
{
tex->tex.uses_stride_addressing =
- !util_is_power_of_two(tex->b.b.width0) ||
+ !util_is_power_of_two_or_zero(tex->b.b.width0) ||
(tex->tex.stride_in_bytes_override &&
r300_stride_to_width(tex->b.b.format,
tex->tex.stride_in_bytes_override) != tex->b.b.width0);
tex->tex.is_npot =
tex->tex.uses_stride_addressing ||
- !util_is_power_of_two(tex->b.b.height0) ||
- !util_is_power_of_two(tex->b.b.depth0);
+ !util_is_power_of_two_or_zero(tex->b.b.height0) ||
+ !util_is_power_of_two_or_zero(tex->b.b.depth0);
}
static void r300_setup_cbzb_flags(struct r300_screen *rscreen,
bpe = 4; /* stencil is allocated separately on evergreen */
} else {
bpe = util_format_get_blocksize(ptex->format);
- assert(util_is_power_of_two(bpe));
+ assert(util_is_power_of_two_or_zero(bpe));
}
if (!is_flushed_depth && is_depth) {
bpe = 4; /* stencil is allocated separately on evergreen */
} else {
bpe = util_format_get_blocksize(ptex->format);
- assert(util_is_power_of_two(bpe));
+ assert(util_is_power_of_two_or_zero(bpe));
}
if (!is_flushed_depth && is_depth) {
LLVMValueRef c_max = LLVMConstInt(ctx->i32, num - 1, 0);
LLVMValueRef cc;
- if (util_is_power_of_two(num)) {
+ if (util_is_power_of_two_or_zero(num)) {
index = LLVMBuildAnd(builder, index, c_max, "");
} else {
/* In theory, this MAX pattern should result in code that is
pipe_reference_init(&spr->base.reference, 1);
spr->base.screen = screen;
- spr->pot = (util_is_power_of_two(templat->width0) &&
- util_is_power_of_two(templat->height0) &&
- util_is_power_of_two(templat->depth0));
+ spr->pot = (util_is_power_of_two_or_zero(templat->width0) &&
+ util_is_power_of_two_or_zero(templat->height0) &&
+ util_is_power_of_two_or_zero(templat->depth0));
if (spr->base.bind & (PIPE_BIND_DISPLAY_TARGET |
PIPE_BIND_SCANOUT |
pipe_reference_init(&spr->base.reference, 1);
spr->base.screen = screen;
- spr->pot = (util_is_power_of_two(templat->width0) &&
- util_is_power_of_two(templat->height0) &&
- util_is_power_of_two(templat->depth0));
+ spr->pot = (util_is_power_of_two_or_zero(templat->width0) &&
+ util_is_power_of_two_or_zero(templat->height0) &&
+ util_is_power_of_two_or_zero(templat->depth0));
spr->dt = winsys->displaytarget_from_handle(winsys,
templat,
return FALSE;
if ((sample_count > screen->msaa_max_count)
- || !util_is_power_of_two(sample_count))
+ || !util_is_power_of_two_or_zero(sample_count))
return FALSE;
if (bind & PIPE_BIND_DISPLAY_TARGET) {
int msaa_max_count = debug_get_num_option("SWR_MSAA_MAX_COUNT", 1);
if (msaa_max_count != 1) {
if ((msaa_max_count < 1) || (msaa_max_count > SWR_MAX_NUM_MULTISAMPLES)
- || !util_is_power_of_two(msaa_max_count)) {
+ || !util_is_power_of_two_or_zero(msaa_max_count)) {
fprintf(stderr, "SWR_MSAA_MAX_COUNT invalid: %d\n", msaa_max_count);
fprintf(stderr, "must be power of 2 between 1 and %d" \
" (or 1 to disable msaa)\n",
ntq_get_alu_src(struct vc4_compile *c, nir_alu_instr *instr,
unsigned src)
{
- assert(util_is_power_of_two(instr->dest.write_mask));
+ assert(util_is_power_of_two_or_zero(instr->dest.write_mask));
unsigned chan = ffs(instr->dest.write_mask) - 1;
struct qreg r = ntq_get_src(c, instr->src[src].src,
instr->src[src].swizzle[chan]);
/* We have a scalar result, so the instruction should only have a
* single channel written to.
*/
- assert(util_is_power_of_two(instr->dest.write_mask));
+ assert(util_is_power_of_two_or_zero(instr->dest.write_mask));
ntq_store_dest(c, &instr->dest.dest,
ffs(instr->dest.write_mask) - 1, result);
}
static void
cplx_align_assert_sane(struct cplx_align a)
{
- assert(a.mul > 0 && util_is_power_of_two(a.mul));
+ assert(a.mul > 0 && util_is_power_of_two_or_zero(a.mul));
assert(a.offset < a.mul);
}
mark_uniform_slots_read(struct uniform_slot_info *slots,
unsigned num_slots, unsigned alignment)
{
- assert(alignment > 0 && util_is_power_of_two(alignment));
+ assert(alignment > 0 && util_is_power_of_two_or_zero(alignment));
assert(alignment <= CPLX_ALIGN_MAX_MUL);
/* We can't align a slot to anything less than the slot size */
if (result != VK_SUCCESS)
return result;
- assert(util_is_power_of_two(block_size));
+ assert(util_is_power_of_two_or_zero(block_size));
pool->block_size = block_size;
pool->back_alloc_free_list = ANV_FREE_LIST_EMPTY;
for (unsigned i = 0; i < ANV_STATE_BUCKETS; i++) {
static void
anv_state_pool_free_no_vg(struct anv_state_pool *pool, struct anv_state state)
{
- assert(util_is_power_of_two(state.alloc_size));
+ assert(util_is_power_of_two_or_zero(state.alloc_size));
unsigned bucket = anv_state_pool_get_bucket(state.alloc_size);
if (state.offset < 0) {
struct bo_pool_bo_link *link = bo.map;
VG_NOACCESS_WRITE(&link->bo, bo);
- assert(util_is_power_of_two(bo.size));
+ assert(util_is_power_of_two_or_zero(bo.size));
const unsigned size_log2 = ilog2_round_up(bo.size);
const unsigned bucket = size_log2 - 12;
assert(bucket < ARRAY_SIZE(pool->free_list));
isl_format_get_layout(plane_format.isl_format);
if (tiling == VK_IMAGE_TILING_OPTIMAL &&
- !util_is_power_of_two(isl_layout->bpb)) {
+ !util_is_power_of_two_or_zero(isl_layout->bpb)) {
/* Tiled formats *must* be power-of-two because we need up upload
* them with the render pipeline. For 3-channel formats, we fix
* this by switching them over to RGBX or RGBA formats under the
*/
if (vk_tiling == VK_IMAGE_TILING_OPTIMAL &&
base_isl_format != ISL_FORMAT_UNSUPPORTED &&
- !util_is_power_of_two(isl_format_layouts[base_isl_format].bpb) &&
+ !util_is_power_of_two_or_zero(isl_format_layouts[base_isl_format].bpb) &&
isl_format_rgb_to_rgbx(base_isl_format) == ISL_FORMAT_UNSUPPORTED) {
flags &= ~VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
flags &= ~VK_FORMAT_FEATURE_BLIT_DST_BIT;
nir_umod(b, nir_load_instance_id(b),
nir_imm_int(b, _mesa_bitcount(state->view_mask)));
- if (util_is_power_of_two(state->view_mask + 1)) {
+ if (util_is_power_of_two_or_zero(state->view_mask + 1)) {
/* If we have a full view mask, then compacted is what we want */
state->view_index = compacted;
} else {
/* We are creating a texture of the size of the region being read back.
* Need to check for NPOT texture support. */
if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) &&
- (!util_is_power_of_two(width) ||
- !util_is_power_of_two(height)))
+ (!util_is_power_of_two_or_zero(width) ||
+ !util_is_power_of_two_or_zero(height)))
return NULL;
/* create the destination texture */
/* Check for NPOT texture support. */
if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) &&
- (!util_is_power_of_two(src_templ.width0) ||
- !util_is_power_of_two(src_templ.height0) ||
- !util_is_power_of_two(src_templ.depth0))) {
+ (!util_is_power_of_two_or_zero(src_templ.width0) ||
+ !util_is_power_of_two_or_zero(src_templ.height0) ||
+ !util_is_power_of_two_or_zero(src_templ.depth0))) {
goto fallback;
}
#include <assert.h>
#include <stdint.h>
+#include <stdbool.h>
#include <string.h>
#if defined(_MSC_VER)
return i;
}
+/* Determine if an unsigned value is a power of two.
+ *
+ * \note
+ * Zero is treated as a power of two.
+ */
+static inline bool
+util_is_power_of_two_or_zero(unsigned v)
+{
+ return (v & (v - 1)) == 0;
+}
+
/* For looping over a bitmask when you want to loop over consecutive bits
* manually, for example:
*
int
u_vector_init(struct u_vector *vector, uint32_t element_size, uint32_t size)
{
- assert(util_is_power_of_two(size));
- assert(element_size < size && util_is_power_of_two(element_size));
+ assert(util_is_power_of_two_or_zero(size));
+ assert(element_size < size && util_is_power_of_two_or_zero(element_size));
vector->head = 0;
vector->tail = 0;
projects / mesa.git / commitdiff