bmi1.h

// SPDX-FileCopyrightText: 2026 Edward Kmett <ekmett@gmail.com>
// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0
#pragma once
#include "native/config.h"
#include "native/attributes.h"
#include "native/isa.h"
#include <bit>
#include <cstdint>
#if NATIVE_HOST_X86
#include <immintrin.h>
 
namespace native::detail {
  template<class U>
  constexpr U bmi1_extract(U value, unsigned start, unsigned length) noexcept {
    constexpr unsigned width = sizeof(U) * 8;
    start &= 255u;
    length &= 255u;
    if (start >= width) return 0;
    auto shifted = U(value >> start);
    return length >= width - start ? shifted : U(shifted & ((U{1} << length) - U{1}));
  }
}
 
namespace native {

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint32_t andn(std::uint32_t first, std::uint32_t second) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return (~first) & second;
    } else {
      return _andn_u32(first, second);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint64_t andn(std::uint64_t first, std::uint64_t second) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return (~first) & second;
    } else {
      return _andn_u64(first, second);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint32_t bextr(std::uint32_t value, std::uint32_t control) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return detail::bmi1_extract(value, control & 255u, (control >> 8) & 255u);
    } else {
      return _bextr2_u32(value, control);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint64_t bextr(std::uint64_t value, std::uint32_t control) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return detail::bmi1_extract(value, control & 255u, (control >> 8) & 255u);
    } else {
      return _bextr2_u64(value, control);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint32_t bextr(std::uint32_t value, unsigned start, unsigned length) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return detail::bmi1_extract(value, start, length);
    } else {
      return _bextr_u32(value, start, length);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint64_t bextr(std::uint64_t value, unsigned start, unsigned length) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return detail::bmi1_extract(value, start, length);
    } else {
      return _bextr_u64(value, start, length);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint32_t blsi(std::uint32_t value) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return value & (std::uint32_t{0} - value);
    } else {
      return _blsi_u32(value);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint64_t blsi(std::uint64_t value) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return value & (std::uint64_t{0} - value);
    } else {
      return _blsi_u64(value);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint32_t blsmsk(std::uint32_t value) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return value ^ (value - std::uint32_t{1});
    } else {
      return _blsmsk_u32(value);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint64_t blsmsk(std::uint64_t value) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return value ^ (value - std::uint64_t{1});
    } else {
      return _blsmsk_u64(value);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint32_t blsr(std::uint32_t value) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return value & (value - std::uint32_t{1});
    } else {
      return _blsr_u32(value);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint64_t blsr(std::uint64_t value) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return value & (value - std::uint64_t{1});
    } else {
      return _blsr_u64(value);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint16_t tzcnt(std::uint16_t value) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return static_cast<std::uint16_t>(std::countr_zero(value));
    } else {
      return _tzcnt_u16(value);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint32_t tzcnt(std::uint32_t value) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return static_cast<std::uint32_t>(std::countr_zero(value));
    } else {
      return _tzcnt_u32(value);
    }
  }

  template<isa<x86> Arch> requires(Arch.has(x86_feature::bmi1))
  native_nodiscard native_inline native_const __attribute__((target("bmi")))
  constexpr std::uint64_t tzcnt(std::uint64_t value) noexcept {
    if (__builtin_is_constant_evaluated()) {
      return static_cast<std::uint64_t>(std::countr_zero(value));
    } else {
      return _tzcnt_u64(value);
    }
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint32_t andn(std::uint32_t first, std::uint32_t second) noexcept {
    return andn<isa<x86>{x86_feature::bmi1}>(first, second);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint64_t andn(std::uint64_t first, std::uint64_t second) noexcept {
    return andn<isa<x86>{x86_feature::bmi1}>(first, second);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint32_t bextr(std::uint32_t value, std::uint32_t control) noexcept {
    return bextr<isa<x86>{x86_feature::bmi1}>(value, control);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint64_t bextr(std::uint64_t value, std::uint32_t control) noexcept {
    return bextr<isa<x86>{x86_feature::bmi1}>(value, control);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint32_t bextr(std::uint32_t value, unsigned start, unsigned length) noexcept {
    return bextr<isa<x86>{x86_feature::bmi1}>(value, start, length);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint64_t bextr(std::uint64_t value, unsigned start, unsigned length) noexcept {
    return bextr<isa<x86>{x86_feature::bmi1}>(value, start, length);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint32_t blsi(std::uint32_t value) noexcept {
    return blsi<isa<x86>{x86_feature::bmi1}>(value);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint64_t blsi(std::uint64_t value) noexcept {
    return blsi<isa<x86>{x86_feature::bmi1}>(value);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint32_t blsmsk(std::uint32_t value) noexcept {
    return blsmsk<isa<x86>{x86_feature::bmi1}>(value);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint64_t blsmsk(std::uint64_t value) noexcept {
    return blsmsk<isa<x86>{x86_feature::bmi1}>(value);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint32_t blsr(std::uint32_t value) noexcept {
    return blsr<isa<x86>{x86_feature::bmi1}>(value);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint64_t blsr(std::uint64_t value) noexcept {
    return blsr<isa<x86>{x86_feature::bmi1}>(value);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint16_t tzcnt(std::uint16_t value) noexcept {
    return tzcnt<isa<x86>{x86_feature::bmi1}>(value);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint32_t tzcnt(std::uint32_t value) noexcept {
    return tzcnt<isa<x86>{x86_feature::bmi1}>(value);
  }

  template<isa<x86> Arch> requires(!Arch.has(x86_feature::bmi1))
  native_nodiscard
  consteval std::uint64_t tzcnt(std::uint64_t value) noexcept {
    return tzcnt<isa<x86>{x86_feature::bmi1}>(value);
  }

}
#endif