╭────────────╮ │next lines →│ ╰────────────╯ ╭ avx512fintrin.h ──────────────────────────────────────────────╮ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ╰───────────────────────────────────────────────────────────────╯
🬂🬂🬒 🬂🬰🬂 🬑🬂🬀 ╭master╮ master xeubie: 🬋 🬋 🬃🬇🬋 │files │ commits refs discuss issues patches new login 🬯🬭🬭 🬭🬰🬭 🬟🬭🬑 ╰──────╯ (15882) user
╭ find file ─ ─ ─ ─ ─ ─ ─ ─ ─ ─╮ ╭────╮ ╭ clone ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╮ │ │ │http│ ssh │ │ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─╯ ╰────╯ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╯
.. llvm_libc_wrappers/ openmp_wrappers/ ppc_wrappers/ __clang_spirv_builtins.h __float_float.h __float_header_macro.h __float_infinity_nan.h __stdarg___gnuc_va_list.h __stdarg___va_copy.h __stdarg_header_macro.h __stdarg_va_arg.h __stdarg_va_copy.h __stdarg_va_list.h __stddef_header_macro.h __stddef_max_align_t.h __stddef_null.h __stddef_nullptr_t.h __stddef_offsetof.h __stddef_ptrdiff_t.h __stddef_rsize_t.h __stddef_size_t.h __stddef_unreachable.h __stddef_wchar_t.h __stddef_wint_t.h __wmmintrin_aes.h __wmmintrin_pclmul.h adcintrin.h adxintrin.h altivec.h ammintrin.h amo.h amxavx512intrin.h amxcomplexintrin.h amxfp16intrin.h amxfp8intrin.h amxintrin.h amxmovrsintrin.h amxtf32intrin.h andes_vector.h arm64intr.h arm_acle.h arm_bf16.h arm_cde.h arm_cmse.h arm_fp16.h arm_mve.h arm_neon.h arm_neon_sve_bridge.h arm_sme.h arm_sve.h arm_vector_types.h armintr.h avx10_2_512bf16intrin.h avx10_2_512convertintrin.h avx10_2_512minmaxintrin.h avx10_2_512niintrin.h avx10_2_512satcvtdsintrin.h avx10_2_512satcvtintrin.h avx10_2bf16intrin.h avx10_2convertintrin.h avx10_2copyintrin.h avx10_2minmaxintrin.h avx10_2niintrin.h avx10_2satcvtdsintrin.h avx10_2satcvtintrin.h avx2intrin.h avx512bf16intrin.h avx512bitalgintrin.h avx512bwintrin.h avx512cdintrin.h avx512dqintrin.h ╭─────────────────────────────────╮ │avx512fintrin.h │ ╰─────────────────────────────────╯ avx512fp16intrin.h avx512ifmaintrin.h avx512ifmavlintrin.h avx512vbmi2intrin.h avx512vbmiintrin.h avx512vbmivlintrin.h avx512vlbf16intrin.h avx512vlbitalgintrin.h avx512vlbwintrin.h avx512vlcdintrin.h avx512vldqintrin.h avx512vlfp16intrin.h avx512vlintrin.h avx512vlvbmi2intrin.h avx512vlvnniintrin.h avx512vlvp2intersectintrin.h avx512vnniintrin.h avx512vp2intersectintrin.h avx512vpopcntdqintrin.h avx512vpopcntdqvlintrin.h avxifmaintrin.h avxintrin.h avxneconvertintrin.h avxvnniint16intrin.h avxvnniint8intrin.h avxvnniintrin.h bmi2intrin.h bmiintrin.h builtins.h cet.h cetintrin.h cldemoteintrin.h clflushoptintrin.h clwbintrin.h clzerointrin.h cmpccxaddintrin.h cpuid.h crc32intrin.h emmintrin.h enqcmdintrin.h f16cintrin.h float.h fma4intrin.h fmaintrin.h fxsrintrin.h gfniintrin.h hexagon_circ_brev_intrinsics.h hexagon_protos.h hexagon_types.h hresetintrin.h htmintrin.h htmxlintrin.h hvx_hexagon_protos.h ia32intrin.h immintrin.h intrin.h intrin0.h inttypes.h invpcidintrin.h iso646.h keylockerintrin.h larchintrin.h lasxintrin.h limits.h lsxintrin.h lwpintrin.h lzcntintrin.h mm3dnow.h mm_malloc.h mmintrin.h module.modulemap movdirintrin.h movrs_avx10_2_512intrin.h movrs_avx10_2intrin.h movrsintrin.h msa.h mwaitxintrin.h nmmintrin.h pconfigintrin.h pkuintrin.h pmmintrin.h popcntintrin.h prfchiintrin.h prfchwintrin.h ptrauth.h ptwriteintrin.h raointintrin.h rdpruintrin.h rdseedintrin.h riscv_bitmanip.h riscv_corev_alu.h riscv_crypto.h riscv_mips.h riscv_nds.h riscv_ntlh.h riscv_vector.h rtmintrin.h s390intrin.h serializeintrin.h sgxintrin.h sha512intrin.h shaintrin.h sifive_vector.h sm3intrin.h sm4evexintrin.h sm4intrin.h smmintrin.h spirvintrin.h stdalign.h stdarg.h stdatomic.h stdbool.h stdckdint.h stdcountof.h stddef.h stddefer.h stdint.h stdnoreturn.h tbmintrin.h tgmath.h tmmintrin.h tsxldtrkintrin.h uintrintrin.h unwind.h usermsrintrin.h vadefs.h vaesintrin.h varargs.h vecintrin.h velintrin.h velintrin_approx.h velintrin_gen.h vpclmulqdqintrin.h waitpkgintrin.h wasm_simd128.h wbnoinvdintrin.h wmmintrin.h x86gprintrin.h x86intrin.h xmmintrin.h xopintrin.h xsavecintrin.h xsaveintrin.h xsaveoptintrin.h xsavesintrin.h xtestintrin.h yvals_core.h
1 /*===---- avx512fintrin.h - AVX512F intrinsics -----------------------------=== 2 * 3 * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 * See https://llvm.org/LICENSE.txt for license information. 5 * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 * 7 *===-----------------------------------------------------------------------=== 8 */ 9 #ifndef __IMMINTRIN_H 10 #error "Never use <avx512fintrin.h> directly; include <immintrin.h> instead." 11 #endif 12 13 #ifndef __AVX512FINTRIN_H 14 #define __AVX512FINTRIN_H 15 16 typedef char __v64qi __attribute__((__vector_size__(64))); 17 typedef short __v32hi __attribute__((__vector_size__(64))); 18 typedef double __v8df __attribute__((__vector_size__(64))); 19 typedef float __v16sf __attribute__((__vector_size__(64))); 20 typedef long long __v8di __attribute__((__vector_size__(64))); 21 typedef int __v16si __attribute__((__vector_size__(64))); 22 23 /* Unsigned types */ 24 typedef unsigned char __v64qu __attribute__((__vector_size__(64))); 25 typedef unsigned short __v32hu __attribute__((__vector_size__(64))); 26 typedef unsigned long long __v8du __attribute__((__vector_size__(64))); 27 typedef unsigned int __v16su __attribute__((__vector_size__(64))); 28 29 /* We need an explicitly signed variant for char. Note that this shouldn't 30 * appear in the interface though. */ 31 typedef signed char __v64qs __attribute__((__vector_size__(64))); 32 33 typedef float __m512 __attribute__((__vector_size__(64), __aligned__(64))); 34 typedef double __m512d __attribute__((__vector_size__(64), __aligned__(64))); 35 typedef long long __m512i __attribute__((__vector_size__(64), __aligned__(64))); 36 37 typedef float __m512_u __attribute__((__vector_size__(64), __aligned__(1))); 38 typedef double __m512d_u __attribute__((__vector_size__(64), __aligned__(1))); 39 typedef long long __m512i_u __attribute__((__vector_size__(64), __aligned__(1))); 40 41 typedef unsigned char __mmask8; 42 typedef unsigned short __mmask16; 43 44 /* Rounding mode macros. */ 45 #define _MM_FROUND_TO_NEAREST_INT 0x00 46 #define _MM_FROUND_TO_NEG_INF 0x01 47 #define _MM_FROUND_TO_POS_INF 0x02 48 #define _MM_FROUND_TO_ZERO 0x03 49 #define _MM_FROUND_CUR_DIRECTION 0x04 50 51 /* Constants for integer comparison predicates */ 52 typedef enum { 53 _MM_CMPINT_EQ, /* Equal */ 54 _MM_CMPINT_LT, /* Less than */ 55 _MM_CMPINT_LE, /* Less than or Equal */ 56 _MM_CMPINT_UNUSED, 57 _MM_CMPINT_NE, /* Not Equal */ 58 _MM_CMPINT_NLT, /* Not Less than */ 59 #define _MM_CMPINT_GE _MM_CMPINT_NLT /* Greater than or Equal */ 60 _MM_CMPINT_NLE /* Not Less than or Equal */ 61 #define _MM_CMPINT_GT _MM_CMPINT_NLE /* Greater than */ 62 } _MM_CMPINT_ENUM; 63 64 typedef enum 65 { 66 _MM_PERM_AAAA = 0x00, _MM_PERM_AAAB = 0x01, _MM_PERM_AAAC = 0x02, 67 _MM_PERM_AAAD = 0x03, _MM_PERM_AABA = 0x04, _MM_PERM_AABB = 0x05, 68 _MM_PERM_AABC = 0x06, _MM_PERM_AABD = 0x07, _MM_PERM_AACA = 0x08, 69 _MM_PERM_AACB = 0x09, _MM_PERM_AACC = 0x0A, _MM_PERM_AACD = 0x0B, 70 _MM_PERM_AADA = 0x0C, _MM_PERM_AADB = 0x0D, _MM_PERM_AADC = 0x0E, 71 _MM_PERM_AADD = 0x0F, _MM_PERM_ABAA = 0x10, _MM_PERM_ABAB = 0x11, 72 _MM_PERM_ABAC = 0x12, _MM_PERM_ABAD = 0x13, _MM_PERM_ABBA = 0x14, 73 _MM_PERM_ABBB = 0x15, _MM_PERM_ABBC = 0x16, _MM_PERM_ABBD = 0x17, 74 _MM_PERM_ABCA = 0x18, _MM_PERM_ABCB = 0x19, _MM_PERM_ABCC = 0x1A, 75 _MM_PERM_ABCD = 0x1B, _MM_PERM_ABDA = 0x1C, _MM_PERM_ABDB = 0x1D, 76 _MM_PERM_ABDC = 0x1E, _MM_PERM_ABDD = 0x1F, _MM_PERM_ACAA = 0x20, 77 _MM_PERM_ACAB = 0x21, _MM_PERM_ACAC = 0x22, _MM_PERM_ACAD = 0x23, 78 _MM_PERM_ACBA = 0x24, _MM_PERM_ACBB = 0x25, _MM_PERM_ACBC = 0x26, 79 _MM_PERM_ACBD = 0x27, _MM_PERM_ACCA = 0x28, _MM_PERM_ACCB = 0x29, 80 _MM_PERM_ACCC = 0x2A, _MM_PERM_ACCD = 0x2B, _MM_PERM_ACDA = 0x2C, 81 _MM_PERM_ACDB = 0x2D, _MM_PERM_ACDC = 0x2E, _MM_PERM_ACDD = 0x2F, 82 _MM_PERM_ADAA = 0x30, _MM_PERM_ADAB = 0x31, _MM_PERM_ADAC = 0x32, 83 _MM_PERM_ADAD = 0x33, _MM_PERM_ADBA = 0x34, _MM_PERM_ADBB = 0x35, 84 _MM_PERM_ADBC = 0x36, _MM_PERM_ADBD = 0x37, _MM_PERM_ADCA = 0x38, 85 _MM_PERM_ADCB = 0x39, _MM_PERM_ADCC = 0x3A, _MM_PERM_ADCD = 0x3B, 86 _MM_PERM_ADDA = 0x3C, _MM_PERM_ADDB = 0x3D, _MM_PERM_ADDC = 0x3E, 87 _MM_PERM_ADDD = 0x3F, _MM_PERM_BAAA = 0x40, _MM_PERM_BAAB = 0x41, 88 _MM_PERM_BAAC = 0x42, _MM_PERM_BAAD = 0x43, _MM_PERM_BABA = 0x44, 89 _MM_PERM_BABB = 0x45, _MM_PERM_BABC = 0x46, _MM_PERM_BABD = 0x47, 90 _MM_PERM_BACA = 0x48, _MM_PERM_BACB = 0x49, _MM_PERM_BACC = 0x4A, 91 _MM_PERM_BACD = 0x4B, _MM_PERM_BADA = 0x4C, _MM_PERM_BADB = 0x4D, 92 _MM_PERM_BADC = 0x4E, _MM_PERM_BADD = 0x4F, _MM_PERM_BBAA = 0x50, 93 _MM_PERM_BBAB = 0x51, _MM_PERM_BBAC = 0x52, _MM_PERM_BBAD = 0x53, 94 _MM_PERM_BBBA = 0x54, _MM_PERM_BBBB = 0x55, _MM_PERM_BBBC = 0x56, 95 _MM_PERM_BBBD = 0x57, _MM_PERM_BBCA = 0x58, _MM_PERM_BBCB = 0x59, 96 _MM_PERM_BBCC = 0x5A, _MM_PERM_BBCD = 0x5B, _MM_PERM_BBDA = 0x5C, 97 _MM_PERM_BBDB = 0x5D, _MM_PERM_BBDC = 0x5E, _MM_PERM_BBDD = 0x5F, 98 _MM_PERM_BCAA = 0x60, _MM_PERM_BCAB = 0x61, _MM_PERM_BCAC = 0x62, 99 _MM_PERM_BCAD = 0x63, _MM_PERM_BCBA = 0x64, _MM_PERM_BCBB = 0x65, 100 _MM_PERM_BCBC = 0x66, _MM_PERM_BCBD = 0x67, _MM_PERM_BCCA = 0x68, 101 _MM_PERM_BCCB = 0x69, _MM_PERM_BCCC = 0x6A, _MM_PERM_BCCD = 0x6B, 102 _MM_PERM_BCDA = 0x6C, _MM_PERM_BCDB = 0x6D, _MM_PERM_BCDC = 0x6E, 103 _MM_PERM_BCDD = 0x6F, _MM_PERM_BDAA = 0x70, _MM_PERM_BDAB = 0x71, 104 _MM_PERM_BDAC = 0x72, _MM_PERM_BDAD = 0x73, _MM_PERM_BDBA = 0x74, 105 _MM_PERM_BDBB = 0x75, _MM_PERM_BDBC = 0x76, _MM_PERM_BDBD = 0x77, 106 _MM_PERM_BDCA = 0x78, _MM_PERM_BDCB = 0x79, _MM_PERM_BDCC = 0x7A, 107 _MM_PERM_BDCD = 0x7B, _MM_PERM_BDDA = 0x7C, _MM_PERM_BDDB = 0x7D, 108 _MM_PERM_BDDC = 0x7E, _MM_PERM_BDDD = 0x7F, _MM_PERM_CAAA = 0x80, 109 _MM_PERM_CAAB = 0x81, _MM_PERM_CAAC = 0x82, _MM_PERM_CAAD = 0x83, 110 _MM_PERM_CABA = 0x84, _MM_PERM_CABB = 0x85, _MM_PERM_CABC = 0x86, 111 _MM_PERM_CABD = 0x87, _MM_PERM_CACA = 0x88, _MM_PERM_CACB = 0x89, 112 _MM_PERM_CACC = 0x8A, _MM_PERM_CACD = 0x8B, _MM_PERM_CADA = 0x8C, 113 _MM_PERM_CADB = 0x8D, _MM_PERM_CADC = 0x8E, _MM_PERM_CADD = 0x8F, 114 _MM_PERM_CBAA = 0x90, _MM_PERM_CBAB = 0x91, _MM_PERM_CBAC = 0x92, 115 _MM_PERM_CBAD = 0x93, _MM_PERM_CBBA = 0x94, _MM_PERM_CBBB = 0x95, 116 _MM_PERM_CBBC = 0x96, _MM_PERM_CBBD = 0x97, _MM_PERM_CBCA = 0x98, 117 _MM_PERM_CBCB = 0x99, _MM_PERM_CBCC = 0x9A, _MM_PERM_CBCD = 0x9B, 118 _MM_PERM_CBDA = 0x9C, _MM_PERM_CBDB = 0x9D, _MM_PERM_CBDC = 0x9E, 119 _MM_PERM_CBDD = 0x9F, _MM_PERM_CCAA = 0xA0, _MM_PERM_CCAB = 0xA1, 120 _MM_PERM_CCAC = 0xA2, _MM_PERM_CCAD = 0xA3, _MM_PERM_CCBA = 0xA4, 121 _MM_PERM_CCBB = 0xA5, _MM_PERM_CCBC = 0xA6, _MM_PERM_CCBD = 0xA7, 122 _MM_PERM_CCCA = 0xA8, _MM_PERM_CCCB = 0xA9, _MM_PERM_CCCC = 0xAA, 123 _MM_PERM_CCCD = 0xAB, _MM_PERM_CCDA = 0xAC, _MM_PERM_CCDB = 0xAD, 124 _MM_PERM_CCDC = 0xAE, _MM_PERM_CCDD = 0xAF, _MM_PERM_CDAA = 0xB0, 125 _MM_PERM_CDAB = 0xB1, _MM_PERM_CDAC = 0xB2, _MM_PERM_CDAD = 0xB3, 126 _MM_PERM_CDBA = 0xB4, _MM_PERM_CDBB = 0xB5, _MM_PERM_CDBC = 0xB6, 127 _MM_PERM_CDBD = 0xB7, _MM_PERM_CDCA = 0xB8, _MM_PERM_CDCB = 0xB9, 128 _MM_PERM_CDCC = 0xBA, _MM_PERM_CDCD = 0xBB, _MM_PERM_CDDA = 0xBC, 129 _MM_PERM_CDDB = 0xBD, _MM_PERM_CDDC = 0xBE, _MM_PERM_CDDD = 0xBF, 130 _MM_PERM_DAAA = 0xC0, _MM_PERM_DAAB = 0xC1, _MM_PERM_DAAC = 0xC2, 131 _MM_PERM_DAAD = 0xC3, _MM_PERM_DABA = 0xC4, _MM_PERM_DABB = 0xC5, 132 _MM_PERM_DABC = 0xC6, _MM_PERM_DABD = 0xC7, _MM_PERM_DACA = 0xC8, 133 _MM_PERM_DACB = 0xC9, _MM_PERM_DACC = 0xCA, _MM_PERM_DACD = 0xCB, 134 _MM_PERM_DADA = 0xCC, _MM_PERM_DADB = 0xCD, _MM_PERM_DADC = 0xCE, 135 _MM_PERM_DADD = 0xCF, _MM_PERM_DBAA = 0xD0, _MM_PERM_DBAB = 0xD1, 136 _MM_PERM_DBAC = 0xD2, _MM_PERM_DBAD = 0xD3, _MM_PERM_DBBA = 0xD4, 137 _MM_PERM_DBBB = 0xD5, _MM_PERM_DBBC = 0xD6, _MM_PERM_DBBD = 0xD7, 138 _MM_PERM_DBCA = 0xD8, _MM_PERM_DBCB = 0xD9, _MM_PERM_DBCC = 0xDA, 139 _MM_PERM_DBCD = 0xDB, _MM_PERM_DBDA = 0xDC, _MM_PERM_DBDB = 0xDD, 140 _MM_PERM_DBDC = 0xDE, _MM_PERM_DBDD = 0xDF, _MM_PERM_DCAA = 0xE0, 141 _MM_PERM_DCAB = 0xE1, _MM_PERM_DCAC = 0xE2, _MM_PERM_DCAD = 0xE3, 142 _MM_PERM_DCBA = 0xE4, _MM_PERM_DCBB = 0xE5, _MM_PERM_DCBC = 0xE6, 143 _MM_PERM_DCBD = 0xE7, _MM_PERM_DCCA = 0xE8, _MM_PERM_DCCB = 0xE9, 144 _MM_PERM_DCCC = 0xEA, _MM_PERM_DCCD = 0xEB, _MM_PERM_DCDA = 0xEC, 145 _MM_PERM_DCDB = 0xED, _MM_PERM_DCDC = 0xEE, _MM_PERM_DCDD = 0xEF, 146 _MM_PERM_DDAA = 0xF0, _MM_PERM_DDAB = 0xF1, _MM_PERM_DDAC = 0xF2, 147 _MM_PERM_DDAD = 0xF3, _MM_PERM_DDBA = 0xF4, _MM_PERM_DDBB = 0xF5, 148 _MM_PERM_DDBC = 0xF6, _MM_PERM_DDBD = 0xF7, _MM_PERM_DDCA = 0xF8, 149 _MM_PERM_DDCB = 0xF9, _MM_PERM_DDCC = 0xFA, _MM_PERM_DDCD = 0xFB, 150 _MM_PERM_DDDA = 0xFC, _MM_PERM_DDDB = 0xFD, _MM_PERM_DDDC = 0xFE, 151 _MM_PERM_DDDD = 0xFF 152 } _MM_PERM_ENUM; 153 154 typedef enum 155 { 156 _MM_MANT_NORM_1_2, /* interval [1, 2) */ 157 _MM_MANT_NORM_p5_2, /* interval [0.5, 2) */ 158 _MM_MANT_NORM_p5_1, /* interval [0.5, 1) */ 159 _MM_MANT_NORM_p75_1p5 /* interval [0.75, 1.5) */ 160 } _MM_MANTISSA_NORM_ENUM; 161 162 typedef enum 163 { 164 _MM_MANT_SIGN_src, /* sign = sign(SRC) */ 165 _MM_MANT_SIGN_zero, /* sign = 0 */ 166 _MM_MANT_SIGN_nan /* DEST = NaN if sign(SRC) = 1 */ 167 } _MM_MANTISSA_SIGN_ENUM; 168 169 /* Define the default attributes for the functions in this file. */ 170 #define __DEFAULT_FN_ATTRS512 \ 171 __attribute__((__always_inline__, __nodebug__, __target__("avx512f"), \ 172 __min_vector_width__(512))) 173 #define __DEFAULT_FN_ATTRS128 \ 174 __attribute__((__always_inline__, __nodebug__, __target__("avx512f"), \ 175 __min_vector_width__(128))) 176 #define __DEFAULT_FN_ATTRS \ 177 __attribute__((__always_inline__, __nodebug__, __target__("avx512f"))) 178 179 #if defined(__cplusplus) && (__cplusplus >= 201103L) 180 #define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS constexpr 181 #define __DEFAULT_FN_ATTRS512_CONSTEXPR __DEFAULT_FN_ATTRS512 constexpr 182 #define __DEFAULT_FN_ATTRS128_CONSTEXPR __DEFAULT_FN_ATTRS128 constexpr 183 #else 184 #define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS 185 #define __DEFAULT_FN_ATTRS512_CONSTEXPR __DEFAULT_FN_ATTRS512 186 #define __DEFAULT_FN_ATTRS128_CONSTEXPR __DEFAULT_FN_ATTRS128 187 #endif 188 189 /* Create vectors with repeated elements */ 190 191 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 192 _mm512_setzero_si512(void) { 193 return __extension__(__m512i)(__v8di){0, 0, 0, 0, 0, 0, 0, 0}; 194 } 195 196 #define _mm512_setzero_epi32 _mm512_setzero_si512 197 198 static __inline__ __m512d __DEFAULT_FN_ATTRS512 199 _mm512_undefined_pd(void) 200 { 201 return (__m512d)__builtin_ia32_undef512(); 202 } 203 204 static __inline__ __m512 __DEFAULT_FN_ATTRS512 205 _mm512_undefined(void) 206 { 207 return (__m512)__builtin_ia32_undef512(); 208 } 209 210 static __inline__ __m512 __DEFAULT_FN_ATTRS512 _mm512_undefined_ps(void) { 211 return (__m512)__builtin_ia32_undef512(); 212 } 213 214 static __inline__ __m512i __DEFAULT_FN_ATTRS512 215 _mm512_undefined_epi32(void) 216 { 217 return (__m512i)__builtin_ia32_undef512(); 218 } 219 220 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 221 _mm512_broadcastd_epi32(__m128i __A) { 222 return (__m512i)__builtin_shufflevector((__v4si) __A, (__v4si) __A, 223 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); 224 } 225 226 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 227 _mm512_mask_broadcastd_epi32(__m512i __O, __mmask16 __M, __m128i __A) { 228 return (__m512i)__builtin_ia32_selectd_512(__M, 229 (__v16si) _mm512_broadcastd_epi32(__A), 230 (__v16si) __O); 231 } 232 233 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 234 _mm512_maskz_broadcastd_epi32(__mmask16 __M, __m128i __A) { 235 return (__m512i)__builtin_ia32_selectd_512(__M, 236 (__v16si) _mm512_broadcastd_epi32(__A), 237 (__v16si) _mm512_setzero_si512()); 238 } 239 240 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 241 _mm512_broadcastq_epi64(__m128i __A) { 242 return (__m512i)__builtin_shufflevector((__v2di) __A, (__v2di) __A, 243 0, 0, 0, 0, 0, 0, 0, 0); 244 } 245 246 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 247 _mm512_mask_broadcastq_epi64(__m512i __O, __mmask8 __M, __m128i __A) { 248 return (__m512i)__builtin_ia32_selectq_512( 249 __M, (__v8di)_mm512_broadcastq_epi64(__A), (__v8di)__O); 250 } 251 252 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 253 _mm512_maskz_broadcastq_epi64(__mmask8 __M, __m128i __A) { 254 return (__m512i)__builtin_ia32_selectq_512(__M, 255 (__v8di) _mm512_broadcastq_epi64(__A), 256 (__v8di) _mm512_setzero_si512()); 257 } 258 259 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_setzero_ps(void) { 260 return __extension__(__m512){0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 261 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}; 262 } 263 264 #define _mm512_setzero _mm512_setzero_ps 265 266 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 267 _mm512_setzero_pd(void) { 268 return __extension__(__m512d){0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}; 269 } 270 271 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 272 _mm512_set1_ps(float __w) 273 { 274 return __extension__ (__m512){ __w, __w, __w, __w, __w, __w, __w, __w, 275 __w, __w, __w, __w, __w, __w, __w, __w }; 276 } 277 278 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 279 _mm512_set1_pd(double __w) 280 { 281 return __extension__ (__m512d){ __w, __w, __w, __w, __w, __w, __w, __w }; 282 } 283 284 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 285 _mm512_set1_epi8(char __w) 286 { 287 return __extension__ (__m512i)(__v64qi){ 288 __w, __w, __w, __w, __w, __w, __w, __w, 289 __w, __w, __w, __w, __w, __w, __w, __w, 290 __w, __w, __w, __w, __w, __w, __w, __w, 291 __w, __w, __w, __w, __w, __w, __w, __w, 292 __w, __w, __w, __w, __w, __w, __w, __w, 293 __w, __w, __w, __w, __w, __w, __w, __w, 294 __w, __w, __w, __w, __w, __w, __w, __w, 295 __w, __w, __w, __w, __w, __w, __w, __w }; 296 } 297 298 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 299 _mm512_set1_epi16(short __w) 300 { 301 return __extension__ (__m512i)(__v32hi){ 302 __w, __w, __w, __w, __w, __w, __w, __w, 303 __w, __w, __w, __w, __w, __w, __w, __w, 304 __w, __w, __w, __w, __w, __w, __w, __w, 305 __w, __w, __w, __w, __w, __w, __w, __w }; 306 } 307 308 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 309 _mm512_set1_epi32(int __s) 310 { 311 return __extension__ (__m512i)(__v16si){ 312 __s, __s, __s, __s, __s, __s, __s, __s, 313 __s, __s, __s, __s, __s, __s, __s, __s }; 314 } 315 316 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 317 _mm512_maskz_set1_epi32(__mmask16 __M, int __A) { 318 return (__m512i)__builtin_ia32_selectd_512(__M, 319 (__v16si)_mm512_set1_epi32(__A), 320 (__v16si)_mm512_setzero_si512()); 321 } 322 323 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 324 _mm512_set1_epi64(long long __d) 325 { 326 return __extension__(__m512i)(__v8di){ __d, __d, __d, __d, __d, __d, __d, __d }; 327 } 328 329 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 330 _mm512_maskz_set1_epi64(__mmask8 __M, long long __A) { 331 return (__m512i)__builtin_ia32_selectq_512(__M, 332 (__v8di)_mm512_set1_epi64(__A), 333 (__v8di)_mm512_setzero_si512()); 334 } 335 336 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 337 _mm512_broadcastss_ps(__m128 __A) { 338 return (__m512)__builtin_shufflevector((__v4sf) __A, (__v4sf) __A, 339 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); 340 } 341 342 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 343 _mm512_set4_epi32(int __A, int __B, int __C, int __D) { 344 return __extension__ (__m512i)(__v16si) 345 { __D, __C, __B, __A, __D, __C, __B, __A, 346 __D, __C, __B, __A, __D, __C, __B, __A }; 347 } 348 349 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 350 _mm512_set4_epi64(long long __A, long long __B, long long __C, long long __D) { 351 return __extension__ (__m512i) (__v8di) 352 { __D, __C, __B, __A, __D, __C, __B, __A }; 353 } 354 355 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 356 _mm512_set4_pd(double __A, double __B, double __C, double __D) { 357 return __extension__ (__m512d) 358 { __D, __C, __B, __A, __D, __C, __B, __A }; 359 } 360 361 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 362 _mm512_set4_ps(float __A, float __B, float __C, float __D) { 363 return __extension__ (__m512) 364 { __D, __C, __B, __A, __D, __C, __B, __A, 365 __D, __C, __B, __A, __D, __C, __B, __A }; 366 } 367 368 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 369 _mm512_setr4_epi32(int e0, int e1, int e2, int e3) { 370 return _mm512_set4_epi32(e3, e2, e1, e0); 371 } 372 373 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 374 _mm512_setr4_epi64(long long e0, long long e1, long long e2, long long e3) { 375 return _mm512_set4_epi64(e3, e2, e1, e0); 376 } 377 378 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 379 _mm512_setr4_pd(double e0, double e1, double e2, double e3) { 380 return _mm512_set4_pd(e3, e2, e1, e0); 381 } 382 383 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 384 _mm512_setr4_ps(float e0, float e1, float e2, float e3) { 385 return _mm512_set4_ps(e3, e2, e1, e0); 386 } 387 388 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 389 _mm512_broadcastsd_pd(__m128d __A) { 390 return (__m512d)__builtin_shufflevector((__v2df) __A, (__v2df) __A, 391 0, 0, 0, 0, 0, 0, 0, 0); 392 } 393 394 /* Cast between vector types */ 395 396 static __inline __m512d __DEFAULT_FN_ATTRS512 397 _mm512_castpd256_pd512(__m256d __a) 398 { 399 return __builtin_shufflevector(__a, __builtin_nondeterministic_value(__a), 0, 400 1, 2, 3, 4, 5, 6, 7); 401 } 402 403 static __inline __m512 __DEFAULT_FN_ATTRS512 404 _mm512_castps256_ps512(__m256 __a) 405 { 406 return __builtin_shufflevector(__a, __builtin_nondeterministic_value(__a), 0, 407 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); 408 } 409 410 static __inline __m128d __DEFAULT_FN_ATTRS512_CONSTEXPR 411 _mm512_castpd512_pd128(__m512d __a) 412 { 413 return __builtin_shufflevector(__a, __a, 0, 1); 414 } 415 416 static __inline __m256d __DEFAULT_FN_ATTRS512_CONSTEXPR 417 _mm512_castpd512_pd256 (__m512d __A) 418 { 419 return __builtin_shufflevector(__A, __A, 0, 1, 2, 3); 420 } 421 422 static __inline __m128 __DEFAULT_FN_ATTRS512_CONSTEXPR 423 _mm512_castps512_ps128(__m512 __a) 424 { 425 return __builtin_shufflevector(__a, __a, 0, 1, 2, 3); 426 } 427 428 static __inline __m256 __DEFAULT_FN_ATTRS512_CONSTEXPR 429 _mm512_castps512_ps256(__m512 __A) { 430 return __builtin_shufflevector(__A, __A, 0, 1, 2, 3, 4, 5, 6, 7); 431 } 432 433 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 434 _mm512_castpd_ps (__m512d __A) 435 { 436 return (__m512) (__A); 437 } 438 439 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 440 _mm512_castpd_si512 (__m512d __A) 441 { 442 return (__m512i) (__A); 443 } 444 445 static __inline__ __m512d __DEFAULT_FN_ATTRS512 446 _mm512_castpd128_pd512 (__m128d __A) 447 { 448 __m256d __B = __builtin_nondeterministic_value(__B); 449 return __builtin_shufflevector( 450 __builtin_shufflevector(__A, __builtin_nondeterministic_value(__A), 0, 1, 2, 3), 451 __B, 0, 1, 2, 3, 4, 5, 6, 7); 452 } 453 454 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 455 _mm512_castps_pd (__m512 __A) 456 { 457 return (__m512d) (__A); 458 } 459 460 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 461 _mm512_castps_si512 (__m512 __A) 462 { 463 return (__m512i) (__A); 464 } 465 466 static __inline__ __m512 __DEFAULT_FN_ATTRS512 467 _mm512_castps128_ps512 (__m128 __A) 468 { 469 __m256 __B = __builtin_nondeterministic_value(__B); 470 return __builtin_shufflevector( 471 __builtin_shufflevector(__A, __builtin_nondeterministic_value(__A), 0, 1, 2, 3, 4, 5, 6, 7), 472 __B, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); 473 } 474 475 static __inline__ __m512i __DEFAULT_FN_ATTRS512 476 _mm512_castsi128_si512 (__m128i __A) 477 { 478 __m256i __B = __builtin_nondeterministic_value(__B); 479 return __builtin_shufflevector( 480 __builtin_shufflevector(__A, __builtin_nondeterministic_value(__A), 0, 1, 2, 3), 481 __B, 0, 1, 2, 3, 4, 5, 6, 7); 482 } 483 484 static __inline__ __m512i __DEFAULT_FN_ATTRS512 485 _mm512_castsi256_si512 (__m256i __A) 486 { 487 return __builtin_shufflevector( __A, __builtin_nondeterministic_value(__A), 0, 1, 2, 3, 4, 5, 6, 7); 488 } 489 490 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 491 _mm512_castsi512_ps (__m512i __A) 492 { 493 return (__m512) (__A); 494 } 495 496 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 497 _mm512_castsi512_pd (__m512i __A) 498 { 499 return (__m512d) (__A); 500 } 501 502 static __inline __m128i __DEFAULT_FN_ATTRS512_CONSTEXPR 503 _mm512_castsi512_si128 (__m512i __A) 504 { 505 return (__m128i)__builtin_shufflevector(__A, __A , 0, 1); 506 } 507 508 static __inline __m256i __DEFAULT_FN_ATTRS512_CONSTEXPR 509 _mm512_castsi512_si256(__m512i __A) { 510 return (__m256i)__builtin_shufflevector(__A, __A , 0, 1, 2, 3); 511 } 512 513 static __inline__ __mmask16 __DEFAULT_FN_ATTRS_CONSTEXPR 514 _mm512_int2mask(int __a) { 515 return (__mmask16)__a; 516 } 517 518 static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR 519 _mm512_mask2int(__mmask16 __a) { 520 return (int)__a; 521 } 522 523 /// Constructs a 512-bit floating-point vector of [8 x double] from a 524 /// 128-bit floating-point vector of [2 x double]. The lower 128 bits 525 /// contain the value of the source vector. The upper 384 bits are set 526 /// to zero. 527 /// 528 /// \headerfile <x86intrin.h> 529 /// 530 /// This intrinsic has no corresponding instruction. 531 /// 532 /// \param __a 533 /// A 128-bit vector of [2 x double]. 534 /// \returns A 512-bit floating-point vector of [8 x double]. The lower 128 bits 535 /// contain the value of the parameter. The upper 384 bits are set to zero. 536 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 537 _mm512_zextpd128_pd512(__m128d __a) { 538 return __builtin_shufflevector((__v2df)__a, (__v2df)_mm_setzero_pd(), 0, 1, 2, 3, 2, 3, 2, 3); 539 } 540 541 /// Constructs a 512-bit floating-point vector of [8 x double] from a 542 /// 256-bit floating-point vector of [4 x double]. The lower 256 bits 543 /// contain the value of the source vector. The upper 256 bits are set 544 /// to zero. 545 /// 546 /// \headerfile <x86intrin.h> 547 /// 548 /// This intrinsic has no corresponding instruction. 549 /// 550 /// \param __a 551 /// A 256-bit vector of [4 x double]. 552 /// \returns A 512-bit floating-point vector of [8 x double]. The lower 256 bits 553 /// contain the value of the parameter. The upper 256 bits are set to zero. 554 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 555 _mm512_zextpd256_pd512(__m256d __a) { 556 return __builtin_shufflevector((__v4df)__a, (__v4df)_mm256_setzero_pd(), 0, 1, 2, 3, 4, 5, 6, 7); 557 } 558 559 /// Constructs a 512-bit floating-point vector of [16 x float] from a 560 /// 128-bit floating-point vector of [4 x float]. The lower 128 bits contain 561 /// the value of the source vector. The upper 384 bits are set to zero. 562 /// 563 /// \headerfile <x86intrin.h> 564 /// 565 /// This intrinsic has no corresponding instruction. 566 /// 567 /// \param __a 568 /// A 128-bit vector of [4 x float]. 569 /// \returns A 512-bit floating-point vector of [16 x float]. The lower 128 bits 570 /// contain the value of the parameter. The upper 384 bits are set to zero. 571 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 572 _mm512_zextps128_ps512(__m128 __a) { 573 return __builtin_shufflevector((__v4sf)__a, (__v4sf)_mm_setzero_ps(), 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7); 574 } 575 576 /// Constructs a 512-bit floating-point vector of [16 x float] from a 577 /// 256-bit floating-point vector of [8 x float]. The lower 256 bits contain 578 /// the value of the source vector. The upper 256 bits are set to zero. 579 /// 580 /// \headerfile <x86intrin.h> 581 /// 582 /// This intrinsic has no corresponding instruction. 583 /// 584 /// \param __a 585 /// A 256-bit vector of [8 x float]. 586 /// \returns A 512-bit floating-point vector of [16 x float]. The lower 256 bits 587 /// contain the value of the parameter. The upper 256 bits are set to zero. 588 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 589 _mm512_zextps256_ps512(__m256 __a) { 590 return __builtin_shufflevector((__v8sf)__a, (__v8sf)_mm256_setzero_ps(), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); 591 } 592 593 /// Constructs a 512-bit integer vector from a 128-bit integer vector. 594 /// The lower 128 bits contain the value of the source vector. The upper 595 /// 384 bits are set to zero. 596 /// 597 /// \headerfile <x86intrin.h> 598 /// 599 /// This intrinsic has no corresponding instruction. 600 /// 601 /// \param __a 602 /// A 128-bit integer vector. 603 /// \returns A 512-bit integer vector. The lower 128 bits contain the value of 604 /// the parameter. The upper 384 bits are set to zero. 605 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 606 _mm512_zextsi128_si512(__m128i __a) { 607 return __builtin_shufflevector((__v2di)__a, (__v2di)_mm_setzero_si128(), 0, 1, 2, 3, 2, 3, 2, 3); 608 } 609 610 /// Constructs a 512-bit integer vector from a 256-bit integer vector. 611 /// The lower 256 bits contain the value of the source vector. The upper 612 /// 256 bits are set to zero. 613 /// 614 /// \headerfile <x86intrin.h> 615 /// 616 /// This intrinsic has no corresponding instruction. 617 /// 618 /// \param __a 619 /// A 256-bit integer vector. 620 /// \returns A 512-bit integer vector. The lower 256 bits contain the value of 621 /// the parameter. The upper 256 bits are set to zero. 622 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 623 _mm512_zextsi256_si512(__m256i __a) { 624 return __builtin_shufflevector((__v4di)__a, (__v4di)_mm256_setzero_si256(), 0, 1, 2, 3, 4, 5, 6, 7); 625 } 626 627 /* Bitwise operators */ 628 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 629 _mm512_and_epi32(__m512i __a, __m512i __b) 630 { 631 return (__m512i)((__v16su)__a & (__v16su)__b); 632 } 633 634 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 635 _mm512_mask_and_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b) { 636 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__k, 637 (__v16si) _mm512_and_epi32(__a, __b), 638 (__v16si) __src); 639 } 640 641 static __inline__ __m512i __DEFAULT_FN_ATTRS512 642 _mm512_maskz_and_epi32(__mmask16 __k, __m512i __a, __m512i __b) 643 { 644 return (__m512i) _mm512_mask_and_epi32(_mm512_setzero_si512 (), 645 __k, __a, __b); 646 } 647 648 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 649 _mm512_and_epi64(__m512i __a, __m512i __b) 650 { 651 return (__m512i)((__v8du)__a & (__v8du)__b); 652 } 653 654 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 655 _mm512_mask_and_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b) { 656 return (__m512i)__builtin_ia32_selectq_512( 657 (__mmask8)__k, (__v8di)_mm512_and_epi64(__a, __b), (__v8di)__src); 658 } 659 660 static __inline__ __m512i __DEFAULT_FN_ATTRS512 661 _mm512_maskz_and_epi64(__mmask8 __k, __m512i __a, __m512i __b) 662 { 663 return (__m512i) _mm512_mask_and_epi64(_mm512_setzero_si512 (), 664 __k, __a, __b); 665 } 666 667 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 668 _mm512_andnot_si512 (__m512i __A, __m512i __B) 669 { 670 return (__m512i)(~(__v8du)__A & (__v8du)__B); 671 } 672 673 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 674 _mm512_andnot_epi32 (__m512i __A, __m512i __B) 675 { 676 return (__m512i)(~(__v16su)__A & (__v16su)__B); 677 } 678 679 static __inline__ __m512i __DEFAULT_FN_ATTRS512 680 _mm512_mask_andnot_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) 681 { 682 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 683 (__v16si)_mm512_andnot_epi32(__A, __B), 684 (__v16si)__W); 685 } 686 687 static __inline__ __m512i __DEFAULT_FN_ATTRS512 688 _mm512_maskz_andnot_epi32(__mmask16 __U, __m512i __A, __m512i __B) 689 { 690 return (__m512i)_mm512_mask_andnot_epi32(_mm512_setzero_si512(), 691 __U, __A, __B); 692 } 693 694 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 695 _mm512_andnot_epi64(__m512i __A, __m512i __B) 696 { 697 return (__m512i)(~(__v8du)__A & (__v8du)__B); 698 } 699 700 static __inline__ __m512i __DEFAULT_FN_ATTRS512 701 _mm512_mask_andnot_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) 702 { 703 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 704 (__v8di)_mm512_andnot_epi64(__A, __B), 705 (__v8di)__W); 706 } 707 708 static __inline__ __m512i __DEFAULT_FN_ATTRS512 709 _mm512_maskz_andnot_epi64(__mmask8 __U, __m512i __A, __m512i __B) 710 { 711 return (__m512i)_mm512_mask_andnot_epi64(_mm512_setzero_si512(), 712 __U, __A, __B); 713 } 714 715 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 716 _mm512_or_epi32(__m512i __a, __m512i __b) 717 { 718 return (__m512i)((__v16su)__a | (__v16su)__b); 719 } 720 721 static __inline__ __m512i __DEFAULT_FN_ATTRS512 722 _mm512_mask_or_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b) 723 { 724 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__k, 725 (__v16si)_mm512_or_epi32(__a, __b), 726 (__v16si)__src); 727 } 728 729 static __inline__ __m512i __DEFAULT_FN_ATTRS512 730 _mm512_maskz_or_epi32(__mmask16 __k, __m512i __a, __m512i __b) 731 { 732 return (__m512i)_mm512_mask_or_epi32(_mm512_setzero_si512(), __k, __a, __b); 733 } 734 735 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 736 _mm512_or_epi64(__m512i __a, __m512i __b) 737 { 738 return (__m512i)((__v8du)__a | (__v8du)__b); 739 } 740 741 static __inline__ __m512i __DEFAULT_FN_ATTRS512 742 _mm512_mask_or_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b) 743 { 744 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__k, 745 (__v8di)_mm512_or_epi64(__a, __b), 746 (__v8di)__src); 747 } 748 749 static __inline__ __m512i __DEFAULT_FN_ATTRS512 750 _mm512_maskz_or_epi64(__mmask8 __k, __m512i __a, __m512i __b) 751 { 752 return (__m512i)_mm512_mask_or_epi64(_mm512_setzero_si512(), __k, __a, __b); 753 } 754 755 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 756 _mm512_xor_epi32(__m512i __a, __m512i __b) 757 { 758 return (__m512i)((__v16su)__a ^ (__v16su)__b); 759 } 760 761 static __inline__ __m512i __DEFAULT_FN_ATTRS512 762 _mm512_mask_xor_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b) 763 { 764 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__k, 765 (__v16si)_mm512_xor_epi32(__a, __b), 766 (__v16si)__src); 767 } 768 769 static __inline__ __m512i __DEFAULT_FN_ATTRS512 770 _mm512_maskz_xor_epi32(__mmask16 __k, __m512i __a, __m512i __b) 771 { 772 return (__m512i)_mm512_mask_xor_epi32(_mm512_setzero_si512(), __k, __a, __b); 773 } 774 775 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 776 _mm512_xor_epi64(__m512i __a, __m512i __b) 777 { 778 return (__m512i)((__v8du)__a ^ (__v8du)__b); 779 } 780 781 static __inline__ __m512i __DEFAULT_FN_ATTRS512 782 _mm512_mask_xor_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b) 783 { 784 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__k, 785 (__v8di)_mm512_xor_epi64(__a, __b), 786 (__v8di)__src); 787 } 788 789 static __inline__ __m512i __DEFAULT_FN_ATTRS512 790 _mm512_maskz_xor_epi64(__mmask8 __k, __m512i __a, __m512i __b) 791 { 792 return (__m512i)_mm512_mask_xor_epi64(_mm512_setzero_si512(), __k, __a, __b); 793 } 794 795 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 796 _mm512_and_si512(__m512i __a, __m512i __b) 797 { 798 return (__m512i)((__v8du)__a & (__v8du)__b); 799 } 800 801 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 802 _mm512_or_si512(__m512i __a, __m512i __b) 803 { 804 return (__m512i)((__v8du)__a | (__v8du)__b); 805 } 806 807 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 808 _mm512_xor_si512(__m512i __a, __m512i __b) 809 { 810 return (__m512i)((__v8du)__a ^ (__v8du)__b); 811 } 812 813 /* Arithmetic */ 814 815 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 816 _mm512_add_pd(__m512d __a, __m512d __b) { 817 return (__m512d)((__v8df)__a + (__v8df)__b); 818 } 819 820 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 821 _mm512_add_ps(__m512 __a, __m512 __b) { 822 return (__m512)((__v16sf)__a + (__v16sf)__b); 823 } 824 825 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 826 _mm512_mul_pd(__m512d __a, __m512d __b) { 827 return (__m512d)((__v8df)__a * (__v8df)__b); 828 } 829 830 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 831 _mm512_mul_ps(__m512 __a, __m512 __b) { 832 return (__m512)((__v16sf)__a * (__v16sf)__b); 833 } 834 835 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 836 _mm512_sub_pd(__m512d __a, __m512d __b) { 837 return (__m512d)((__v8df)__a - (__v8df)__b); 838 } 839 840 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 841 _mm512_sub_ps(__m512 __a, __m512 __b) { 842 return (__m512)((__v16sf)__a - (__v16sf)__b); 843 } 844 845 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 846 _mm512_add_epi64(__m512i __A, __m512i __B) { 847 return (__m512i) ((__v8du) __A + (__v8du) __B); 848 } 849 850 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 851 _mm512_mask_add_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { 852 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 853 (__v8di)_mm512_add_epi64(__A, __B), 854 (__v8di)__W); 855 } 856 857 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 858 _mm512_maskz_add_epi64(__mmask8 __U, __m512i __A, __m512i __B) { 859 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 860 (__v8di)_mm512_add_epi64(__A, __B), 861 (__v8di)_mm512_setzero_si512()); 862 } 863 864 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 865 _mm512_sub_epi64(__m512i __A, __m512i __B) { 866 return (__m512i) ((__v8du) __A - (__v8du) __B); 867 } 868 869 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 870 _mm512_mask_sub_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { 871 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 872 (__v8di)_mm512_sub_epi64(__A, __B), 873 (__v8di)__W); 874 } 875 876 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 877 _mm512_maskz_sub_epi64(__mmask8 __U, __m512i __A, __m512i __B) { 878 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 879 (__v8di)_mm512_sub_epi64(__A, __B), 880 (__v8di)_mm512_setzero_si512()); 881 } 882 883 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 884 _mm512_add_epi32(__m512i __A, __m512i __B) { 885 return (__m512i) ((__v16su) __A + (__v16su) __B); 886 } 887 888 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 889 _mm512_mask_add_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) { 890 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 891 (__v16si)_mm512_add_epi32(__A, __B), 892 (__v16si)__W); 893 } 894 895 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 896 _mm512_maskz_add_epi32(__mmask16 __U, __m512i __A, __m512i __B) { 897 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 898 (__v16si)_mm512_add_epi32(__A, __B), 899 (__v16si)_mm512_setzero_si512()); 900 } 901 902 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 903 _mm512_sub_epi32(__m512i __A, __m512i __B) { 904 return (__m512i) ((__v16su) __A - (__v16su) __B); 905 } 906 907 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 908 _mm512_mask_sub_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) { 909 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 910 (__v16si)_mm512_sub_epi32(__A, __B), 911 (__v16si)__W); 912 } 913 914 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 915 _mm512_maskz_sub_epi32(__mmask16 __U, __m512i __A, __m512i __B) { 916 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 917 (__v16si)_mm512_sub_epi32(__A, __B), 918 (__v16si)_mm512_setzero_si512()); 919 } 920 921 #define _mm512_max_round_pd(A, B, R) \ 922 ((__m512d)__builtin_ia32_maxpd512((__v8df)(__m512d)(A), \ 923 (__v8df)(__m512d)(B), (int)(R))) 924 925 #define _mm512_mask_max_round_pd(W, U, A, B, R) \ 926 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 927 (__v8df)_mm512_max_round_pd((A), (B), (R)), \ 928 (__v8df)(W))) 929 930 #define _mm512_maskz_max_round_pd(U, A, B, R) \ 931 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 932 (__v8df)_mm512_max_round_pd((A), (B), (R)), \ 933 (__v8df)_mm512_setzero_pd())) 934 935 static __inline__ __m512d 936 __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_max_pd(__m512d __A, __m512d __B) { 937 return (__m512d) __builtin_ia32_maxpd512((__v8df) __A, (__v8df) __B, 938 _MM_FROUND_CUR_DIRECTION); 939 } 940 941 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 942 _mm512_mask_max_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 943 return (__m512d)__builtin_ia32_selectpd_512(__U, 944 (__v8df)_mm512_max_pd(__A, __B), 945 (__v8df)__W); 946 } 947 948 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 949 _mm512_maskz_max_pd(__mmask8 __U, __m512d __A, __m512d __B) { 950 return (__m512d)__builtin_ia32_selectpd_512(__U, 951 (__v8df)_mm512_max_pd(__A, __B), 952 (__v8df)_mm512_setzero_pd()); 953 } 954 955 #define _mm512_max_round_ps(A, B, R) \ 956 ((__m512)__builtin_ia32_maxps512((__v16sf)(__m512)(A), \ 957 (__v16sf)(__m512)(B), (int)(R))) 958 959 #define _mm512_mask_max_round_ps(W, U, A, B, R) \ 960 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 961 (__v16sf)_mm512_max_round_ps((A), (B), (R)), \ 962 (__v16sf)(W))) 963 964 #define _mm512_maskz_max_round_ps(U, A, B, R) \ 965 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 966 (__v16sf)_mm512_max_round_ps((A), (B), (R)), \ 967 (__v16sf)_mm512_setzero_ps())) 968 969 static __inline__ __m512 970 __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_max_ps(__m512 __A, __m512 __B) { 971 return (__m512) __builtin_ia32_maxps512((__v16sf) __A, (__v16sf) __B, 972 _MM_FROUND_CUR_DIRECTION); 973 } 974 975 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 976 _mm512_mask_max_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 977 return (__m512)__builtin_ia32_selectps_512(__U, 978 (__v16sf)_mm512_max_ps(__A, __B), 979 (__v16sf)__W); 980 } 981 982 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 983 _mm512_maskz_max_ps(__mmask16 __U, __m512 __A, __m512 __B) { 984 return (__m512)__builtin_ia32_selectps_512(__U, 985 (__v16sf)_mm512_max_ps(__A, __B), 986 (__v16sf)_mm512_setzero_ps()); 987 } 988 989 static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_mask_max_ss(__m128 __W, 990 __mmask8 __U, 991 __m128 __A, 992 __m128 __B) { 993 return (__m128) __builtin_ia32_maxss_round_mask ((__v4sf) __A, 994 (__v4sf) __B, 995 (__v4sf) __W, 996 (__mmask8) __U, 997 _MM_FROUND_CUR_DIRECTION); 998 } 999 1000 static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_maskz_max_ss(__mmask8 __U, 1001 __m128 __A, 1002 __m128 __B) { 1003 return (__m128) __builtin_ia32_maxss_round_mask ((__v4sf) __A, 1004 (__v4sf) __B, 1005 (__v4sf) _mm_setzero_ps (), 1006 (__mmask8) __U, 1007 _MM_FROUND_CUR_DIRECTION); 1008 } 1009 1010 #define _mm_max_round_ss(A, B, R) \ 1011 ((__m128)__builtin_ia32_maxss_round_mask((__v4sf)(__m128)(A), \ 1012 (__v4sf)(__m128)(B), \ 1013 (__v4sf)_mm_setzero_ps(), \ 1014 (__mmask8)-1, (int)(R))) 1015 1016 #define _mm_mask_max_round_ss(W, U, A, B, R) \ 1017 ((__m128)__builtin_ia32_maxss_round_mask((__v4sf)(__m128)(A), \ 1018 (__v4sf)(__m128)(B), \ 1019 (__v4sf)(__m128)(W), (__mmask8)(U), \ 1020 (int)(R))) 1021 1022 #define _mm_maskz_max_round_ss(U, A, B, R) \ 1023 ((__m128)__builtin_ia32_maxss_round_mask((__v4sf)(__m128)(A), \ 1024 (__v4sf)(__m128)(B), \ 1025 (__v4sf)_mm_setzero_ps(), \ 1026 (__mmask8)(U), (int)(R))) 1027 1028 static __inline__ __m128d __DEFAULT_FN_ATTRS128 _mm_mask_max_sd(__m128d __W, 1029 __mmask8 __U, 1030 __m128d __A, 1031 __m128d __B) { 1032 return (__m128d) __builtin_ia32_maxsd_round_mask ((__v2df) __A, 1033 (__v2df) __B, 1034 (__v2df) __W, 1035 (__mmask8) __U, 1036 _MM_FROUND_CUR_DIRECTION); 1037 } 1038 1039 static __inline__ __m128d __DEFAULT_FN_ATTRS128 _mm_maskz_max_sd(__mmask8 __U, 1040 __m128d __A, 1041 __m128d __B) { 1042 return (__m128d) __builtin_ia32_maxsd_round_mask ((__v2df) __A, 1043 (__v2df) __B, 1044 (__v2df) _mm_setzero_pd (), 1045 (__mmask8) __U, 1046 _MM_FROUND_CUR_DIRECTION); 1047 } 1048 1049 #define _mm_max_round_sd(A, B, R) \ 1050 ((__m128d)__builtin_ia32_maxsd_round_mask((__v2df)(__m128d)(A), \ 1051 (__v2df)(__m128d)(B), \ 1052 (__v2df)_mm_setzero_pd(), \ 1053 (__mmask8)-1, (int)(R))) 1054 1055 #define _mm_mask_max_round_sd(W, U, A, B, R) \ 1056 ((__m128d)__builtin_ia32_maxsd_round_mask((__v2df)(__m128d)(A), \ 1057 (__v2df)(__m128d)(B), \ 1058 (__v2df)(__m128d)(W), \ 1059 (__mmask8)(U), (int)(R))) 1060 1061 #define _mm_maskz_max_round_sd(U, A, B, R) \ 1062 ((__m128d)__builtin_ia32_maxsd_round_mask((__v2df)(__m128d)(A), \ 1063 (__v2df)(__m128d)(B), \ 1064 (__v2df)_mm_setzero_pd(), \ 1065 (__mmask8)(U), (int)(R))) 1066 1067 static __inline __m512i 1068 __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_max_epi32(__m512i __A, __m512i __B) { 1069 return (__m512i)__builtin_elementwise_max((__v16si)__A, (__v16si)__B); 1070 } 1071 1072 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1073 _mm512_mask_max_epi32(__m512i __W, __mmask16 __M, __m512i __A, __m512i __B) { 1074 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M, 1075 (__v16si)_mm512_max_epi32(__A, __B), 1076 (__v16si)__W); 1077 } 1078 1079 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1080 _mm512_maskz_max_epi32(__mmask16 __M, __m512i __A, __m512i __B) { 1081 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M, 1082 (__v16si)_mm512_max_epi32(__A, __B), 1083 (__v16si)_mm512_setzero_si512()); 1084 } 1085 1086 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1087 _mm512_max_epu32(__m512i __A, __m512i __B) { 1088 return (__m512i)__builtin_elementwise_max((__v16su)__A, (__v16su)__B); 1089 } 1090 1091 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1092 _mm512_mask_max_epu32(__m512i __W, __mmask16 __M, __m512i __A, __m512i __B) { 1093 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M, 1094 (__v16si)_mm512_max_epu32(__A, __B), 1095 (__v16si)__W); 1096 } 1097 1098 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1099 _mm512_maskz_max_epu32(__mmask16 __M, __m512i __A, __m512i __B) { 1100 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M, 1101 (__v16si)_mm512_max_epu32(__A, __B), 1102 (__v16si)_mm512_setzero_si512()); 1103 } 1104 1105 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1106 _mm512_max_epi64(__m512i __A, __m512i __B) { 1107 return (__m512i)__builtin_elementwise_max((__v8di)__A, (__v8di)__B); 1108 } 1109 1110 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1111 _mm512_mask_max_epi64(__m512i __W, __mmask8 __M, __m512i __A, __m512i __B) { 1112 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M, 1113 (__v8di)_mm512_max_epi64(__A, __B), 1114 (__v8di)__W); 1115 } 1116 1117 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1118 _mm512_maskz_max_epi64(__mmask8 __M, __m512i __A, __m512i __B) { 1119 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M, 1120 (__v8di)_mm512_max_epi64(__A, __B), 1121 (__v8di)_mm512_setzero_si512()); 1122 } 1123 1124 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1125 _mm512_max_epu64(__m512i __A, __m512i __B) { 1126 return (__m512i)__builtin_elementwise_max((__v8du)__A, (__v8du)__B); 1127 } 1128 1129 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1130 _mm512_mask_max_epu64(__m512i __W, __mmask8 __M, __m512i __A, __m512i __B) { 1131 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M, 1132 (__v8di)_mm512_max_epu64(__A, __B), 1133 (__v8di)__W); 1134 } 1135 1136 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1137 _mm512_maskz_max_epu64(__mmask8 __M, __m512i __A, __m512i __B) { 1138 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M, 1139 (__v8di)_mm512_max_epu64(__A, __B), 1140 (__v8di)_mm512_setzero_si512()); 1141 } 1142 1143 #define _mm512_min_round_pd(A, B, R) \ 1144 ((__m512d)__builtin_ia32_minpd512((__v8df)(__m512d)(A), \ 1145 (__v8df)(__m512d)(B), (int)(R))) 1146 1147 #define _mm512_mask_min_round_pd(W, U, A, B, R) \ 1148 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 1149 (__v8df)_mm512_min_round_pd((A), (B), (R)), \ 1150 (__v8df)(W))) 1151 1152 #define _mm512_maskz_min_round_pd(U, A, B, R) \ 1153 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 1154 (__v8df)_mm512_min_round_pd((A), (B), (R)), \ 1155 (__v8df)_mm512_setzero_pd())) 1156 1157 static __inline__ __m512d 1158 __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_min_pd(__m512d __A, __m512d __B) { 1159 return (__m512d) __builtin_ia32_minpd512((__v8df) __A, (__v8df) __B, 1160 _MM_FROUND_CUR_DIRECTION); 1161 } 1162 1163 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 1164 _mm512_mask_min_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 1165 return (__m512d)__builtin_ia32_selectpd_512(__U, 1166 (__v8df)_mm512_min_pd(__A, __B), 1167 (__v8df)__W); 1168 } 1169 1170 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 1171 _mm512_maskz_min_pd(__mmask8 __U, __m512d __A, __m512d __B) { 1172 return (__m512d)__builtin_ia32_selectpd_512(__U, 1173 (__v8df)_mm512_min_pd(__A, __B), 1174 (__v8df)_mm512_setzero_pd()); 1175 } 1176 1177 #define _mm512_min_round_ps(A, B, R) \ 1178 ((__m512)__builtin_ia32_minps512((__v16sf)(__m512)(A), \ 1179 (__v16sf)(__m512)(B), (int)(R))) 1180 1181 #define _mm512_mask_min_round_ps(W, U, A, B, R) \ 1182 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 1183 (__v16sf)_mm512_min_round_ps((A), (B), (R)), \ 1184 (__v16sf)(W))) 1185 1186 #define _mm512_maskz_min_round_ps(U, A, B, R) \ 1187 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 1188 (__v16sf)_mm512_min_round_ps((A), (B), (R)), \ 1189 (__v16sf)_mm512_setzero_ps())) 1190 1191 static __inline__ __m512 1192 __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_min_ps(__m512 __A, __m512 __B) { 1193 return (__m512) __builtin_ia32_minps512((__v16sf) __A, (__v16sf) __B, 1194 _MM_FROUND_CUR_DIRECTION); 1195 } 1196 1197 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 1198 _mm512_mask_min_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 1199 return (__m512)__builtin_ia32_selectps_512(__U, 1200 (__v16sf)_mm512_min_ps(__A, __B), 1201 (__v16sf)__W); 1202 } 1203 1204 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 1205 _mm512_maskz_min_ps(__mmask16 __U, __m512 __A, __m512 __B) { 1206 return (__m512)__builtin_ia32_selectps_512(__U, 1207 (__v16sf)_mm512_min_ps(__A, __B), 1208 (__v16sf)_mm512_setzero_ps()); 1209 } 1210 1211 static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_mask_min_ss(__m128 __W, 1212 __mmask8 __U, 1213 __m128 __A, 1214 __m128 __B) { 1215 return (__m128) __builtin_ia32_minss_round_mask ((__v4sf) __A, 1216 (__v4sf) __B, 1217 (__v4sf) __W, 1218 (__mmask8) __U, 1219 _MM_FROUND_CUR_DIRECTION); 1220 } 1221 1222 static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_maskz_min_ss(__mmask8 __U, 1223 __m128 __A, 1224 __m128 __B) { 1225 return (__m128) __builtin_ia32_minss_round_mask ((__v4sf) __A, 1226 (__v4sf) __B, 1227 (__v4sf) _mm_setzero_ps (), 1228 (__mmask8) __U, 1229 _MM_FROUND_CUR_DIRECTION); 1230 } 1231 1232 #define _mm_min_round_ss(A, B, R) \ 1233 ((__m128)__builtin_ia32_minss_round_mask((__v4sf)(__m128)(A), \ 1234 (__v4sf)(__m128)(B), \ 1235 (__v4sf)_mm_setzero_ps(), \ 1236 (__mmask8)-1, (int)(R))) 1237 1238 #define _mm_mask_min_round_ss(W, U, A, B, R) \ 1239 ((__m128)__builtin_ia32_minss_round_mask((__v4sf)(__m128)(A), \ 1240 (__v4sf)(__m128)(B), \ 1241 (__v4sf)(__m128)(W), (__mmask8)(U), \ 1242 (int)(R))) 1243 1244 #define _mm_maskz_min_round_ss(U, A, B, R) \ 1245 ((__m128)__builtin_ia32_minss_round_mask((__v4sf)(__m128)(A), \ 1246 (__v4sf)(__m128)(B), \ 1247 (__v4sf)_mm_setzero_ps(), \ 1248 (__mmask8)(U), (int)(R))) 1249 1250 static __inline__ __m128d __DEFAULT_FN_ATTRS128 _mm_mask_min_sd(__m128d __W, 1251 __mmask8 __U, 1252 __m128d __A, 1253 __m128d __B) { 1254 return (__m128d) __builtin_ia32_minsd_round_mask ((__v2df) __A, 1255 (__v2df) __B, 1256 (__v2df) __W, 1257 (__mmask8) __U, 1258 _MM_FROUND_CUR_DIRECTION); 1259 } 1260 1261 static __inline__ __m128d __DEFAULT_FN_ATTRS128 _mm_maskz_min_sd(__mmask8 __U, 1262 __m128d __A, 1263 __m128d __B) { 1264 return (__m128d) __builtin_ia32_minsd_round_mask ((__v2df) __A, 1265 (__v2df) __B, 1266 (__v2df) _mm_setzero_pd (), 1267 (__mmask8) __U, 1268 _MM_FROUND_CUR_DIRECTION); 1269 } 1270 1271 #define _mm_min_round_sd(A, B, R) \ 1272 ((__m128d)__builtin_ia32_minsd_round_mask((__v2df)(__m128d)(A), \ 1273 (__v2df)(__m128d)(B), \ 1274 (__v2df)_mm_setzero_pd(), \ 1275 (__mmask8)-1, (int)(R))) 1276 1277 #define _mm_mask_min_round_sd(W, U, A, B, R) \ 1278 ((__m128d)__builtin_ia32_minsd_round_mask((__v2df)(__m128d)(A), \ 1279 (__v2df)(__m128d)(B), \ 1280 (__v2df)(__m128d)(W), \ 1281 (__mmask8)(U), (int)(R))) 1282 1283 #define _mm_maskz_min_round_sd(U, A, B, R) \ 1284 ((__m128d)__builtin_ia32_minsd_round_mask((__v2df)(__m128d)(A), \ 1285 (__v2df)(__m128d)(B), \ 1286 (__v2df)_mm_setzero_pd(), \ 1287 (__mmask8)(U), (int)(R))) 1288 1289 static __inline __m512i 1290 __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_min_epi32(__m512i __A, __m512i __B) { 1291 return (__m512i)__builtin_elementwise_min((__v16si)__A, (__v16si)__B); 1292 } 1293 1294 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1295 _mm512_mask_min_epi32(__m512i __W, __mmask16 __M, __m512i __A, __m512i __B) { 1296 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M, 1297 (__v16si)_mm512_min_epi32(__A, __B), 1298 (__v16si)__W); 1299 } 1300 1301 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1302 _mm512_maskz_min_epi32(__mmask16 __M, __m512i __A, __m512i __B) { 1303 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M, 1304 (__v16si)_mm512_min_epi32(__A, __B), 1305 (__v16si)_mm512_setzero_si512()); 1306 } 1307 1308 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1309 _mm512_min_epu32(__m512i __A, __m512i __B) { 1310 return (__m512i)__builtin_elementwise_min((__v16su)__A, (__v16su)__B); 1311 } 1312 1313 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1314 _mm512_mask_min_epu32(__m512i __W, __mmask16 __M, __m512i __A, __m512i __B) { 1315 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M, 1316 (__v16si)_mm512_min_epu32(__A, __B), 1317 (__v16si)__W); 1318 } 1319 1320 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1321 _mm512_maskz_min_epu32(__mmask16 __M, __m512i __A, __m512i __B) { 1322 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M, 1323 (__v16si)_mm512_min_epu32(__A, __B), 1324 (__v16si)_mm512_setzero_si512()); 1325 } 1326 1327 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1328 _mm512_min_epi64(__m512i __A, __m512i __B) { 1329 return (__m512i)__builtin_elementwise_min((__v8di)__A, (__v8di)__B); 1330 } 1331 1332 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1333 _mm512_mask_min_epi64(__m512i __W, __mmask8 __M, __m512i __A, __m512i __B) { 1334 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M, 1335 (__v8di)_mm512_min_epi64(__A, __B), 1336 (__v8di)__W); 1337 } 1338 1339 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1340 _mm512_maskz_min_epi64(__mmask8 __M, __m512i __A, __m512i __B) { 1341 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M, 1342 (__v8di)_mm512_min_epi64(__A, __B), 1343 (__v8di)_mm512_setzero_si512()); 1344 } 1345 1346 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1347 _mm512_min_epu64(__m512i __A, __m512i __B) { 1348 return (__m512i)__builtin_elementwise_min((__v8du)__A, (__v8du)__B); 1349 } 1350 1351 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1352 _mm512_mask_min_epu64(__m512i __W, __mmask8 __M, __m512i __A, __m512i __B) { 1353 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M, 1354 (__v8di)_mm512_min_epu64(__A, __B), 1355 (__v8di)__W); 1356 } 1357 1358 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1359 _mm512_maskz_min_epu64(__mmask8 __M, __m512i __A, __m512i __B) { 1360 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M, 1361 (__v8di)_mm512_min_epu64(__A, __B), 1362 (__v8di)_mm512_setzero_si512()); 1363 } 1364 1365 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1366 _mm512_mul_epi32(__m512i __X, __m512i __Y) { 1367 return (__m512i)__builtin_ia32_pmuldq512((__v16si)__X, (__v16si) __Y); 1368 } 1369 1370 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1371 _mm512_mask_mul_epi32(__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y) { 1372 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M, 1373 (__v8di)_mm512_mul_epi32(__X, __Y), 1374 (__v8di)__W); 1375 } 1376 1377 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1378 _mm512_maskz_mul_epi32(__mmask8 __M, __m512i __X, __m512i __Y) { 1379 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M, 1380 (__v8di)_mm512_mul_epi32(__X, __Y), 1381 (__v8di)_mm512_setzero_si512 ()); 1382 } 1383 1384 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1385 _mm512_mul_epu32(__m512i __X, __m512i __Y) { 1386 return (__m512i)__builtin_ia32_pmuludq512((__v16si)__X, (__v16si)__Y); 1387 } 1388 1389 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1390 _mm512_mask_mul_epu32(__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y) { 1391 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M, 1392 (__v8di)_mm512_mul_epu32(__X, __Y), 1393 (__v8di)__W); 1394 } 1395 1396 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1397 _mm512_maskz_mul_epu32(__mmask8 __M, __m512i __X, __m512i __Y) { 1398 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M, 1399 (__v8di)_mm512_mul_epu32(__X, __Y), 1400 (__v8di)_mm512_setzero_si512 ()); 1401 } 1402 1403 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1404 _mm512_mullo_epi32(__m512i __A, __m512i __B) { 1405 return (__m512i) ((__v16su) __A * (__v16su) __B); 1406 } 1407 1408 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1409 _mm512_maskz_mullo_epi32(__mmask16 __M, __m512i __A, __m512i __B) { 1410 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M, 1411 (__v16si)_mm512_mullo_epi32(__A, __B), 1412 (__v16si)_mm512_setzero_si512()); 1413 } 1414 1415 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1416 _mm512_mask_mullo_epi32(__m512i __W, __mmask16 __M, __m512i __A, __m512i __B) { 1417 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M, 1418 (__v16si)_mm512_mullo_epi32(__A, __B), 1419 (__v16si)__W); 1420 } 1421 1422 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1423 _mm512_mullox_epi64(__m512i __A, __m512i __B) { 1424 return (__m512i) ((__v8du) __A * (__v8du) __B); 1425 } 1426 1427 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1428 _mm512_mask_mullox_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { 1429 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 1430 (__v8di)_mm512_mullox_epi64(__A, __B), 1431 (__v8di)__W); 1432 } 1433 1434 #define _mm512_sqrt_round_pd(A, R) \ 1435 ((__m512d)__builtin_ia32_sqrtpd512((__v8df)(__m512d)(A), (int)(R))) 1436 1437 #define _mm512_mask_sqrt_round_pd(W, U, A, R) \ 1438 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 1439 (__v8df)_mm512_sqrt_round_pd((A), (R)), \ 1440 (__v8df)(__m512d)(W))) 1441 1442 #define _mm512_maskz_sqrt_round_pd(U, A, R) \ 1443 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 1444 (__v8df)_mm512_sqrt_round_pd((A), (R)), \ 1445 (__v8df)_mm512_setzero_pd())) 1446 1447 static __inline__ __m512d __DEFAULT_FN_ATTRS512 _mm512_sqrt_pd(__m512d __A) { 1448 return (__m512d)__builtin_elementwise_sqrt((__v8df)__A); 1449 } 1450 1451 static __inline__ __m512d __DEFAULT_FN_ATTRS512 1452 _mm512_mask_sqrt_pd(__m512d __W, __mmask8 __U, __m512d __A) { 1453 return (__m512d)__builtin_ia32_selectpd_512(__U, (__v8df)_mm512_sqrt_pd(__A), 1454 (__v8df)__W); 1455 } 1456 1457 static __inline__ __m512d __DEFAULT_FN_ATTRS512 1458 _mm512_maskz_sqrt_pd(__mmask8 __U, __m512d __A) { 1459 return (__m512d)__builtin_ia32_selectpd_512(__U, (__v8df)_mm512_sqrt_pd(__A), 1460 (__v8df)_mm512_setzero_pd()); 1461 } 1462 1463 #define _mm512_sqrt_round_ps(A, R) \ 1464 ((__m512)__builtin_ia32_sqrtps512((__v16sf)(__m512)(A), (int)(R))) 1465 1466 #define _mm512_mask_sqrt_round_ps(W, U, A, R) \ 1467 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 1468 (__v16sf)_mm512_sqrt_round_ps((A), (R)), \ 1469 (__v16sf)(__m512)(W))) 1470 1471 #define _mm512_maskz_sqrt_round_ps(U, A, R) \ 1472 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 1473 (__v16sf)_mm512_sqrt_round_ps((A), (R)), \ 1474 (__v16sf)_mm512_setzero_ps())) 1475 1476 static __inline__ __m512 __DEFAULT_FN_ATTRS512 _mm512_sqrt_ps(__m512 __A) { 1477 return (__m512)__builtin_elementwise_sqrt((__v16sf)__A); 1478 } 1479 1480 static __inline__ __m512 __DEFAULT_FN_ATTRS512 1481 _mm512_mask_sqrt_ps(__m512 __W, __mmask16 __U, __m512 __A) { 1482 return (__m512)__builtin_ia32_selectps_512(__U, (__v16sf)_mm512_sqrt_ps(__A), 1483 (__v16sf)__W); 1484 } 1485 1486 static __inline__ __m512 __DEFAULT_FN_ATTRS512 1487 _mm512_maskz_sqrt_ps(__mmask16 __U, __m512 __A) { 1488 return (__m512)__builtin_ia32_selectps_512(__U, (__v16sf)_mm512_sqrt_ps(__A), 1489 (__v16sf)_mm512_setzero_ps()); 1490 } 1491 1492 static __inline__ __m512d __DEFAULT_FN_ATTRS512 1493 _mm512_rsqrt14_pd(__m512d __A) 1494 { 1495 return (__m512d) __builtin_ia32_rsqrt14pd512_mask ((__v8df) __A, 1496 (__v8df) 1497 _mm512_setzero_pd (), 1498 (__mmask8) -1);} 1499 1500 static __inline__ __m512d __DEFAULT_FN_ATTRS512 1501 _mm512_mask_rsqrt14_pd (__m512d __W, __mmask8 __U, __m512d __A) 1502 { 1503 return (__m512d) __builtin_ia32_rsqrt14pd512_mask ((__v8df) __A, 1504 (__v8df) __W, 1505 (__mmask8) __U); 1506 } 1507 1508 static __inline__ __m512d __DEFAULT_FN_ATTRS512 1509 _mm512_maskz_rsqrt14_pd (__mmask8 __U, __m512d __A) 1510 { 1511 return (__m512d) __builtin_ia32_rsqrt14pd512_mask ((__v8df) __A, 1512 (__v8df) 1513 _mm512_setzero_pd (), 1514 (__mmask8) __U); 1515 } 1516 1517 static __inline__ __m512 __DEFAULT_FN_ATTRS512 1518 _mm512_rsqrt14_ps(__m512 __A) 1519 { 1520 return (__m512) __builtin_ia32_rsqrt14ps512_mask ((__v16sf) __A, 1521 (__v16sf) 1522 _mm512_setzero_ps (), 1523 (__mmask16) -1); 1524 } 1525 1526 static __inline__ __m512 __DEFAULT_FN_ATTRS512 1527 _mm512_mask_rsqrt14_ps (__m512 __W, __mmask16 __U, __m512 __A) 1528 { 1529 return (__m512) __builtin_ia32_rsqrt14ps512_mask ((__v16sf) __A, 1530 (__v16sf) __W, 1531 (__mmask16) __U); 1532 } 1533 1534 static __inline__ __m512 __DEFAULT_FN_ATTRS512 1535 _mm512_maskz_rsqrt14_ps (__mmask16 __U, __m512 __A) 1536 { 1537 return (__m512) __builtin_ia32_rsqrt14ps512_mask ((__v16sf) __A, 1538 (__v16sf) 1539 _mm512_setzero_ps (), 1540 (__mmask16) __U); 1541 } 1542 1543 static __inline__ __m128 __DEFAULT_FN_ATTRS128 1544 _mm_rsqrt14_ss(__m128 __A, __m128 __B) 1545 { 1546 return (__m128) __builtin_ia32_rsqrt14ss_mask ((__v4sf) __A, 1547 (__v4sf) __B, 1548 (__v4sf) 1549 _mm_setzero_ps (), 1550 (__mmask8) -1); 1551 } 1552 1553 static __inline__ __m128 __DEFAULT_FN_ATTRS128 1554 _mm_mask_rsqrt14_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) 1555 { 1556 return (__m128) __builtin_ia32_rsqrt14ss_mask ((__v4sf) __A, 1557 (__v4sf) __B, 1558 (__v4sf) __W, 1559 (__mmask8) __U); 1560 } 1561 1562 static __inline__ __m128 __DEFAULT_FN_ATTRS128 1563 _mm_maskz_rsqrt14_ss (__mmask8 __U, __m128 __A, __m128 __B) 1564 { 1565 return (__m128) __builtin_ia32_rsqrt14ss_mask ((__v4sf) __A, 1566 (__v4sf) __B, 1567 (__v4sf) _mm_setzero_ps (), 1568 (__mmask8) __U); 1569 } 1570 1571 static __inline__ __m128d __DEFAULT_FN_ATTRS128 1572 _mm_rsqrt14_sd(__m128d __A, __m128d __B) 1573 { 1574 return (__m128d) __builtin_ia32_rsqrt14sd_mask ((__v2df) __A, 1575 (__v2df) __B, 1576 (__v2df) 1577 _mm_setzero_pd (), 1578 (__mmask8) -1); 1579 } 1580 1581 static __inline__ __m128d __DEFAULT_FN_ATTRS128 1582 _mm_mask_rsqrt14_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) 1583 { 1584 return (__m128d) __builtin_ia32_rsqrt14sd_mask ( (__v2df) __A, 1585 (__v2df) __B, 1586 (__v2df) __W, 1587 (__mmask8) __U); 1588 } 1589 1590 static __inline__ __m128d __DEFAULT_FN_ATTRS128 1591 _mm_maskz_rsqrt14_sd (__mmask8 __U, __m128d __A, __m128d __B) 1592 { 1593 return (__m128d) __builtin_ia32_rsqrt14sd_mask ( (__v2df) __A, 1594 (__v2df) __B, 1595 (__v2df) _mm_setzero_pd (), 1596 (__mmask8) __U); 1597 } 1598 1599 static __inline__ __m512d __DEFAULT_FN_ATTRS512 1600 _mm512_rcp14_pd(__m512d __A) 1601 { 1602 return (__m512d) __builtin_ia32_rcp14pd512_mask ((__v8df) __A, 1603 (__v8df) 1604 _mm512_setzero_pd (), 1605 (__mmask8) -1); 1606 } 1607 1608 static __inline__ __m512d __DEFAULT_FN_ATTRS512 1609 _mm512_mask_rcp14_pd (__m512d __W, __mmask8 __U, __m512d __A) 1610 { 1611 return (__m512d) __builtin_ia32_rcp14pd512_mask ((__v8df) __A, 1612 (__v8df) __W, 1613 (__mmask8) __U); 1614 } 1615 1616 static __inline__ __m512d __DEFAULT_FN_ATTRS512 1617 _mm512_maskz_rcp14_pd (__mmask8 __U, __m512d __A) 1618 { 1619 return (__m512d) __builtin_ia32_rcp14pd512_mask ((__v8df) __A, 1620 (__v8df) 1621 _mm512_setzero_pd (), 1622 (__mmask8) __U); 1623 } 1624 1625 static __inline__ __m512 __DEFAULT_FN_ATTRS512 1626 _mm512_rcp14_ps(__m512 __A) 1627 { 1628 return (__m512) __builtin_ia32_rcp14ps512_mask ((__v16sf) __A, 1629 (__v16sf) 1630 _mm512_setzero_ps (), 1631 (__mmask16) -1); 1632 } 1633 1634 static __inline__ __m512 __DEFAULT_FN_ATTRS512 1635 _mm512_mask_rcp14_ps (__m512 __W, __mmask16 __U, __m512 __A) 1636 { 1637 return (__m512) __builtin_ia32_rcp14ps512_mask ((__v16sf) __A, 1638 (__v16sf) __W, 1639 (__mmask16) __U); 1640 } 1641 1642 static __inline__ __m512 __DEFAULT_FN_ATTRS512 1643 _mm512_maskz_rcp14_ps (__mmask16 __U, __m512 __A) 1644 { 1645 return (__m512) __builtin_ia32_rcp14ps512_mask ((__v16sf) __A, 1646 (__v16sf) 1647 _mm512_setzero_ps (), 1648 (__mmask16) __U); 1649 } 1650 1651 static __inline__ __m128 __DEFAULT_FN_ATTRS128 1652 _mm_rcp14_ss(__m128 __A, __m128 __B) 1653 { 1654 return (__m128) __builtin_ia32_rcp14ss_mask ((__v4sf) __A, 1655 (__v4sf) __B, 1656 (__v4sf) 1657 _mm_setzero_ps (), 1658 (__mmask8) -1); 1659 } 1660 1661 static __inline__ __m128 __DEFAULT_FN_ATTRS128 1662 _mm_mask_rcp14_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) 1663 { 1664 return (__m128) __builtin_ia32_rcp14ss_mask ((__v4sf) __A, 1665 (__v4sf) __B, 1666 (__v4sf) __W, 1667 (__mmask8) __U); 1668 } 1669 1670 static __inline__ __m128 __DEFAULT_FN_ATTRS128 1671 _mm_maskz_rcp14_ss (__mmask8 __U, __m128 __A, __m128 __B) 1672 { 1673 return (__m128) __builtin_ia32_rcp14ss_mask ((__v4sf) __A, 1674 (__v4sf) __B, 1675 (__v4sf) _mm_setzero_ps (), 1676 (__mmask8) __U); 1677 } 1678 1679 static __inline__ __m128d __DEFAULT_FN_ATTRS128 1680 _mm_rcp14_sd(__m128d __A, __m128d __B) 1681 { 1682 return (__m128d) __builtin_ia32_rcp14sd_mask ((__v2df) __A, 1683 (__v2df) __B, 1684 (__v2df) 1685 _mm_setzero_pd (), 1686 (__mmask8) -1); 1687 } 1688 1689 static __inline__ __m128d __DEFAULT_FN_ATTRS128 1690 _mm_mask_rcp14_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) 1691 { 1692 return (__m128d) __builtin_ia32_rcp14sd_mask ( (__v2df) __A, 1693 (__v2df) __B, 1694 (__v2df) __W, 1695 (__mmask8) __U); 1696 } 1697 1698 static __inline__ __m128d __DEFAULT_FN_ATTRS128 1699 _mm_maskz_rcp14_sd (__mmask8 __U, __m128d __A, __m128d __B) 1700 { 1701 return (__m128d) __builtin_ia32_rcp14sd_mask ( (__v2df) __A, 1702 (__v2df) __B, 1703 (__v2df) _mm_setzero_pd (), 1704 (__mmask8) __U); 1705 } 1706 1707 static __inline __m512 __DEFAULT_FN_ATTRS512 1708 _mm512_floor_ps(__m512 __A) 1709 { 1710 return (__m512) __builtin_ia32_rndscaleps_mask ((__v16sf) __A, 1711 _MM_FROUND_FLOOR, 1712 (__v16sf) __A, (unsigned short)-1, 1713 _MM_FROUND_CUR_DIRECTION); 1714 } 1715 1716 static __inline__ __m512 __DEFAULT_FN_ATTRS512 1717 _mm512_mask_floor_ps (__m512 __W, __mmask16 __U, __m512 __A) 1718 { 1719 return (__m512) __builtin_ia32_rndscaleps_mask ((__v16sf) __A, 1720 _MM_FROUND_FLOOR, 1721 (__v16sf) __W, __U, 1722 _MM_FROUND_CUR_DIRECTION); 1723 } 1724 1725 static __inline __m512d __DEFAULT_FN_ATTRS512 1726 _mm512_floor_pd(__m512d __A) 1727 { 1728 return (__m512d) __builtin_ia32_rndscalepd_mask ((__v8df) __A, 1729 _MM_FROUND_FLOOR, 1730 (__v8df) __A, (unsigned char)-1, 1731 _MM_FROUND_CUR_DIRECTION); 1732 } 1733 1734 static __inline__ __m512d __DEFAULT_FN_ATTRS512 1735 _mm512_mask_floor_pd (__m512d __W, __mmask8 __U, __m512d __A) 1736 { 1737 return (__m512d) __builtin_ia32_rndscalepd_mask ((__v8df) __A, 1738 _MM_FROUND_FLOOR, 1739 (__v8df) __W, __U, 1740 _MM_FROUND_CUR_DIRECTION); 1741 } 1742 1743 static __inline__ __m512 __DEFAULT_FN_ATTRS512 1744 _mm512_mask_ceil_ps (__m512 __W, __mmask16 __U, __m512 __A) 1745 { 1746 return (__m512) __builtin_ia32_rndscaleps_mask ((__v16sf) __A, 1747 _MM_FROUND_CEIL, 1748 (__v16sf) __W, __U, 1749 _MM_FROUND_CUR_DIRECTION); 1750 } 1751 1752 static __inline __m512 __DEFAULT_FN_ATTRS512 1753 _mm512_ceil_ps(__m512 __A) 1754 { 1755 return (__m512) __builtin_ia32_rndscaleps_mask ((__v16sf) __A, 1756 _MM_FROUND_CEIL, 1757 (__v16sf) __A, (unsigned short)-1, 1758 _MM_FROUND_CUR_DIRECTION); 1759 } 1760 1761 static __inline __m512d __DEFAULT_FN_ATTRS512 1762 _mm512_ceil_pd(__m512d __A) 1763 { 1764 return (__m512d) __builtin_ia32_rndscalepd_mask ((__v8df) __A, 1765 _MM_FROUND_CEIL, 1766 (__v8df) __A, (unsigned char)-1, 1767 _MM_FROUND_CUR_DIRECTION); 1768 } 1769 1770 static __inline__ __m512d __DEFAULT_FN_ATTRS512 1771 _mm512_mask_ceil_pd (__m512d __W, __mmask8 __U, __m512d __A) 1772 { 1773 return (__m512d) __builtin_ia32_rndscalepd_mask ((__v8df) __A, 1774 _MM_FROUND_CEIL, 1775 (__v8df) __W, __U, 1776 _MM_FROUND_CUR_DIRECTION); 1777 } 1778 1779 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1780 _mm512_abs_epi64(__m512i __A) { 1781 return (__m512i)__builtin_elementwise_abs((__v8di)__A); 1782 } 1783 1784 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1785 _mm512_mask_abs_epi64(__m512i __W, __mmask8 __U, __m512i __A) { 1786 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 1787 (__v8di)_mm512_abs_epi64(__A), 1788 (__v8di)__W); 1789 } 1790 1791 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1792 _mm512_maskz_abs_epi64(__mmask8 __U, __m512i __A) { 1793 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 1794 (__v8di)_mm512_abs_epi64(__A), 1795 (__v8di)_mm512_setzero_si512()); 1796 } 1797 1798 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1799 _mm512_abs_epi32(__m512i __A) { 1800 return (__m512i)__builtin_elementwise_abs((__v16si) __A); 1801 } 1802 1803 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1804 _mm512_mask_abs_epi32(__m512i __W, __mmask16 __U, __m512i __A) { 1805 return (__m512i)__builtin_ia32_selectd_512(__U, 1806 (__v16si)_mm512_abs_epi32(__A), 1807 (__v16si)__W); 1808 } 1809 1810 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 1811 _mm512_maskz_abs_epi32(__mmask16 __U, __m512i __A) { 1812 return (__m512i)__builtin_ia32_selectd_512(__U, 1813 (__v16si)_mm512_abs_epi32(__A), 1814 (__v16si)_mm512_setzero_si512()); 1815 } 1816 1817 static __inline__ __m128 __DEFAULT_FN_ATTRS128_CONSTEXPR 1818 _mm_mask_add_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 1819 __A = _mm_add_ss(__A, __B); 1820 return __builtin_ia32_selectss_128(__U, __A, __W); 1821 } 1822 1823 static __inline__ __m128 __DEFAULT_FN_ATTRS128_CONSTEXPR 1824 _mm_maskz_add_ss(__mmask8 __U, __m128 __A, __m128 __B) { 1825 __A = _mm_add_ss(__A, __B); 1826 return __builtin_ia32_selectss_128(__U, __A, _mm_setzero_ps()); 1827 } 1828 1829 #define _mm_add_round_ss(A, B, R) \ 1830 ((__m128)__builtin_ia32_addss_round_mask((__v4sf)(__m128)(A), \ 1831 (__v4sf)(__m128)(B), \ 1832 (__v4sf)_mm_setzero_ps(), \ 1833 (__mmask8)-1, (int)(R))) 1834 1835 #define _mm_mask_add_round_ss(W, U, A, B, R) \ 1836 ((__m128)__builtin_ia32_addss_round_mask((__v4sf)(__m128)(A), \ 1837 (__v4sf)(__m128)(B), \ 1838 (__v4sf)(__m128)(W), (__mmask8)(U), \ 1839 (int)(R))) 1840 1841 #define _mm_maskz_add_round_ss(U, A, B, R) \ 1842 ((__m128)__builtin_ia32_addss_round_mask((__v4sf)(__m128)(A), \ 1843 (__v4sf)(__m128)(B), \ 1844 (__v4sf)_mm_setzero_ps(), \ 1845 (__mmask8)(U), (int)(R))) 1846 1847 static __inline__ __m128d __DEFAULT_FN_ATTRS128_CONSTEXPR 1848 _mm_mask_add_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 1849 __A = _mm_add_sd(__A, __B); 1850 return __builtin_ia32_selectsd_128(__U, __A, __W); 1851 } 1852 1853 static __inline__ __m128d __DEFAULT_FN_ATTRS128_CONSTEXPR 1854 _mm_maskz_add_sd(__mmask8 __U, __m128d __A, __m128d __B) { 1855 __A = _mm_add_sd(__A, __B); 1856 return __builtin_ia32_selectsd_128(__U, __A, _mm_setzero_pd()); 1857 } 1858 #define _mm_add_round_sd(A, B, R) \ 1859 ((__m128d)__builtin_ia32_addsd_round_mask((__v2df)(__m128d)(A), \ 1860 (__v2df)(__m128d)(B), \ 1861 (__v2df)_mm_setzero_pd(), \ 1862 (__mmask8)-1, (int)(R))) 1863 1864 #define _mm_mask_add_round_sd(W, U, A, B, R) \ 1865 ((__m128d)__builtin_ia32_addsd_round_mask((__v2df)(__m128d)(A), \ 1866 (__v2df)(__m128d)(B), \ 1867 (__v2df)(__m128d)(W), \ 1868 (__mmask8)(U), (int)(R))) 1869 1870 #define _mm_maskz_add_round_sd(U, A, B, R) \ 1871 ((__m128d)__builtin_ia32_addsd_round_mask((__v2df)(__m128d)(A), \ 1872 (__v2df)(__m128d)(B), \ 1873 (__v2df)_mm_setzero_pd(), \ 1874 (__mmask8)(U), (int)(R))) 1875 1876 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 1877 _mm512_mask_add_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 1878 return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U, 1879 (__v8df)_mm512_add_pd(__A, __B), 1880 (__v8df)__W); 1881 } 1882 1883 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 1884 _mm512_maskz_add_pd(__mmask8 __U, __m512d __A, __m512d __B) { 1885 return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U, 1886 (__v8df)_mm512_add_pd(__A, __B), 1887 (__v8df)_mm512_setzero_pd()); 1888 } 1889 1890 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 1891 _mm512_mask_add_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 1892 return (__m512)__builtin_ia32_selectps_512((__mmask16)__U, 1893 (__v16sf)_mm512_add_ps(__A, __B), 1894 (__v16sf)__W); 1895 } 1896 1897 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 1898 _mm512_maskz_add_ps(__mmask16 __U, __m512 __A, __m512 __B) { 1899 return (__m512)__builtin_ia32_selectps_512((__mmask16)__U, 1900 (__v16sf)_mm512_add_ps(__A, __B), 1901 (__v16sf)_mm512_setzero_ps()); 1902 } 1903 1904 #define _mm512_add_round_pd(A, B, R) \ 1905 ((__m512d)__builtin_ia32_addpd512((__v8df)(__m512d)(A), \ 1906 (__v8df)(__m512d)(B), (int)(R))) 1907 1908 #define _mm512_mask_add_round_pd(W, U, A, B, R) \ 1909 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 1910 (__v8df)_mm512_add_round_pd((A), (B), (R)), \ 1911 (__v8df)(__m512d)(W))) 1912 1913 #define _mm512_maskz_add_round_pd(U, A, B, R) \ 1914 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 1915 (__v8df)_mm512_add_round_pd((A), (B), (R)), \ 1916 (__v8df)_mm512_setzero_pd())) 1917 1918 #define _mm512_add_round_ps(A, B, R) \ 1919 ((__m512)__builtin_ia32_addps512((__v16sf)(__m512)(A), \ 1920 (__v16sf)(__m512)(B), (int)(R))) 1921 1922 #define _mm512_mask_add_round_ps(W, U, A, B, R) \ 1923 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 1924 (__v16sf)_mm512_add_round_ps((A), (B), (R)), \ 1925 (__v16sf)(__m512)(W))) 1926 1927 #define _mm512_maskz_add_round_ps(U, A, B, R) \ 1928 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 1929 (__v16sf)_mm512_add_round_ps((A), (B), (R)), \ 1930 (__v16sf)_mm512_setzero_ps())) 1931 1932 static __inline__ __m128 __DEFAULT_FN_ATTRS128_CONSTEXPR 1933 _mm_mask_sub_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 1934 __A = _mm_sub_ss(__A, __B); 1935 return __builtin_ia32_selectss_128(__U, __A, __W); 1936 } 1937 1938 static __inline__ __m128 __DEFAULT_FN_ATTRS128_CONSTEXPR 1939 _mm_maskz_sub_ss(__mmask8 __U, __m128 __A, __m128 __B) { 1940 __A = _mm_sub_ss(__A, __B); 1941 return __builtin_ia32_selectss_128(__U, __A, _mm_setzero_ps()); 1942 } 1943 #define _mm_sub_round_ss(A, B, R) \ 1944 ((__m128)__builtin_ia32_subss_round_mask((__v4sf)(__m128)(A), \ 1945 (__v4sf)(__m128)(B), \ 1946 (__v4sf)_mm_setzero_ps(), \ 1947 (__mmask8)-1, (int)(R))) 1948 1949 #define _mm_mask_sub_round_ss(W, U, A, B, R) \ 1950 ((__m128)__builtin_ia32_subss_round_mask((__v4sf)(__m128)(A), \ 1951 (__v4sf)(__m128)(B), \ 1952 (__v4sf)(__m128)(W), (__mmask8)(U), \ 1953 (int)(R))) 1954 1955 #define _mm_maskz_sub_round_ss(U, A, B, R) \ 1956 ((__m128)__builtin_ia32_subss_round_mask((__v4sf)(__m128)(A), \ 1957 (__v4sf)(__m128)(B), \ 1958 (__v4sf)_mm_setzero_ps(), \ 1959 (__mmask8)(U), (int)(R))) 1960 1961 static __inline__ __m128d __DEFAULT_FN_ATTRS128_CONSTEXPR 1962 _mm_mask_sub_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 1963 __A = _mm_sub_sd(__A, __B); 1964 return __builtin_ia32_selectsd_128(__U, __A, __W); 1965 } 1966 1967 static __inline__ __m128d __DEFAULT_FN_ATTRS128_CONSTEXPR 1968 _mm_maskz_sub_sd(__mmask8 __U, __m128d __A, __m128d __B) { 1969 __A = _mm_sub_sd(__A, __B); 1970 return __builtin_ia32_selectsd_128(__U, __A, _mm_setzero_pd()); 1971 } 1972 1973 #define _mm_sub_round_sd(A, B, R) \ 1974 ((__m128d)__builtin_ia32_subsd_round_mask((__v2df)(__m128d)(A), \ 1975 (__v2df)(__m128d)(B), \ 1976 (__v2df)_mm_setzero_pd(), \ 1977 (__mmask8)-1, (int)(R))) 1978 1979 #define _mm_mask_sub_round_sd(W, U, A, B, R) \ 1980 ((__m128d)__builtin_ia32_subsd_round_mask((__v2df)(__m128d)(A), \ 1981 (__v2df)(__m128d)(B), \ 1982 (__v2df)(__m128d)(W), \ 1983 (__mmask8)(U), (int)(R))) 1984 1985 #define _mm_maskz_sub_round_sd(U, A, B, R) \ 1986 ((__m128d)__builtin_ia32_subsd_round_mask((__v2df)(__m128d)(A), \ 1987 (__v2df)(__m128d)(B), \ 1988 (__v2df)_mm_setzero_pd(), \ 1989 (__mmask8)(U), (int)(R))) 1990 1991 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 1992 _mm512_mask_sub_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 1993 return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U, 1994 (__v8df)_mm512_sub_pd(__A, __B), 1995 (__v8df)__W); 1996 } 1997 1998 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 1999 _mm512_maskz_sub_pd(__mmask8 __U, __m512d __A, __m512d __B) { 2000 return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U, 2001 (__v8df)_mm512_sub_pd(__A, __B), 2002 (__v8df)_mm512_setzero_pd()); 2003 } 2004 2005 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2006 _mm512_mask_sub_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 2007 return (__m512)__builtin_ia32_selectps_512((__mmask16)__U, 2008 (__v16sf)_mm512_sub_ps(__A, __B), 2009 (__v16sf)__W); 2010 } 2011 2012 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2013 _mm512_maskz_sub_ps(__mmask16 __U, __m512 __A, __m512 __B) { 2014 return (__m512)__builtin_ia32_selectps_512((__mmask16)__U, 2015 (__v16sf)_mm512_sub_ps(__A, __B), 2016 (__v16sf)_mm512_setzero_ps()); 2017 } 2018 2019 #define _mm512_sub_round_pd(A, B, R) \ 2020 ((__m512d)__builtin_ia32_subpd512((__v8df)(__m512d)(A), \ 2021 (__v8df)(__m512d)(B), (int)(R))) 2022 2023 #define _mm512_mask_sub_round_pd(W, U, A, B, R) \ 2024 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 2025 (__v8df)_mm512_sub_round_pd((A), (B), (R)), \ 2026 (__v8df)(__m512d)(W))) 2027 2028 #define _mm512_maskz_sub_round_pd(U, A, B, R) \ 2029 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 2030 (__v8df)_mm512_sub_round_pd((A), (B), (R)), \ 2031 (__v8df)_mm512_setzero_pd())) 2032 2033 #define _mm512_sub_round_ps(A, B, R) \ 2034 ((__m512)__builtin_ia32_subps512((__v16sf)(__m512)(A), \ 2035 (__v16sf)(__m512)(B), (int)(R))) 2036 2037 #define _mm512_mask_sub_round_ps(W, U, A, B, R) \ 2038 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 2039 (__v16sf)_mm512_sub_round_ps((A), (B), (R)), \ 2040 (__v16sf)(__m512)(W))) 2041 2042 #define _mm512_maskz_sub_round_ps(U, A, B, R) \ 2043 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 2044 (__v16sf)_mm512_sub_round_ps((A), (B), (R)), \ 2045 (__v16sf)_mm512_setzero_ps())) 2046 2047 static __inline__ __m128 __DEFAULT_FN_ATTRS128_CONSTEXPR 2048 _mm_mask_mul_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 2049 __A = _mm_mul_ss(__A, __B); 2050 return __builtin_ia32_selectss_128(__U, __A, __W); 2051 } 2052 2053 static __inline__ __m128 __DEFAULT_FN_ATTRS128_CONSTEXPR 2054 _mm_maskz_mul_ss(__mmask8 __U, __m128 __A, __m128 __B) { 2055 __A = _mm_mul_ss(__A, __B); 2056 return __builtin_ia32_selectss_128(__U, __A, _mm_setzero_ps()); 2057 } 2058 #define _mm_mul_round_ss(A, B, R) \ 2059 ((__m128)__builtin_ia32_mulss_round_mask((__v4sf)(__m128)(A), \ 2060 (__v4sf)(__m128)(B), \ 2061 (__v4sf)_mm_setzero_ps(), \ 2062 (__mmask8)-1, (int)(R))) 2063 2064 #define _mm_mask_mul_round_ss(W, U, A, B, R) \ 2065 ((__m128)__builtin_ia32_mulss_round_mask((__v4sf)(__m128)(A), \ 2066 (__v4sf)(__m128)(B), \ 2067 (__v4sf)(__m128)(W), (__mmask8)(U), \ 2068 (int)(R))) 2069 2070 #define _mm_maskz_mul_round_ss(U, A, B, R) \ 2071 ((__m128)__builtin_ia32_mulss_round_mask((__v4sf)(__m128)(A), \ 2072 (__v4sf)(__m128)(B), \ 2073 (__v4sf)_mm_setzero_ps(), \ 2074 (__mmask8)(U), (int)(R))) 2075 2076 static __inline__ __m128d __DEFAULT_FN_ATTRS128_CONSTEXPR 2077 _mm_mask_mul_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 2078 __A = _mm_mul_sd(__A, __B); 2079 return __builtin_ia32_selectsd_128(__U, __A, __W); 2080 } 2081 2082 static __inline__ __m128d __DEFAULT_FN_ATTRS128_CONSTEXPR 2083 _mm_maskz_mul_sd(__mmask8 __U, __m128d __A, __m128d __B) { 2084 __A = _mm_mul_sd(__A, __B); 2085 return __builtin_ia32_selectsd_128(__U, __A, _mm_setzero_pd()); 2086 } 2087 2088 #define _mm_mul_round_sd(A, B, R) \ 2089 ((__m128d)__builtin_ia32_mulsd_round_mask((__v2df)(__m128d)(A), \ 2090 (__v2df)(__m128d)(B), \ 2091 (__v2df)_mm_setzero_pd(), \ 2092 (__mmask8)-1, (int)(R))) 2093 2094 #define _mm_mask_mul_round_sd(W, U, A, B, R) \ 2095 ((__m128d)__builtin_ia32_mulsd_round_mask((__v2df)(__m128d)(A), \ 2096 (__v2df)(__m128d)(B), \ 2097 (__v2df)(__m128d)(W), \ 2098 (__mmask8)(U), (int)(R))) 2099 2100 #define _mm_maskz_mul_round_sd(U, A, B, R) \ 2101 ((__m128d)__builtin_ia32_mulsd_round_mask((__v2df)(__m128d)(A), \ 2102 (__v2df)(__m128d)(B), \ 2103 (__v2df)_mm_setzero_pd(), \ 2104 (__mmask8)(U), (int)(R))) 2105 2106 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2107 _mm512_mask_mul_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 2108 return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U, 2109 (__v8df)_mm512_mul_pd(__A, __B), 2110 (__v8df)__W); 2111 } 2112 2113 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2114 _mm512_maskz_mul_pd(__mmask8 __U, __m512d __A, __m512d __B) { 2115 return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U, 2116 (__v8df)_mm512_mul_pd(__A, __B), 2117 (__v8df)_mm512_setzero_pd()); 2118 } 2119 2120 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2121 _mm512_mask_mul_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 2122 return (__m512)__builtin_ia32_selectps_512((__mmask16)__U, 2123 (__v16sf)_mm512_mul_ps(__A, __B), 2124 (__v16sf)__W); 2125 } 2126 2127 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2128 _mm512_maskz_mul_ps(__mmask16 __U, __m512 __A, __m512 __B) { 2129 return (__m512)__builtin_ia32_selectps_512((__mmask16)__U, 2130 (__v16sf)_mm512_mul_ps(__A, __B), 2131 (__v16sf)_mm512_setzero_ps()); 2132 } 2133 2134 #define _mm512_mul_round_pd(A, B, R) \ 2135 ((__m512d)__builtin_ia32_mulpd512((__v8df)(__m512d)(A), \ 2136 (__v8df)(__m512d)(B), (int)(R))) 2137 2138 #define _mm512_mask_mul_round_pd(W, U, A, B, R) \ 2139 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 2140 (__v8df)_mm512_mul_round_pd((A), (B), (R)), \ 2141 (__v8df)(__m512d)(W))) 2142 2143 #define _mm512_maskz_mul_round_pd(U, A, B, R) \ 2144 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 2145 (__v8df)_mm512_mul_round_pd((A), (B), (R)), \ 2146 (__v8df)_mm512_setzero_pd())) 2147 2148 #define _mm512_mul_round_ps(A, B, R) \ 2149 ((__m512)__builtin_ia32_mulps512((__v16sf)(__m512)(A), \ 2150 (__v16sf)(__m512)(B), (int)(R))) 2151 2152 #define _mm512_mask_mul_round_ps(W, U, A, B, R) \ 2153 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 2154 (__v16sf)_mm512_mul_round_ps((A), (B), (R)), \ 2155 (__v16sf)(__m512)(W))) 2156 2157 #define _mm512_maskz_mul_round_ps(U, A, B, R) \ 2158 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 2159 (__v16sf)_mm512_mul_round_ps((A), (B), (R)), \ 2160 (__v16sf)_mm512_setzero_ps())) 2161 2162 static __inline__ __m128 __DEFAULT_FN_ATTRS128_CONSTEXPR 2163 _mm_mask_div_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 2164 __A = _mm_div_ss(__A, __B); 2165 return __builtin_ia32_selectss_128(__U, __A, __W); 2166 } 2167 2168 static __inline__ __m128 __DEFAULT_FN_ATTRS128_CONSTEXPR 2169 _mm_maskz_div_ss(__mmask8 __U, __m128 __A, __m128 __B) { 2170 __A = _mm_div_ss(__A, __B); 2171 return __builtin_ia32_selectss_128(__U, __A, _mm_setzero_ps()); 2172 } 2173 2174 #define _mm_div_round_ss(A, B, R) \ 2175 ((__m128)__builtin_ia32_divss_round_mask((__v4sf)(__m128)(A), \ 2176 (__v4sf)(__m128)(B), \ 2177 (__v4sf)_mm_setzero_ps(), \ 2178 (__mmask8)-1, (int)(R))) 2179 2180 #define _mm_mask_div_round_ss(W, U, A, B, R) \ 2181 ((__m128)__builtin_ia32_divss_round_mask((__v4sf)(__m128)(A), \ 2182 (__v4sf)(__m128)(B), \ 2183 (__v4sf)(__m128)(W), (__mmask8)(U), \ 2184 (int)(R))) 2185 2186 #define _mm_maskz_div_round_ss(U, A, B, R) \ 2187 ((__m128)__builtin_ia32_divss_round_mask((__v4sf)(__m128)(A), \ 2188 (__v4sf)(__m128)(B), \ 2189 (__v4sf)_mm_setzero_ps(), \ 2190 (__mmask8)(U), (int)(R))) 2191 2192 static __inline__ __m128d __DEFAULT_FN_ATTRS128_CONSTEXPR 2193 _mm_mask_div_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 2194 __A = _mm_div_sd(__A, __B); 2195 return __builtin_ia32_selectsd_128(__U, __A, __W); 2196 } 2197 2198 static __inline__ __m128d __DEFAULT_FN_ATTRS128_CONSTEXPR 2199 _mm_maskz_div_sd(__mmask8 __U, __m128d __A, __m128d __B) { 2200 __A = _mm_div_sd(__A, __B); 2201 return __builtin_ia32_selectsd_128(__U, __A, _mm_setzero_pd()); 2202 } 2203 2204 #define _mm_div_round_sd(A, B, R) \ 2205 ((__m128d)__builtin_ia32_divsd_round_mask((__v2df)(__m128d)(A), \ 2206 (__v2df)(__m128d)(B), \ 2207 (__v2df)_mm_setzero_pd(), \ 2208 (__mmask8)-1, (int)(R))) 2209 2210 #define _mm_mask_div_round_sd(W, U, A, B, R) \ 2211 ((__m128d)__builtin_ia32_divsd_round_mask((__v2df)(__m128d)(A), \ 2212 (__v2df)(__m128d)(B), \ 2213 (__v2df)(__m128d)(W), \ 2214 (__mmask8)(U), (int)(R))) 2215 2216 #define _mm_maskz_div_round_sd(U, A, B, R) \ 2217 ((__m128d)__builtin_ia32_divsd_round_mask((__v2df)(__m128d)(A), \ 2218 (__v2df)(__m128d)(B), \ 2219 (__v2df)_mm_setzero_pd(), \ 2220 (__mmask8)(U), (int)(R))) 2221 2222 static __inline __m512d 2223 __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_div_pd(__m512d __a, __m512d __b) { 2224 return (__m512d)((__v8df)__a/(__v8df)__b); 2225 } 2226 2227 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2228 _mm512_mask_div_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 2229 return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U, 2230 (__v8df)_mm512_div_pd(__A, __B), 2231 (__v8df)__W); 2232 } 2233 2234 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2235 _mm512_maskz_div_pd(__mmask8 __U, __m512d __A, __m512d __B) { 2236 return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U, 2237 (__v8df)_mm512_div_pd(__A, __B), 2238 (__v8df)_mm512_setzero_pd()); 2239 } 2240 2241 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2242 _mm512_div_ps(__m512 __a, __m512 __b) { 2243 return (__m512)((__v16sf)__a/(__v16sf)__b); 2244 } 2245 2246 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2247 _mm512_mask_div_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 2248 return (__m512)__builtin_ia32_selectps_512((__mmask16)__U, 2249 (__v16sf)_mm512_div_ps(__A, __B), 2250 (__v16sf)__W); 2251 } 2252 2253 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2254 _mm512_maskz_div_ps(__mmask16 __U, __m512 __A, __m512 __B) { 2255 return (__m512)__builtin_ia32_selectps_512((__mmask16)__U, 2256 (__v16sf)_mm512_div_ps(__A, __B), 2257 (__v16sf)_mm512_setzero_ps()); 2258 } 2259 2260 #define _mm512_div_round_pd(A, B, R) \ 2261 ((__m512d)__builtin_ia32_divpd512((__v8df)(__m512d)(A), \ 2262 (__v8df)(__m512d)(B), (int)(R))) 2263 2264 #define _mm512_mask_div_round_pd(W, U, A, B, R) \ 2265 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 2266 (__v8df)_mm512_div_round_pd((A), (B), (R)), \ 2267 (__v8df)(__m512d)(W))) 2268 2269 #define _mm512_maskz_div_round_pd(U, A, B, R) \ 2270 ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \ 2271 (__v8df)_mm512_div_round_pd((A), (B), (R)), \ 2272 (__v8df)_mm512_setzero_pd())) 2273 2274 #define _mm512_div_round_ps(A, B, R) \ 2275 ((__m512)__builtin_ia32_divps512((__v16sf)(__m512)(A), \ 2276 (__v16sf)(__m512)(B), (int)(R))) 2277 2278 #define _mm512_mask_div_round_ps(W, U, A, B, R) \ 2279 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 2280 (__v16sf)_mm512_div_round_ps((A), (B), (R)), \ 2281 (__v16sf)(__m512)(W))) 2282 2283 #define _mm512_maskz_div_round_ps(U, A, B, R) \ 2284 ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \ 2285 (__v16sf)_mm512_div_round_ps((A), (B), (R)), \ 2286 (__v16sf)_mm512_setzero_ps())) 2287 2288 #define _mm512_roundscale_ps(A, B) \ 2289 ((__m512)__builtin_ia32_rndscaleps_mask((__v16sf)(__m512)(A), (int)(B), \ 2290 (__v16sf)_mm512_undefined_ps(), \ 2291 (__mmask16)-1, \ 2292 _MM_FROUND_CUR_DIRECTION)) 2293 2294 #define _mm512_mask_roundscale_ps(A, B, C, imm) \ 2295 ((__m512)__builtin_ia32_rndscaleps_mask((__v16sf)(__m512)(C), (int)(imm), \ 2296 (__v16sf)(__m512)(A), (__mmask16)(B), \ 2297 _MM_FROUND_CUR_DIRECTION)) 2298 2299 #define _mm512_maskz_roundscale_ps(A, B, imm) \ 2300 ((__m512)__builtin_ia32_rndscaleps_mask((__v16sf)(__m512)(B), (int)(imm), \ 2301 (__v16sf)_mm512_setzero_ps(), \ 2302 (__mmask16)(A), \ 2303 _MM_FROUND_CUR_DIRECTION)) 2304 2305 #define _mm512_mask_roundscale_round_ps(A, B, C, imm, R) \ 2306 ((__m512)__builtin_ia32_rndscaleps_mask((__v16sf)(__m512)(C), (int)(imm), \ 2307 (__v16sf)(__m512)(A), (__mmask16)(B), \ 2308 (int)(R))) 2309 2310 #define _mm512_maskz_roundscale_round_ps(A, B, imm, R) \ 2311 ((__m512)__builtin_ia32_rndscaleps_mask((__v16sf)(__m512)(B), (int)(imm), \ 2312 (__v16sf)_mm512_setzero_ps(), \ 2313 (__mmask16)(A), (int)(R))) 2314 2315 #define _mm512_roundscale_round_ps(A, imm, R) \ 2316 ((__m512)__builtin_ia32_rndscaleps_mask((__v16sf)(__m512)(A), (int)(imm), \ 2317 (__v16sf)_mm512_undefined_ps(), \ 2318 (__mmask16)-1, (int)(R))) 2319 2320 #define _mm512_roundscale_pd(A, B) \ 2321 ((__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(__m512d)(A), (int)(B), \ 2322 (__v8df)_mm512_undefined_pd(), \ 2323 (__mmask8)-1, \ 2324 _MM_FROUND_CUR_DIRECTION)) 2325 2326 #define _mm512_mask_roundscale_pd(A, B, C, imm) \ 2327 ((__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(__m512d)(C), (int)(imm), \ 2328 (__v8df)(__m512d)(A), (__mmask8)(B), \ 2329 _MM_FROUND_CUR_DIRECTION)) 2330 2331 #define _mm512_maskz_roundscale_pd(A, B, imm) \ 2332 ((__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(__m512d)(B), (int)(imm), \ 2333 (__v8df)_mm512_setzero_pd(), \ 2334 (__mmask8)(A), \ 2335 _MM_FROUND_CUR_DIRECTION)) 2336 2337 #define _mm512_mask_roundscale_round_pd(A, B, C, imm, R) \ 2338 ((__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(__m512d)(C), (int)(imm), \ 2339 (__v8df)(__m512d)(A), (__mmask8)(B), \ 2340 (int)(R))) 2341 2342 #define _mm512_maskz_roundscale_round_pd(A, B, imm, R) \ 2343 ((__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(__m512d)(B), (int)(imm), \ 2344 (__v8df)_mm512_setzero_pd(), \ 2345 (__mmask8)(A), (int)(R))) 2346 2347 #define _mm512_roundscale_round_pd(A, imm, R) \ 2348 ((__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(__m512d)(A), (int)(imm), \ 2349 (__v8df)_mm512_undefined_pd(), \ 2350 (__mmask8)-1, (int)(R))) 2351 2352 #define _mm512_fmadd_round_pd(A, B, C, R) \ 2353 ((__m512d)__builtin_ia32_vfmaddpd512_mask((__v8df)(__m512d)(A), \ 2354 (__v8df)(__m512d)(B), \ 2355 (__v8df)(__m512d)(C), \ 2356 (__mmask8)-1, (int)(R))) 2357 2358 2359 #define _mm512_mask_fmadd_round_pd(A, U, B, C, R) \ 2360 ((__m512d)__builtin_ia32_vfmaddpd512_mask((__v8df)(__m512d)(A), \ 2361 (__v8df)(__m512d)(B), \ 2362 (__v8df)(__m512d)(C), \ 2363 (__mmask8)(U), (int)(R))) 2364 2365 2366 #define _mm512_mask3_fmadd_round_pd(A, B, C, U, R) \ 2367 ((__m512d)__builtin_ia32_vfmaddpd512_mask3((__v8df)(__m512d)(A), \ 2368 (__v8df)(__m512d)(B), \ 2369 (__v8df)(__m512d)(C), \ 2370 (__mmask8)(U), (int)(R))) 2371 2372 2373 #define _mm512_maskz_fmadd_round_pd(U, A, B, C, R) \ 2374 ((__m512d)__builtin_ia32_vfmaddpd512_maskz((__v8df)(__m512d)(A), \ 2375 (__v8df)(__m512d)(B), \ 2376 (__v8df)(__m512d)(C), \ 2377 (__mmask8)(U), (int)(R))) 2378 2379 2380 #define _mm512_fmsub_round_pd(A, B, C, R) \ 2381 ((__m512d)__builtin_ia32_vfmaddpd512_mask((__v8df)(__m512d)(A), \ 2382 (__v8df)(__m512d)(B), \ 2383 -(__v8df)(__m512d)(C), \ 2384 (__mmask8)-1, (int)(R))) 2385 2386 2387 #define _mm512_mask_fmsub_round_pd(A, U, B, C, R) \ 2388 ((__m512d)__builtin_ia32_vfmaddpd512_mask((__v8df)(__m512d)(A), \ 2389 (__v8df)(__m512d)(B), \ 2390 -(__v8df)(__m512d)(C), \ 2391 (__mmask8)(U), (int)(R))) 2392 2393 2394 #define _mm512_maskz_fmsub_round_pd(U, A, B, C, R) \ 2395 ((__m512d)__builtin_ia32_vfmaddpd512_maskz((__v8df)(__m512d)(A), \ 2396 (__v8df)(__m512d)(B), \ 2397 -(__v8df)(__m512d)(C), \ 2398 (__mmask8)(U), (int)(R))) 2399 2400 2401 #define _mm512_fnmadd_round_pd(A, B, C, R) \ 2402 ((__m512d)__builtin_ia32_vfmaddpd512_mask(-(__v8df)(__m512d)(A), \ 2403 (__v8df)(__m512d)(B), \ 2404 (__v8df)(__m512d)(C), \ 2405 (__mmask8)-1, (int)(R))) 2406 2407 2408 #define _mm512_mask3_fnmadd_round_pd(A, B, C, U, R) \ 2409 ((__m512d)__builtin_ia32_vfmaddpd512_mask3(-(__v8df)(__m512d)(A), \ 2410 (__v8df)(__m512d)(B), \ 2411 (__v8df)(__m512d)(C), \ 2412 (__mmask8)(U), (int)(R))) 2413 2414 2415 #define _mm512_maskz_fnmadd_round_pd(U, A, B, C, R) \ 2416 ((__m512d)__builtin_ia32_vfmaddpd512_maskz(-(__v8df)(__m512d)(A), \ 2417 (__v8df)(__m512d)(B), \ 2418 (__v8df)(__m512d)(C), \ 2419 (__mmask8)(U), (int)(R))) 2420 2421 2422 #define _mm512_fnmsub_round_pd(A, B, C, R) \ 2423 ((__m512d)__builtin_ia32_vfmaddpd512_mask(-(__v8df)(__m512d)(A), \ 2424 (__v8df)(__m512d)(B), \ 2425 -(__v8df)(__m512d)(C), \ 2426 (__mmask8)-1, (int)(R))) 2427 2428 2429 #define _mm512_maskz_fnmsub_round_pd(U, A, B, C, R) \ 2430 ((__m512d)__builtin_ia32_vfmaddpd512_maskz(-(__v8df)(__m512d)(A), \ 2431 (__v8df)(__m512d)(B), \ 2432 -(__v8df)(__m512d)(C), \ 2433 (__mmask8)(U), (int)(R))) 2434 2435 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2436 _mm512_fmadd_pd(__m512d __A, __m512d __B, __m512d __C) { 2437 return (__m512d)__builtin_elementwise_fma((__v8df)__A, (__v8df)__B, 2438 (__v8df)__C); 2439 } 2440 2441 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2442 _mm512_mask_fmadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 2443 return (__m512d)__builtin_ia32_selectpd_512( 2444 (__mmask8)__U, (__v8df)_mm512_fmadd_pd(__A, __B, __C), (__v8df)__A); 2445 } 2446 2447 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2448 _mm512_mask3_fmadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 2449 return (__m512d)__builtin_ia32_selectpd_512( 2450 (__mmask8)__U, (__v8df)_mm512_fmadd_pd(__A, __B, __C), (__v8df)__C); 2451 } 2452 2453 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2454 _mm512_maskz_fmadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 2455 return (__m512d)__builtin_ia32_selectpd_512( 2456 (__mmask8)__U, (__v8df)_mm512_fmadd_pd(__A, __B, __C), 2457 (__v8df)_mm512_setzero_pd()); 2458 } 2459 2460 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2461 _mm512_fmsub_pd(__m512d __A, __m512d __B, __m512d __C) { 2462 return (__m512d)__builtin_elementwise_fma((__v8df)__A, (__v8df)__B, 2463 -(__v8df)__C); 2464 } 2465 2466 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2467 _mm512_mask_fmsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 2468 return (__m512d)__builtin_ia32_selectpd_512( 2469 (__mmask8)__U, (__v8df)_mm512_fmsub_pd(__A, __B, __C), (__v8df)__A); 2470 } 2471 2472 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2473 _mm512_mask3_fmsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 2474 return (__m512d)__builtin_ia32_selectpd_512( 2475 (__mmask8)__U, (__v8df)_mm512_fmsub_pd(__A, __B, __C), (__v8df)__C); 2476 } 2477 2478 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2479 _mm512_maskz_fmsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 2480 return (__m512d)__builtin_ia32_selectpd_512( 2481 (__mmask8)__U, (__v8df)_mm512_fmsub_pd(__A, __B, __C), 2482 (__v8df)_mm512_setzero_pd()); 2483 } 2484 2485 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2486 _mm512_fnmadd_pd(__m512d __A, __m512d __B, __m512d __C) { 2487 return (__m512d)__builtin_elementwise_fma(-(__v8df)__A, (__v8df)__B, 2488 (__v8df)__C); 2489 } 2490 2491 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2492 _mm512_mask_fnmadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 2493 return (__m512d)__builtin_ia32_selectpd_512( 2494 (__mmask8)__U, (__v8df)_mm512_fnmadd_pd(__A, __B, __C), (__v8df)__A); 2495 } 2496 2497 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2498 _mm512_mask3_fnmadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 2499 return (__m512d)__builtin_ia32_selectpd_512( 2500 (__mmask8)__U, (__v8df)_mm512_fnmadd_pd(__A, __B, __C), (__v8df)__C); 2501 } 2502 2503 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2504 _mm512_maskz_fnmadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 2505 return (__m512d)__builtin_ia32_selectpd_512( 2506 (__mmask8)__U, (__v8df)_mm512_fnmadd_pd(__A, __B, __C), 2507 (__v8df)_mm512_setzero_pd()); 2508 } 2509 2510 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2511 _mm512_fnmsub_pd(__m512d __A, __m512d __B, __m512d __C) { 2512 return (__m512d)__builtin_elementwise_fma(-(__v8df)__A, (__v8df)__B, 2513 -(__v8df)__C); 2514 } 2515 2516 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2517 _mm512_mask_fnmsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 2518 return (__m512d)__builtin_ia32_selectpd_512( 2519 (__mmask8)__U, (__v8df)_mm512_fnmsub_pd(__A, __B, __C), (__v8df)__A); 2520 } 2521 2522 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2523 _mm512_mask3_fnmsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 2524 return (__m512d)__builtin_ia32_selectpd_512( 2525 (__mmask8)__U, (__v8df)_mm512_fnmsub_pd(__A, __B, __C), (__v8df)__C); 2526 } 2527 2528 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 2529 _mm512_maskz_fnmsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 2530 return (__m512d)__builtin_ia32_selectpd_512( 2531 (__mmask8)__U, (__v8df)_mm512_fnmsub_pd(__A, __B, __C), 2532 (__v8df)_mm512_setzero_pd()); 2533 } 2534 2535 #define _mm512_fmadd_round_ps(A, B, C, R) \ 2536 ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \ 2537 (__v16sf)(__m512)(B), \ 2538 (__v16sf)(__m512)(C), \ 2539 (__mmask16)-1, (int)(R))) 2540 2541 2542 #define _mm512_mask_fmadd_round_ps(A, U, B, C, R) \ 2543 ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \ 2544 (__v16sf)(__m512)(B), \ 2545 (__v16sf)(__m512)(C), \ 2546 (__mmask16)(U), (int)(R))) 2547 2548 2549 #define _mm512_mask3_fmadd_round_ps(A, B, C, U, R) \ 2550 ((__m512)__builtin_ia32_vfmaddps512_mask3((__v16sf)(__m512)(A), \ 2551 (__v16sf)(__m512)(B), \ 2552 (__v16sf)(__m512)(C), \ 2553 (__mmask16)(U), (int)(R))) 2554 2555 2556 #define _mm512_maskz_fmadd_round_ps(U, A, B, C, R) \ 2557 ((__m512)__builtin_ia32_vfmaddps512_maskz((__v16sf)(__m512)(A), \ 2558 (__v16sf)(__m512)(B), \ 2559 (__v16sf)(__m512)(C), \ 2560 (__mmask16)(U), (int)(R))) 2561 2562 2563 #define _mm512_fmsub_round_ps(A, B, C, R) \ 2564 ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \ 2565 (__v16sf)(__m512)(B), \ 2566 -(__v16sf)(__m512)(C), \ 2567 (__mmask16)-1, (int)(R))) 2568 2569 2570 #define _mm512_mask_fmsub_round_ps(A, U, B, C, R) \ 2571 ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \ 2572 (__v16sf)(__m512)(B), \ 2573 -(__v16sf)(__m512)(C), \ 2574 (__mmask16)(U), (int)(R))) 2575 2576 2577 #define _mm512_maskz_fmsub_round_ps(U, A, B, C, R) \ 2578 ((__m512)__builtin_ia32_vfmaddps512_maskz((__v16sf)(__m512)(A), \ 2579 (__v16sf)(__m512)(B), \ 2580 -(__v16sf)(__m512)(C), \ 2581 (__mmask16)(U), (int)(R))) 2582 2583 2584 #define _mm512_fnmadd_round_ps(A, B, C, R) \ 2585 ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \ 2586 -(__v16sf)(__m512)(B), \ 2587 (__v16sf)(__m512)(C), \ 2588 (__mmask16)-1, (int)(R))) 2589 2590 2591 #define _mm512_mask3_fnmadd_round_ps(A, B, C, U, R) \ 2592 ((__m512)__builtin_ia32_vfmaddps512_mask3(-(__v16sf)(__m512)(A), \ 2593 (__v16sf)(__m512)(B), \ 2594 (__v16sf)(__m512)(C), \ 2595 (__mmask16)(U), (int)(R))) 2596 2597 2598 #define _mm512_maskz_fnmadd_round_ps(U, A, B, C, R) \ 2599 ((__m512)__builtin_ia32_vfmaddps512_maskz(-(__v16sf)(__m512)(A), \ 2600 (__v16sf)(__m512)(B), \ 2601 (__v16sf)(__m512)(C), \ 2602 (__mmask16)(U), (int)(R))) 2603 2604 2605 #define _mm512_fnmsub_round_ps(A, B, C, R) \ 2606 ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \ 2607 -(__v16sf)(__m512)(B), \ 2608 -(__v16sf)(__m512)(C), \ 2609 (__mmask16)-1, (int)(R))) 2610 2611 2612 #define _mm512_maskz_fnmsub_round_ps(U, A, B, C, R) \ 2613 ((__m512)__builtin_ia32_vfmaddps512_maskz(-(__v16sf)(__m512)(A), \ 2614 (__v16sf)(__m512)(B), \ 2615 -(__v16sf)(__m512)(C), \ 2616 (__mmask16)(U), (int)(R))) 2617 2618 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2619 _mm512_fmadd_ps(__m512 __A, __m512 __B, __m512 __C) { 2620 return (__m512)__builtin_elementwise_fma((__v16sf)__A, (__v16sf)__B, 2621 (__v16sf)__C); 2622 } 2623 2624 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2625 _mm512_mask_fmadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 2626 return (__m512)__builtin_ia32_selectps_512( 2627 (__mmask16)__U, (__v16sf)_mm512_fmadd_ps(__A, __B, __C), (__v16sf)__A); 2628 } 2629 2630 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2631 _mm512_mask3_fmadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 2632 return (__m512)__builtin_ia32_selectps_512( 2633 (__mmask16)__U, (__v16sf)_mm512_fmadd_ps(__A, __B, __C), (__v16sf)__C); 2634 } 2635 2636 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2637 _mm512_maskz_fmadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 2638 return (__m512)__builtin_ia32_selectps_512( 2639 (__mmask16)__U, (__v16sf)_mm512_fmadd_ps(__A, __B, __C), 2640 (__v16sf)_mm512_setzero_ps()); 2641 } 2642 2643 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2644 _mm512_fmsub_ps(__m512 __A, __m512 __B, __m512 __C) { 2645 return (__m512)__builtin_elementwise_fma((__v16sf)__A, (__v16sf)__B, 2646 -(__v16sf)__C); 2647 } 2648 2649 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2650 _mm512_mask_fmsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 2651 return (__m512)__builtin_ia32_selectps_512( 2652 (__mmask16)__U, (__v16sf)_mm512_fmsub_ps(__A, __B, __C), (__v16sf)__A); 2653 } 2654 2655 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2656 _mm512_mask3_fmsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 2657 return (__m512)__builtin_ia32_selectps_512( 2658 (__mmask16)__U, (__v16sf)_mm512_fmsub_ps(__A, __B, __C), (__v16sf)__C); 2659 } 2660 2661 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2662 _mm512_maskz_fmsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 2663 return (__m512)__builtin_ia32_selectps_512( 2664 (__mmask16)__U, (__v16sf)_mm512_fmsub_ps(__A, __B, __C), 2665 (__v16sf)_mm512_setzero_ps()); 2666 } 2667 2668 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2669 _mm512_fnmadd_ps(__m512 __A, __m512 __B, __m512 __C) { 2670 return (__m512)__builtin_elementwise_fma(-(__v16sf)__A, (__v16sf)__B, 2671 (__v16sf)__C); 2672 } 2673 2674 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2675 _mm512_mask_fnmadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 2676 return (__m512)__builtin_ia32_selectps_512( 2677 (__mmask16)__U, (__v16sf)_mm512_fnmadd_ps(__A, __B, __C), (__v16sf)__A); 2678 } 2679 2680 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2681 _mm512_mask3_fnmadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 2682 return (__m512)__builtin_ia32_selectps_512( 2683 (__mmask16)__U, (__v16sf)_mm512_fnmadd_ps(__A, __B, __C), (__v16sf)__C); 2684 } 2685 2686 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2687 _mm512_maskz_fnmadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 2688 return (__m512)__builtin_ia32_selectps_512( 2689 (__mmask16)__U, (__v16sf)_mm512_fnmadd_ps(__A, __B, __C), 2690 (__v16sf)_mm512_setzero_ps()); 2691 } 2692 2693 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2694 _mm512_fnmsub_ps(__m512 __A, __m512 __B, __m512 __C) { 2695 return (__m512)__builtin_elementwise_fma(-(__v16sf)__A, (__v16sf)__B, 2696 -(__v16sf)__C); 2697 } 2698 2699 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2700 _mm512_mask_fnmsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 2701 return (__m512)__builtin_ia32_selectps_512( 2702 (__mmask16)__U, (__v16sf)_mm512_fnmsub_ps(__A, __B, __C), (__v16sf)__A); 2703 } 2704 2705 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2706 _mm512_mask3_fnmsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 2707 return (__m512)__builtin_ia32_selectps_512( 2708 (__mmask16)__U, (__v16sf)_mm512_fnmsub_ps(__A, __B, __C), (__v16sf)__C); 2709 } 2710 2711 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 2712 _mm512_maskz_fnmsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 2713 return (__m512)__builtin_ia32_selectps_512( 2714 (__mmask16)__U, (__v16sf)_mm512_fnmsub_ps(__A, __B, __C), 2715 (__v16sf)_mm512_setzero_ps()); 2716 } 2717 2718 #define _mm512_fmaddsub_round_pd(A, B, C, R) \ 2719 ((__m512d)__builtin_ia32_vfmaddsubpd512_mask((__v8df)(__m512d)(A), \ 2720 (__v8df)(__m512d)(B), \ 2721 (__v8df)(__m512d)(C), \ 2722 (__mmask8)-1, (int)(R))) 2723 2724 2725 #define _mm512_mask_fmaddsub_round_pd(A, U, B, C, R) \ 2726 ((__m512d)__builtin_ia32_vfmaddsubpd512_mask((__v8df)(__m512d)(A), \ 2727 (__v8df)(__m512d)(B), \ 2728 (__v8df)(__m512d)(C), \ 2729 (__mmask8)(U), (int)(R))) 2730 2731 2732 #define _mm512_mask3_fmaddsub_round_pd(A, B, C, U, R) \ 2733 ((__m512d)__builtin_ia32_vfmaddsubpd512_mask3((__v8df)(__m512d)(A), \ 2734 (__v8df)(__m512d)(B), \ 2735 (__v8df)(__m512d)(C), \ 2736 (__mmask8)(U), (int)(R))) 2737 2738 2739 #define _mm512_maskz_fmaddsub_round_pd(U, A, B, C, R) \ 2740 ((__m512d)__builtin_ia32_vfmaddsubpd512_maskz((__v8df)(__m512d)(A), \ 2741 (__v8df)(__m512d)(B), \ 2742 (__v8df)(__m512d)(C), \ 2743 (__mmask8)(U), (int)(R))) 2744 2745 2746 #define _mm512_fmsubadd_round_pd(A, B, C, R) \ 2747 ((__m512d)__builtin_ia32_vfmaddsubpd512_mask((__v8df)(__m512d)(A), \ 2748 (__v8df)(__m512d)(B), \ 2749 -(__v8df)(__m512d)(C), \ 2750 (__mmask8)-1, (int)(R))) 2751 2752 2753 #define _mm512_mask_fmsubadd_round_pd(A, U, B, C, R) \ 2754 ((__m512d)__builtin_ia32_vfmaddsubpd512_mask((__v8df)(__m512d)(A), \ 2755 (__v8df)(__m512d)(B), \ 2756 -(__v8df)(__m512d)(C), \ 2757 (__mmask8)(U), (int)(R))) 2758 2759 2760 #define _mm512_maskz_fmsubadd_round_pd(U, A, B, C, R) \ 2761 ((__m512d)__builtin_ia32_vfmaddsubpd512_maskz((__v8df)(__m512d)(A), \ 2762 (__v8df)(__m512d)(B), \ 2763 -(__v8df)(__m512d)(C), \ 2764 (__mmask8)(U), (int)(R))) 2765 2766 2767 static __inline__ __m512d __DEFAULT_FN_ATTRS512 2768 _mm512_fmaddsub_pd(__m512d __A, __m512d __B, __m512d __C) 2769 { 2770 return (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) __A, 2771 (__v8df) __B, 2772 (__v8df) __C, 2773 (__mmask8) -1, 2774 _MM_FROUND_CUR_DIRECTION); 2775 } 2776 2777 static __inline__ __m512d __DEFAULT_FN_ATTRS512 2778 _mm512_mask_fmaddsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) 2779 { 2780 return (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) __A, 2781 (__v8df) __B, 2782 (__v8df) __C, 2783 (__mmask8) __U, 2784 _MM_FROUND_CUR_DIRECTION); 2785 } 2786 2787 static __inline__ __m512d __DEFAULT_FN_ATTRS512 2788 _mm512_mask3_fmaddsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) 2789 { 2790 return (__m512d) __builtin_ia32_vfmaddsubpd512_mask3 ((__v8df) __A, 2791 (__v8df) __B, 2792 (__v8df) __C, 2793 (__mmask8) __U, 2794 _MM_FROUND_CUR_DIRECTION); 2795 } 2796 2797 static __inline__ __m512d __DEFAULT_FN_ATTRS512 2798 _mm512_maskz_fmaddsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) 2799 { 2800 return (__m512d) __builtin_ia32_vfmaddsubpd512_maskz ((__v8df) __A, 2801 (__v8df) __B, 2802 (__v8df) __C, 2803 (__mmask8) __U, 2804 _MM_FROUND_CUR_DIRECTION); 2805 } 2806 2807 static __inline__ __m512d __DEFAULT_FN_ATTRS512 2808 _mm512_fmsubadd_pd(__m512d __A, __m512d __B, __m512d __C) 2809 { 2810 return (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) __A, 2811 (__v8df) __B, 2812 -(__v8df) __C, 2813 (__mmask8) -1, 2814 _MM_FROUND_CUR_DIRECTION); 2815 } 2816 2817 static __inline__ __m512d __DEFAULT_FN_ATTRS512 2818 _mm512_mask_fmsubadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) 2819 { 2820 return (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) __A, 2821 (__v8df) __B, 2822 -(__v8df) __C, 2823 (__mmask8) __U, 2824 _MM_FROUND_CUR_DIRECTION); 2825 } 2826 2827 static __inline__ __m512d __DEFAULT_FN_ATTRS512 2828 _mm512_maskz_fmsubadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) 2829 { 2830 return (__m512d) __builtin_ia32_vfmaddsubpd512_maskz ((__v8df) __A, 2831 (__v8df) __B, 2832 -(__v8df) __C, 2833 (__mmask8) __U, 2834 _MM_FROUND_CUR_DIRECTION); 2835 } 2836 2837 #define _mm512_fmaddsub_round_ps(A, B, C, R) \ 2838 ((__m512)__builtin_ia32_vfmaddsubps512_mask((__v16sf)(__m512)(A), \ 2839 (__v16sf)(__m512)(B), \ 2840 (__v16sf)(__m512)(C), \ 2841 (__mmask16)-1, (int)(R))) 2842 2843 2844 #define _mm512_mask_fmaddsub_round_ps(A, U, B, C, R) \ 2845 ((__m512)__builtin_ia32_vfmaddsubps512_mask((__v16sf)(__m512)(A), \ 2846 (__v16sf)(__m512)(B), \ 2847 (__v16sf)(__m512)(C), \ 2848 (__mmask16)(U), (int)(R))) 2849 2850 2851 #define _mm512_mask3_fmaddsub_round_ps(A, B, C, U, R) \ 2852 ((__m512)__builtin_ia32_vfmaddsubps512_mask3((__v16sf)(__m512)(A), \ 2853 (__v16sf)(__m512)(B), \ 2854 (__v16sf)(__m512)(C), \ 2855 (__mmask16)(U), (int)(R))) 2856 2857 2858 #define _mm512_maskz_fmaddsub_round_ps(U, A, B, C, R) \ 2859 ((__m512)__builtin_ia32_vfmaddsubps512_maskz((__v16sf)(__m512)(A), \ 2860 (__v16sf)(__m512)(B), \ 2861 (__v16sf)(__m512)(C), \ 2862 (__mmask16)(U), (int)(R))) 2863 2864 2865 #define _mm512_fmsubadd_round_ps(A, B, C, R) \ 2866 ((__m512)__builtin_ia32_vfmaddsubps512_mask((__v16sf)(__m512)(A), \ 2867 (__v16sf)(__m512)(B), \ 2868 -(__v16sf)(__m512)(C), \ 2869 (__mmask16)-1, (int)(R))) 2870 2871 2872 #define _mm512_mask_fmsubadd_round_ps(A, U, B, C, R) \ 2873 ((__m512)__builtin_ia32_vfmaddsubps512_mask((__v16sf)(__m512)(A), \ 2874 (__v16sf)(__m512)(B), \ 2875 -(__v16sf)(__m512)(C), \ 2876 (__mmask16)(U), (int)(R))) 2877 2878 2879 #define _mm512_maskz_fmsubadd_round_ps(U, A, B, C, R) \ 2880 ((__m512)__builtin_ia32_vfmaddsubps512_maskz((__v16sf)(__m512)(A), \ 2881 (__v16sf)(__m512)(B), \ 2882 -(__v16sf)(__m512)(C), \ 2883 (__mmask16)(U), (int)(R))) 2884 2885 2886 static __inline__ __m512 __DEFAULT_FN_ATTRS512 2887 _mm512_fmaddsub_ps(__m512 __A, __m512 __B, __m512 __C) 2888 { 2889 return (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) __A, 2890 (__v16sf) __B, 2891 (__v16sf) __C, 2892 (__mmask16) -1, 2893 _MM_FROUND_CUR_DIRECTION); 2894 } 2895 2896 static __inline__ __m512 __DEFAULT_FN_ATTRS512 2897 _mm512_mask_fmaddsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) 2898 { 2899 return (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) __A, 2900 (__v16sf) __B, 2901 (__v16sf) __C, 2902 (__mmask16) __U, 2903 _MM_FROUND_CUR_DIRECTION); 2904 } 2905 2906 static __inline__ __m512 __DEFAULT_FN_ATTRS512 2907 _mm512_mask3_fmaddsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) 2908 { 2909 return (__m512) __builtin_ia32_vfmaddsubps512_mask3 ((__v16sf) __A, 2910 (__v16sf) __B, 2911 (__v16sf) __C, 2912 (__mmask16) __U, 2913 _MM_FROUND_CUR_DIRECTION); 2914 } 2915 2916 static __inline__ __m512 __DEFAULT_FN_ATTRS512 2917 _mm512_maskz_fmaddsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) 2918 { 2919 return (__m512) __builtin_ia32_vfmaddsubps512_maskz ((__v16sf) __A, 2920 (__v16sf) __B, 2921 (__v16sf) __C, 2922 (__mmask16) __U, 2923 _MM_FROUND_CUR_DIRECTION); 2924 } 2925 2926 static __inline__ __m512 __DEFAULT_FN_ATTRS512 2927 _mm512_fmsubadd_ps(__m512 __A, __m512 __B, __m512 __C) 2928 { 2929 return (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) __A, 2930 (__v16sf) __B, 2931 -(__v16sf) __C, 2932 (__mmask16) -1, 2933 _MM_FROUND_CUR_DIRECTION); 2934 } 2935 2936 static __inline__ __m512 __DEFAULT_FN_ATTRS512 2937 _mm512_mask_fmsubadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) 2938 { 2939 return (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) __A, 2940 (__v16sf) __B, 2941 -(__v16sf) __C, 2942 (__mmask16) __U, 2943 _MM_FROUND_CUR_DIRECTION); 2944 } 2945 2946 static __inline__ __m512 __DEFAULT_FN_ATTRS512 2947 _mm512_maskz_fmsubadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) 2948 { 2949 return (__m512) __builtin_ia32_vfmaddsubps512_maskz ((__v16sf) __A, 2950 (__v16sf) __B, 2951 -(__v16sf) __C, 2952 (__mmask16) __U, 2953 _MM_FROUND_CUR_DIRECTION); 2954 } 2955 2956 #define _mm512_mask3_fmsub_round_pd(A, B, C, U, R) \ 2957 ((__m512d)__builtin_ia32_vfmsubpd512_mask3((__v8df)(__m512d)(A), \ 2958 (__v8df)(__m512d)(B), \ 2959 (__v8df)(__m512d)(C), \ 2960 (__mmask8)(U), (int)(R))) 2961 2962 #define _mm512_mask3_fmsub_round_ps(A, B, C, U, R) \ 2963 ((__m512)__builtin_ia32_vfmsubps512_mask3((__v16sf)(__m512)(A), \ 2964 (__v16sf)(__m512)(B), \ 2965 (__v16sf)(__m512)(C), \ 2966 (__mmask16)(U), (int)(R))) 2967 2968 #define _mm512_mask3_fmsubadd_round_pd(A, B, C, U, R) \ 2969 ((__m512d)__builtin_ia32_vfmsubaddpd512_mask3((__v8df)(__m512d)(A), \ 2970 (__v8df)(__m512d)(B), \ 2971 (__v8df)(__m512d)(C), \ 2972 (__mmask8)(U), (int)(R))) 2973 2974 2975 static __inline__ __m512d __DEFAULT_FN_ATTRS512 2976 _mm512_mask3_fmsubadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) 2977 { 2978 return (__m512d)__builtin_ia32_vfmsubaddpd512_mask3 ((__v8df) __A, 2979 (__v8df) __B, 2980 (__v8df) __C, 2981 (__mmask8) __U, 2982 _MM_FROUND_CUR_DIRECTION); 2983 } 2984 2985 #define _mm512_mask3_fmsubadd_round_ps(A, B, C, U, R) \ 2986 ((__m512)__builtin_ia32_vfmsubaddps512_mask3((__v16sf)(__m512)(A), \ 2987 (__v16sf)(__m512)(B), \ 2988 (__v16sf)(__m512)(C), \ 2989 (__mmask16)(U), (int)(R))) 2990 2991 2992 static __inline__ __m512 __DEFAULT_FN_ATTRS512 2993 _mm512_mask3_fmsubadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) 2994 { 2995 return (__m512)__builtin_ia32_vfmsubaddps512_mask3 ((__v16sf) __A, 2996 (__v16sf) __B, 2997 (__v16sf) __C, 2998 (__mmask16) __U, 2999 _MM_FROUND_CUR_DIRECTION); 3000 } 3001 3002 #define _mm512_mask_fnmadd_round_pd(A, U, B, C, R) \ 3003 ((__m512d)__builtin_ia32_vfmaddpd512_mask((__v8df)(__m512d)(A), \ 3004 -(__v8df)(__m512d)(B), \ 3005 (__v8df)(__m512d)(C), \ 3006 (__mmask8)(U), (int)(R))) 3007 3008 #define _mm512_mask_fnmadd_round_ps(A, U, B, C, R) \ 3009 ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \ 3010 -(__v16sf)(__m512)(B), \ 3011 (__v16sf)(__m512)(C), \ 3012 (__mmask16)(U), (int)(R))) 3013 3014 #define _mm512_mask_fnmsub_round_pd(A, U, B, C, R) \ 3015 ((__m512d)__builtin_ia32_vfmaddpd512_mask((__v8df)(__m512d)(A), \ 3016 -(__v8df)(__m512d)(B), \ 3017 -(__v8df)(__m512d)(C), \ 3018 (__mmask8)(U), (int)(R))) 3019 3020 3021 #define _mm512_mask3_fnmsub_round_pd(A, B, C, U, R) \ 3022 ((__m512d)__builtin_ia32_vfmsubpd512_mask3(-(__v8df)(__m512d)(A), \ 3023 (__v8df)(__m512d)(B), \ 3024 (__v8df)(__m512d)(C), \ 3025 (__mmask8)(U), (int)(R))) 3026 3027 #define _mm512_mask_fnmsub_round_ps(A, U, B, C, R) \ 3028 ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \ 3029 -(__v16sf)(__m512)(B), \ 3030 -(__v16sf)(__m512)(C), \ 3031 (__mmask16)(U), (int)(R))) 3032 3033 3034 #define _mm512_mask3_fnmsub_round_ps(A, B, C, U, R) \ 3035 ((__m512)__builtin_ia32_vfmsubps512_mask3(-(__v16sf)(__m512)(A), \ 3036 (__v16sf)(__m512)(B), \ 3037 (__v16sf)(__m512)(C), \ 3038 (__mmask16)(U), (int)(R))) 3039 3040 /* Vector permutations */ 3041 3042 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 3043 _mm512_permutex2var_epi32(__m512i __A, __m512i __I, __m512i __B) { 3044 return (__m512i)__builtin_ia32_vpermi2vard512((__v16si)__A, (__v16si) __I, 3045 (__v16si) __B); 3046 } 3047 3048 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 3049 _mm512_mask_permutex2var_epi32(__m512i __A, __mmask16 __U, __m512i __I, 3050 __m512i __B) { 3051 return (__m512i)__builtin_ia32_selectd_512(__U, 3052 (__v16si)_mm512_permutex2var_epi32(__A, __I, __B), 3053 (__v16si)__A); 3054 } 3055 3056 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 3057 _mm512_mask2_permutex2var_epi32(__m512i __A, __m512i __I, __mmask16 __U, 3058 __m512i __B) { 3059 return (__m512i)__builtin_ia32_selectd_512(__U, 3060 (__v16si)_mm512_permutex2var_epi32(__A, __I, __B), 3061 (__v16si)__I); 3062 } 3063 3064 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 3065 _mm512_maskz_permutex2var_epi32(__mmask16 __U, __m512i __A, __m512i __I, 3066 __m512i __B) { 3067 return (__m512i)__builtin_ia32_selectd_512(__U, 3068 (__v16si)_mm512_permutex2var_epi32(__A, __I, __B), 3069 (__v16si)_mm512_setzero_si512()); 3070 } 3071 3072 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 3073 _mm512_permutex2var_epi64(__m512i __A, __m512i __I, __m512i __B) { 3074 return (__m512i)__builtin_ia32_vpermi2varq512((__v8di)__A, (__v8di) __I, 3075 (__v8di) __B); 3076 } 3077 3078 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 3079 _mm512_mask_permutex2var_epi64(__m512i __A, __mmask8 __U, __m512i __I, 3080 __m512i __B) { 3081 return (__m512i)__builtin_ia32_selectq_512(__U, 3082 (__v8di)_mm512_permutex2var_epi64(__A, __I, __B), 3083 (__v8di)__A); 3084 } 3085 3086 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 3087 _mm512_mask2_permutex2var_epi64(__m512i __A, __m512i __I, __mmask8 __U, 3088 __m512i __B) { 3089 return (__m512i)__builtin_ia32_selectq_512(__U, 3090 (__v8di)_mm512_permutex2var_epi64(__A, __I, __B), 3091 (__v8di)__I); 3092 } 3093 3094 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 3095 _mm512_maskz_permutex2var_epi64(__mmask8 __U, __m512i __A, __m512i __I, 3096 __m512i __B) { 3097 return (__m512i)__builtin_ia32_selectq_512(__U, 3098 (__v8di)_mm512_permutex2var_epi64(__A, __I, __B), 3099 (__v8di)_mm512_setzero_si512()); 3100 } 3101 3102 #define _mm512_alignr_epi64(A, B, I) \ 3103 ((__m512i)__builtin_ia32_alignq512((__v8di)(__m512i)(A), \ 3104 (__v8di)(__m512i)(B), (int)(I))) 3105 3106 #define _mm512_mask_alignr_epi64(W, U, A, B, imm) \ 3107 ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \ 3108 (__v8di)_mm512_alignr_epi64((A), (B), (imm)), \ 3109 (__v8di)(__m512i)(W))) 3110 3111 #define _mm512_maskz_alignr_epi64(U, A, B, imm) \ 3112 ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \ 3113 (__v8di)_mm512_alignr_epi64((A), (B), (imm)), \ 3114 (__v8di)_mm512_setzero_si512())) 3115 3116 #define _mm512_alignr_epi32(A, B, I) \ 3117 ((__m512i)__builtin_ia32_alignd512((__v16si)(__m512i)(A), \ 3118 (__v16si)(__m512i)(B), (int)(I))) 3119 3120 #define _mm512_mask_alignr_epi32(W, U, A, B, imm) \ 3121 ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \ 3122 (__v16si)_mm512_alignr_epi32((A), (B), (imm)), \ 3123 (__v16si)(__m512i)(W))) 3124 3125 #define _mm512_maskz_alignr_epi32(U, A, B, imm) \ 3126 ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \ 3127 (__v16si)_mm512_alignr_epi32((A), (B), (imm)), \ 3128 (__v16si)_mm512_setzero_si512())) 3129 /* Vector Extract */ 3130 3131 #define _mm512_extractf64x4_pd(A, I) \ 3132 ((__m256d)__builtin_ia32_extractf64x4_mask((__v8df)(__m512d)(A), (int)(I), \ 3133 (__v4df)_mm256_setzero_pd(), \ 3134 (__mmask8) - 1)) 3135 3136 #define _mm512_mask_extractf64x4_pd(W, U, A, imm) \ 3137 ((__m256d)__builtin_ia32_extractf64x4_mask((__v8df)(__m512d)(A), (int)(imm), \ 3138 (__v4df)(__m256d)(W), \ 3139 (__mmask8)(U))) 3140 3141 #define _mm512_maskz_extractf64x4_pd(U, A, imm) \ 3142 ((__m256d)__builtin_ia32_extractf64x4_mask((__v8df)(__m512d)(A), (int)(imm), \ 3143 (__v4df)_mm256_setzero_pd(), \ 3144 (__mmask8)(U))) 3145 3146 #define _mm512_extractf32x4_ps(A, I) \ 3147 ((__m128)__builtin_ia32_extractf32x4_mask((__v16sf)(__m512)(A), (int)(I), \ 3148 (__v4sf)_mm_setzero_ps(), \ 3149 (__mmask8) - 1)) 3150 3151 #define _mm512_mask_extractf32x4_ps(W, U, A, imm) \ 3152 ((__m128)__builtin_ia32_extractf32x4_mask((__v16sf)(__m512)(A), (int)(imm), \ 3153 (__v4sf)(__m128)(W), \ 3154 (__mmask8)(U))) 3155 3156 #define _mm512_maskz_extractf32x4_ps(U, A, imm) \ 3157 ((__m128)__builtin_ia32_extractf32x4_mask((__v16sf)(__m512)(A), (int)(imm), \ 3158 (__v4sf)_mm_setzero_ps(), \ 3159 (__mmask8)(U))) 3160 3161 /* Vector Blend */ 3162 3163 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3164 _mm512_mask_blend_pd(__mmask8 __U, __m512d __A, __m512d __W) { 3165 return (__m512d) __builtin_ia32_selectpd_512 ((__mmask8) __U, 3166 (__v8df) __W, 3167 (__v8df) __A); 3168 } 3169 3170 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 3171 _mm512_mask_blend_ps(__mmask16 __U, __m512 __A, __m512 __W) { 3172 return (__m512) __builtin_ia32_selectps_512 ((__mmask16) __U, 3173 (__v16sf) __W, 3174 (__v16sf) __A); 3175 } 3176 3177 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 3178 _mm512_mask_blend_epi64(__mmask8 __U, __m512i __A, __m512i __W) { 3179 return (__m512i) __builtin_ia32_selectq_512 ((__mmask8) __U, 3180 (__v8di) __W, 3181 (__v8di) __A); 3182 } 3183 3184 static __inline __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 3185 _mm512_mask_blend_epi32(__mmask16 __U, __m512i __A, __m512i __W) { 3186 return (__m512i) __builtin_ia32_selectd_512 ((__mmask16) __U, 3187 (__v16si) __W, 3188 (__v16si) __A); 3189 } 3190 3191 /* Compare */ 3192 3193 #define _mm512_cmp_round_ps_mask(A, B, P, R) \ 3194 ((__mmask16)__builtin_ia32_cmpps512_mask((__v16sf)(__m512)(A), \ 3195 (__v16sf)(__m512)(B), (int)(P), \ 3196 (__mmask16)-1, (int)(R))) 3197 3198 #define _mm512_mask_cmp_round_ps_mask(U, A, B, P, R) \ 3199 ((__mmask16)__builtin_ia32_cmpps512_mask((__v16sf)(__m512)(A), \ 3200 (__v16sf)(__m512)(B), (int)(P), \ 3201 (__mmask16)(U), (int)(R))) 3202 3203 #define _mm512_cmp_ps_mask(A, B, P) \ 3204 _mm512_cmp_round_ps_mask((A), (B), (P), _MM_FROUND_CUR_DIRECTION) 3205 #define _mm512_mask_cmp_ps_mask(U, A, B, P) \ 3206 _mm512_mask_cmp_round_ps_mask((U), (A), (B), (P), _MM_FROUND_CUR_DIRECTION) 3207 3208 #define _mm512_cmpeq_ps_mask(A, B) \ 3209 _mm512_cmp_ps_mask((A), (B), _CMP_EQ_OQ) 3210 #define _mm512_mask_cmpeq_ps_mask(k, A, B) \ 3211 _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_EQ_OQ) 3212 3213 #define _mm512_cmplt_ps_mask(A, B) \ 3214 _mm512_cmp_ps_mask((A), (B), _CMP_LT_OS) 3215 #define _mm512_mask_cmplt_ps_mask(k, A, B) \ 3216 _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_LT_OS) 3217 3218 #define _mm512_cmple_ps_mask(A, B) \ 3219 _mm512_cmp_ps_mask((A), (B), _CMP_LE_OS) 3220 #define _mm512_mask_cmple_ps_mask(k, A, B) \ 3221 _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_LE_OS) 3222 3223 #define _mm512_cmpunord_ps_mask(A, B) \ 3224 _mm512_cmp_ps_mask((A), (B), _CMP_UNORD_Q) 3225 #define _mm512_mask_cmpunord_ps_mask(k, A, B) \ 3226 _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_UNORD_Q) 3227 3228 #define _mm512_cmpneq_ps_mask(A, B) \ 3229 _mm512_cmp_ps_mask((A), (B), _CMP_NEQ_UQ) 3230 #define _mm512_mask_cmpneq_ps_mask(k, A, B) \ 3231 _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_NEQ_UQ) 3232 3233 #define _mm512_cmpnlt_ps_mask(A, B) \ 3234 _mm512_cmp_ps_mask((A), (B), _CMP_NLT_US) 3235 #define _mm512_mask_cmpnlt_ps_mask(k, A, B) \ 3236 _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_NLT_US) 3237 3238 #define _mm512_cmpnle_ps_mask(A, B) \ 3239 _mm512_cmp_ps_mask((A), (B), _CMP_NLE_US) 3240 #define _mm512_mask_cmpnle_ps_mask(k, A, B) \ 3241 _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_NLE_US) 3242 3243 #define _mm512_cmpord_ps_mask(A, B) \ 3244 _mm512_cmp_ps_mask((A), (B), _CMP_ORD_Q) 3245 #define _mm512_mask_cmpord_ps_mask(k, A, B) \ 3246 _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_ORD_Q) 3247 3248 #define _mm512_cmp_round_pd_mask(A, B, P, R) \ 3249 ((__mmask8)__builtin_ia32_cmppd512_mask((__v8df)(__m512d)(A), \ 3250 (__v8df)(__m512d)(B), (int)(P), \ 3251 (__mmask8)-1, (int)(R))) 3252 3253 #define _mm512_mask_cmp_round_pd_mask(U, A, B, P, R) \ 3254 ((__mmask8)__builtin_ia32_cmppd512_mask((__v8df)(__m512d)(A), \ 3255 (__v8df)(__m512d)(B), (int)(P), \ 3256 (__mmask8)(U), (int)(R))) 3257 3258 #define _mm512_cmp_pd_mask(A, B, P) \ 3259 _mm512_cmp_round_pd_mask((A), (B), (P), _MM_FROUND_CUR_DIRECTION) 3260 #define _mm512_mask_cmp_pd_mask(U, A, B, P) \ 3261 _mm512_mask_cmp_round_pd_mask((U), (A), (B), (P), _MM_FROUND_CUR_DIRECTION) 3262 3263 #define _mm512_cmpeq_pd_mask(A, B) \ 3264 _mm512_cmp_pd_mask((A), (B), _CMP_EQ_OQ) 3265 #define _mm512_mask_cmpeq_pd_mask(k, A, B) \ 3266 _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_EQ_OQ) 3267 3268 #define _mm512_cmplt_pd_mask(A, B) \ 3269 _mm512_cmp_pd_mask((A), (B), _CMP_LT_OS) 3270 #define _mm512_mask_cmplt_pd_mask(k, A, B) \ 3271 _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_LT_OS) 3272 3273 #define _mm512_cmple_pd_mask(A, B) \ 3274 _mm512_cmp_pd_mask((A), (B), _CMP_LE_OS) 3275 #define _mm512_mask_cmple_pd_mask(k, A, B) \ 3276 _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_LE_OS) 3277 3278 #define _mm512_cmpunord_pd_mask(A, B) \ 3279 _mm512_cmp_pd_mask((A), (B), _CMP_UNORD_Q) 3280 #define _mm512_mask_cmpunord_pd_mask(k, A, B) \ 3281 _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_UNORD_Q) 3282 3283 #define _mm512_cmpneq_pd_mask(A, B) \ 3284 _mm512_cmp_pd_mask((A), (B), _CMP_NEQ_UQ) 3285 #define _mm512_mask_cmpneq_pd_mask(k, A, B) \ 3286 _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_NEQ_UQ) 3287 3288 #define _mm512_cmpnlt_pd_mask(A, B) \ 3289 _mm512_cmp_pd_mask((A), (B), _CMP_NLT_US) 3290 #define _mm512_mask_cmpnlt_pd_mask(k, A, B) \ 3291 _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_NLT_US) 3292 3293 #define _mm512_cmpnle_pd_mask(A, B) \ 3294 _mm512_cmp_pd_mask((A), (B), _CMP_NLE_US) 3295 #define _mm512_mask_cmpnle_pd_mask(k, A, B) \ 3296 _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_NLE_US) 3297 3298 #define _mm512_cmpord_pd_mask(A, B) \ 3299 _mm512_cmp_pd_mask((A), (B), _CMP_ORD_Q) 3300 #define _mm512_mask_cmpord_pd_mask(k, A, B) \ 3301 _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_ORD_Q) 3302 3303 /* Conversion */ 3304 3305 #define _mm512_cvtt_roundps_epu32(A, R) \ 3306 ((__m512i)__builtin_ia32_cvttps2udq512_mask((__v16sf)(__m512)(A), \ 3307 (__v16si)_mm512_undefined_epi32(), \ 3308 (__mmask16)-1, (int)(R))) 3309 3310 #define _mm512_mask_cvtt_roundps_epu32(W, U, A, R) \ 3311 ((__m512i)__builtin_ia32_cvttps2udq512_mask((__v16sf)(__m512)(A), \ 3312 (__v16si)(__m512i)(W), \ 3313 (__mmask16)(U), (int)(R))) 3314 3315 #define _mm512_maskz_cvtt_roundps_epu32(U, A, R) \ 3316 ((__m512i)__builtin_ia32_cvttps2udq512_mask((__v16sf)(__m512)(A), \ 3317 (__v16si)_mm512_setzero_si512(), \ 3318 (__mmask16)(U), (int)(R))) 3319 3320 3321 static __inline __m512i __DEFAULT_FN_ATTRS512 3322 _mm512_cvttps_epu32(__m512 __A) 3323 { 3324 return (__m512i) __builtin_ia32_cvttps2udq512_mask ((__v16sf) __A, 3325 (__v16si) 3326 _mm512_setzero_si512 (), 3327 (__mmask16) -1, 3328 _MM_FROUND_CUR_DIRECTION); 3329 } 3330 3331 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3332 _mm512_mask_cvttps_epu32 (__m512i __W, __mmask16 __U, __m512 __A) 3333 { 3334 return (__m512i) __builtin_ia32_cvttps2udq512_mask ((__v16sf) __A, 3335 (__v16si) __W, 3336 (__mmask16) __U, 3337 _MM_FROUND_CUR_DIRECTION); 3338 } 3339 3340 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3341 _mm512_maskz_cvttps_epu32 (__mmask16 __U, __m512 __A) 3342 { 3343 return (__m512i) __builtin_ia32_cvttps2udq512_mask ((__v16sf) __A, 3344 (__v16si) _mm512_setzero_si512 (), 3345 (__mmask16) __U, 3346 _MM_FROUND_CUR_DIRECTION); 3347 } 3348 3349 #define _mm512_cvt_roundepi32_ps(A, R) \ 3350 ((__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(__m512i)(A), \ 3351 (__v16sf)_mm512_setzero_ps(), \ 3352 (__mmask16)-1, (int)(R))) 3353 3354 #define _mm512_mask_cvt_roundepi32_ps(W, U, A, R) \ 3355 ((__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(__m512i)(A), \ 3356 (__v16sf)(__m512)(W), \ 3357 (__mmask16)(U), (int)(R))) 3358 3359 #define _mm512_maskz_cvt_roundepi32_ps(U, A, R) \ 3360 ((__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(__m512i)(A), \ 3361 (__v16sf)_mm512_setzero_ps(), \ 3362 (__mmask16)(U), (int)(R))) 3363 3364 #define _mm512_cvt_roundepu32_ps(A, R) \ 3365 ((__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(__m512i)(A), \ 3366 (__v16sf)_mm512_setzero_ps(), \ 3367 (__mmask16)-1, (int)(R))) 3368 3369 #define _mm512_mask_cvt_roundepu32_ps(W, U, A, R) \ 3370 ((__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(__m512i)(A), \ 3371 (__v16sf)(__m512)(W), \ 3372 (__mmask16)(U), (int)(R))) 3373 3374 #define _mm512_maskz_cvt_roundepu32_ps(U, A, R) \ 3375 ((__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(__m512i)(A), \ 3376 (__v16sf)_mm512_setzero_ps(), \ 3377 (__mmask16)(U), (int)(R))) 3378 3379 static __inline__ __m512 3380 __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_cvtepu32_ps(__m512i __A) { 3381 return (__m512)__builtin_convertvector((__v16su)__A, __v16sf); 3382 } 3383 3384 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 3385 _mm512_mask_cvtepu32_ps(__m512 __W, __mmask16 __U, __m512i __A) { 3386 return (__m512)__builtin_ia32_selectps_512((__mmask16)__U, 3387 (__v16sf)_mm512_cvtepu32_ps(__A), 3388 (__v16sf)__W); 3389 } 3390 3391 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 3392 _mm512_maskz_cvtepu32_ps(__mmask16 __U, __m512i __A) { 3393 return (__m512)__builtin_ia32_selectps_512((__mmask16)__U, 3394 (__v16sf)_mm512_cvtepu32_ps(__A), 3395 (__v16sf)_mm512_setzero_ps()); 3396 } 3397 3398 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3399 _mm512_cvtepi32_pd(__m256i __A) { 3400 return (__m512d)__builtin_convertvector((__v8si)__A, __v8df); 3401 } 3402 3403 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3404 _mm512_mask_cvtepi32_pd(__m512d __W, __mmask8 __U, __m256i __A) { 3405 return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U, 3406 (__v8df)_mm512_cvtepi32_pd(__A), 3407 (__v8df)__W); 3408 } 3409 3410 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3411 _mm512_maskz_cvtepi32_pd(__mmask8 __U, __m256i __A) { 3412 return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U, 3413 (__v8df)_mm512_cvtepi32_pd(__A), 3414 (__v8df)_mm512_setzero_pd()); 3415 } 3416 3417 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3418 _mm512_cvtepi32lo_pd(__m512i __A) { 3419 return (__m512d) _mm512_cvtepi32_pd(_mm512_castsi512_si256(__A)); 3420 } 3421 3422 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3423 _mm512_mask_cvtepi32lo_pd(__m512d __W, __mmask8 __U, __m512i __A) { 3424 return (__m512d) _mm512_mask_cvtepi32_pd(__W, __U, _mm512_castsi512_si256(__A)); 3425 } 3426 3427 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 3428 _mm512_cvtepi32_ps(__m512i __A) { 3429 return (__m512)__builtin_convertvector((__v16si)__A, __v16sf); 3430 } 3431 3432 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 3433 _mm512_mask_cvtepi32_ps(__m512 __W, __mmask16 __U, __m512i __A) { 3434 return (__m512)__builtin_ia32_selectps_512((__mmask16)__U, 3435 (__v16sf)_mm512_cvtepi32_ps(__A), 3436 (__v16sf)__W); 3437 } 3438 3439 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 3440 _mm512_maskz_cvtepi32_ps(__mmask16 __U, __m512i __A) { 3441 return (__m512)__builtin_ia32_selectps_512((__mmask16)__U, 3442 (__v16sf)_mm512_cvtepi32_ps(__A), 3443 (__v16sf)_mm512_setzero_ps()); 3444 } 3445 3446 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3447 _mm512_cvtepu32_pd(__m256i __A) { 3448 return (__m512d)__builtin_convertvector((__v8su)__A, __v8df); 3449 } 3450 3451 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3452 _mm512_mask_cvtepu32_pd(__m512d __W, __mmask8 __U, __m256i __A) { 3453 return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U, 3454 (__v8df)_mm512_cvtepu32_pd(__A), 3455 (__v8df)__W); 3456 } 3457 3458 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3459 _mm512_maskz_cvtepu32_pd(__mmask8 __U, __m256i __A) { 3460 return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U, 3461 (__v8df)_mm512_cvtepu32_pd(__A), 3462 (__v8df)_mm512_setzero_pd()); 3463 } 3464 3465 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3466 _mm512_cvtepu32lo_pd(__m512i __A) { 3467 return (__m512d) _mm512_cvtepu32_pd(_mm512_castsi512_si256(__A)); 3468 } 3469 3470 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3471 _mm512_mask_cvtepu32lo_pd(__m512d __W, __mmask8 __U, __m512i __A) { 3472 return (__m512d) _mm512_mask_cvtepu32_pd(__W, __U, _mm512_castsi512_si256(__A)); 3473 } 3474 3475 #define _mm512_cvt_roundpd_ps(A, R) \ 3476 ((__m256)__builtin_ia32_cvtpd2ps512_mask((__v8df)(__m512d)(A), \ 3477 (__v8sf)_mm256_setzero_ps(), \ 3478 (__mmask8)-1, (int)(R))) 3479 3480 #define _mm512_mask_cvt_roundpd_ps(W, U, A, R) \ 3481 ((__m256)__builtin_ia32_cvtpd2ps512_mask((__v8df)(__m512d)(A), \ 3482 (__v8sf)(__m256)(W), (__mmask8)(U), \ 3483 (int)(R))) 3484 3485 #define _mm512_maskz_cvt_roundpd_ps(U, A, R) \ 3486 ((__m256)__builtin_ia32_cvtpd2ps512_mask((__v8df)(__m512d)(A), \ 3487 (__v8sf)_mm256_setzero_ps(), \ 3488 (__mmask8)(U), (int)(R))) 3489 3490 static __inline__ __m256 3491 __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_cvtpd_ps(__m512d __A) { 3492 return (__m256)__builtin_ia32_cvtpd2ps512_mask( 3493 (__v8df)__A, (__v8sf)_mm256_setzero_ps(), (__mmask8)-1, 3494 _MM_FROUND_CUR_DIRECTION); 3495 } 3496 3497 static __inline__ __m256 __DEFAULT_FN_ATTRS512_CONSTEXPR 3498 _mm512_mask_cvtpd_ps(__m256 __W, __mmask8 __U, __m512d __A) { 3499 return (__m256) __builtin_ia32_cvtpd2ps512_mask ((__v8df) __A, 3500 (__v8sf) __W, 3501 (__mmask8) __U, 3502 _MM_FROUND_CUR_DIRECTION); 3503 } 3504 3505 static __inline__ __m256 __DEFAULT_FN_ATTRS512_CONSTEXPR 3506 _mm512_maskz_cvtpd_ps(__mmask8 __U, __m512d __A) { 3507 return (__m256) __builtin_ia32_cvtpd2ps512_mask ((__v8df) __A, 3508 (__v8sf) _mm256_setzero_ps (), 3509 (__mmask8) __U, 3510 _MM_FROUND_CUR_DIRECTION); 3511 } 3512 3513 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 3514 _mm512_cvtpd_pslo(__m512d __A) { 3515 return (__m512) __builtin_shufflevector((__v8sf) _mm512_cvtpd_ps(__A), 3516 (__v8sf) _mm256_setzero_ps (), 3517 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); 3518 } 3519 3520 static __inline__ __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 3521 _mm512_mask_cvtpd_pslo(__m512 __W, __mmask8 __U, __m512d __A) { 3522 return (__m512) __builtin_shufflevector ( 3523 (__v8sf) _mm512_mask_cvtpd_ps (_mm512_castps512_ps256(__W), 3524 __U, __A), 3525 (__v8sf) _mm256_setzero_ps (), 3526 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); 3527 } 3528 3529 #define _mm512_cvt_roundps_ph(A, I) \ 3530 ((__m256i)__builtin_ia32_vcvtps2ph512_mask((__v16sf)(__m512)(A), (int)(I), \ 3531 (__v16hi)_mm256_undefined_si256(), \ 3532 (__mmask16)-1)) 3533 3534 #define _mm512_mask_cvt_roundps_ph(U, W, A, I) \ 3535 ((__m256i)__builtin_ia32_vcvtps2ph512_mask((__v16sf)(__m512)(A), (int)(I), \ 3536 (__v16hi)(__m256i)(U), \ 3537 (__mmask16)(W))) 3538 3539 #define _mm512_maskz_cvt_roundps_ph(W, A, I) \ 3540 ((__m256i)__builtin_ia32_vcvtps2ph512_mask((__v16sf)(__m512)(A), (int)(I), \ 3541 (__v16hi)_mm256_setzero_si256(), \ 3542 (__mmask16)(W))) 3543 3544 #define _mm512_cvtps_ph _mm512_cvt_roundps_ph 3545 #define _mm512_mask_cvtps_ph _mm512_mask_cvt_roundps_ph 3546 #define _mm512_maskz_cvtps_ph _mm512_maskz_cvt_roundps_ph 3547 3548 #define _mm512_cvt_roundph_ps(A, R) \ 3549 ((__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(__m256i)(A), \ 3550 (__v16sf)_mm512_undefined_ps(), \ 3551 (__mmask16)-1, (int)(R))) 3552 3553 #define _mm512_mask_cvt_roundph_ps(W, U, A, R) \ 3554 ((__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(__m256i)(A), \ 3555 (__v16sf)(__m512)(W), \ 3556 (__mmask16)(U), (int)(R))) 3557 3558 #define _mm512_maskz_cvt_roundph_ps(U, A, R) \ 3559 ((__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(__m256i)(A), \ 3560 (__v16sf)_mm512_setzero_ps(), \ 3561 (__mmask16)(U), (int)(R))) 3562 3563 3564 static __inline __m512 __DEFAULT_FN_ATTRS512 3565 _mm512_cvtph_ps(__m256i __A) 3566 { 3567 return (__m512) __builtin_ia32_vcvtph2ps512_mask ((__v16hi) __A, 3568 (__v16sf) 3569 _mm512_setzero_ps (), 3570 (__mmask16) -1, 3571 _MM_FROUND_CUR_DIRECTION); 3572 } 3573 3574 static __inline__ __m512 __DEFAULT_FN_ATTRS512 3575 _mm512_mask_cvtph_ps (__m512 __W, __mmask16 __U, __m256i __A) 3576 { 3577 return (__m512) __builtin_ia32_vcvtph2ps512_mask ((__v16hi) __A, 3578 (__v16sf) __W, 3579 (__mmask16) __U, 3580 _MM_FROUND_CUR_DIRECTION); 3581 } 3582 3583 static __inline__ __m512 __DEFAULT_FN_ATTRS512 3584 _mm512_maskz_cvtph_ps (__mmask16 __U, __m256i __A) 3585 { 3586 return (__m512) __builtin_ia32_vcvtph2ps512_mask ((__v16hi) __A, 3587 (__v16sf) _mm512_setzero_ps (), 3588 (__mmask16) __U, 3589 _MM_FROUND_CUR_DIRECTION); 3590 } 3591 3592 #define _mm512_cvtt_roundpd_epi32(A, R) \ 3593 ((__m256i)__builtin_ia32_cvttpd2dq512_mask((__v8df)(__m512d)(A), \ 3594 (__v8si)_mm256_setzero_si256(), \ 3595 (__mmask8)-1, (int)(R))) 3596 3597 #define _mm512_mask_cvtt_roundpd_epi32(W, U, A, R) \ 3598 ((__m256i)__builtin_ia32_cvttpd2dq512_mask((__v8df)(__m512d)(A), \ 3599 (__v8si)(__m256i)(W), \ 3600 (__mmask8)(U), (int)(R))) 3601 3602 #define _mm512_maskz_cvtt_roundpd_epi32(U, A, R) \ 3603 ((__m256i)__builtin_ia32_cvttpd2dq512_mask((__v8df)(__m512d)(A), \ 3604 (__v8si)_mm256_setzero_si256(), \ 3605 (__mmask8)(U), (int)(R))) 3606 3607 static __inline __m256i __DEFAULT_FN_ATTRS512 3608 _mm512_cvttpd_epi32(__m512d __a) 3609 { 3610 return (__m256i)__builtin_ia32_cvttpd2dq512_mask((__v8df) __a, 3611 (__v8si)_mm256_setzero_si256(), 3612 (__mmask8) -1, 3613 _MM_FROUND_CUR_DIRECTION); 3614 } 3615 3616 static __inline__ __m256i __DEFAULT_FN_ATTRS512 3617 _mm512_mask_cvttpd_epi32 (__m256i __W, __mmask8 __U, __m512d __A) 3618 { 3619 return (__m256i) __builtin_ia32_cvttpd2dq512_mask ((__v8df) __A, 3620 (__v8si) __W, 3621 (__mmask8) __U, 3622 _MM_FROUND_CUR_DIRECTION); 3623 } 3624 3625 static __inline__ __m256i __DEFAULT_FN_ATTRS512 3626 _mm512_maskz_cvttpd_epi32 (__mmask8 __U, __m512d __A) 3627 { 3628 return (__m256i) __builtin_ia32_cvttpd2dq512_mask ((__v8df) __A, 3629 (__v8si) _mm256_setzero_si256 (), 3630 (__mmask8) __U, 3631 _MM_FROUND_CUR_DIRECTION); 3632 } 3633 3634 #define _mm512_cvtt_roundps_epi32(A, R) \ 3635 ((__m512i)__builtin_ia32_cvttps2dq512_mask((__v16sf)(__m512)(A), \ 3636 (__v16si)_mm512_setzero_si512(), \ 3637 (__mmask16)-1, (int)(R))) 3638 3639 #define _mm512_mask_cvtt_roundps_epi32(W, U, A, R) \ 3640 ((__m512i)__builtin_ia32_cvttps2dq512_mask((__v16sf)(__m512)(A), \ 3641 (__v16si)(__m512i)(W), \ 3642 (__mmask16)(U), (int)(R))) 3643 3644 #define _mm512_maskz_cvtt_roundps_epi32(U, A, R) \ 3645 ((__m512i)__builtin_ia32_cvttps2dq512_mask((__v16sf)(__m512)(A), \ 3646 (__v16si)_mm512_setzero_si512(), \ 3647 (__mmask16)(U), (int)(R))) 3648 3649 static __inline __m512i __DEFAULT_FN_ATTRS512 3650 _mm512_cvttps_epi32(__m512 __a) 3651 { 3652 return (__m512i) 3653 __builtin_ia32_cvttps2dq512_mask((__v16sf) __a, 3654 (__v16si) _mm512_setzero_si512 (), 3655 (__mmask16) -1, _MM_FROUND_CUR_DIRECTION); 3656 } 3657 3658 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3659 _mm512_mask_cvttps_epi32 (__m512i __W, __mmask16 __U, __m512 __A) 3660 { 3661 return (__m512i) __builtin_ia32_cvttps2dq512_mask ((__v16sf) __A, 3662 (__v16si) __W, 3663 (__mmask16) __U, 3664 _MM_FROUND_CUR_DIRECTION); 3665 } 3666 3667 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3668 _mm512_maskz_cvttps_epi32 (__mmask16 __U, __m512 __A) 3669 { 3670 return (__m512i) __builtin_ia32_cvttps2dq512_mask ((__v16sf) __A, 3671 (__v16si) _mm512_setzero_si512 (), 3672 (__mmask16) __U, 3673 _MM_FROUND_CUR_DIRECTION); 3674 } 3675 3676 #define _mm512_cvt_roundps_epi32(A, R) \ 3677 ((__m512i)__builtin_ia32_cvtps2dq512_mask((__v16sf)(__m512)(A), \ 3678 (__v16si)_mm512_setzero_si512(), \ 3679 (__mmask16)-1, (int)(R))) 3680 3681 #define _mm512_mask_cvt_roundps_epi32(W, U, A, R) \ 3682 ((__m512i)__builtin_ia32_cvtps2dq512_mask((__v16sf)(__m512)(A), \ 3683 (__v16si)(__m512i)(W), \ 3684 (__mmask16)(U), (int)(R))) 3685 3686 #define _mm512_maskz_cvt_roundps_epi32(U, A, R) \ 3687 ((__m512i)__builtin_ia32_cvtps2dq512_mask((__v16sf)(__m512)(A), \ 3688 (__v16si)_mm512_setzero_si512(), \ 3689 (__mmask16)(U), (int)(R))) 3690 3691 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3692 _mm512_cvtps_epi32 (__m512 __A) 3693 { 3694 return (__m512i) __builtin_ia32_cvtps2dq512_mask ((__v16sf) __A, 3695 (__v16si) _mm512_undefined_epi32 (), 3696 (__mmask16) -1, 3697 _MM_FROUND_CUR_DIRECTION); 3698 } 3699 3700 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3701 _mm512_mask_cvtps_epi32 (__m512i __W, __mmask16 __U, __m512 __A) 3702 { 3703 return (__m512i) __builtin_ia32_cvtps2dq512_mask ((__v16sf) __A, 3704 (__v16si) __W, 3705 (__mmask16) __U, 3706 _MM_FROUND_CUR_DIRECTION); 3707 } 3708 3709 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3710 _mm512_maskz_cvtps_epi32 (__mmask16 __U, __m512 __A) 3711 { 3712 return (__m512i) __builtin_ia32_cvtps2dq512_mask ((__v16sf) __A, 3713 (__v16si) 3714 _mm512_setzero_si512 (), 3715 (__mmask16) __U, 3716 _MM_FROUND_CUR_DIRECTION); 3717 } 3718 3719 #define _mm512_cvt_roundpd_epi32(A, R) \ 3720 ((__m256i)__builtin_ia32_cvtpd2dq512_mask((__v8df)(__m512d)(A), \ 3721 (__v8si)_mm256_setzero_si256(), \ 3722 (__mmask8)-1, (int)(R))) 3723 3724 #define _mm512_mask_cvt_roundpd_epi32(W, U, A, R) \ 3725 ((__m256i)__builtin_ia32_cvtpd2dq512_mask((__v8df)(__m512d)(A), \ 3726 (__v8si)(__m256i)(W), \ 3727 (__mmask8)(U), (int)(R))) 3728 3729 #define _mm512_maskz_cvt_roundpd_epi32(U, A, R) \ 3730 ((__m256i)__builtin_ia32_cvtpd2dq512_mask((__v8df)(__m512d)(A), \ 3731 (__v8si)_mm256_setzero_si256(), \ 3732 (__mmask8)(U), (int)(R))) 3733 3734 static __inline__ __m256i __DEFAULT_FN_ATTRS512 3735 _mm512_cvtpd_epi32 (__m512d __A) 3736 { 3737 return (__m256i) __builtin_ia32_cvtpd2dq512_mask ((__v8df) __A, 3738 (__v8si) 3739 _mm256_undefined_si256 (), 3740 (__mmask8) -1, 3741 _MM_FROUND_CUR_DIRECTION); 3742 } 3743 3744 static __inline__ __m256i __DEFAULT_FN_ATTRS512 3745 _mm512_mask_cvtpd_epi32 (__m256i __W, __mmask8 __U, __m512d __A) 3746 { 3747 return (__m256i) __builtin_ia32_cvtpd2dq512_mask ((__v8df) __A, 3748 (__v8si) __W, 3749 (__mmask8) __U, 3750 _MM_FROUND_CUR_DIRECTION); 3751 } 3752 3753 static __inline__ __m256i __DEFAULT_FN_ATTRS512 3754 _mm512_maskz_cvtpd_epi32 (__mmask8 __U, __m512d __A) 3755 { 3756 return (__m256i) __builtin_ia32_cvtpd2dq512_mask ((__v8df) __A, 3757 (__v8si) 3758 _mm256_setzero_si256 (), 3759 (__mmask8) __U, 3760 _MM_FROUND_CUR_DIRECTION); 3761 } 3762 3763 #define _mm512_cvt_roundps_epu32(A, R) \ 3764 ((__m512i)__builtin_ia32_cvtps2udq512_mask((__v16sf)(__m512)(A), \ 3765 (__v16si)_mm512_setzero_si512(), \ 3766 (__mmask16)-1, (int)(R))) 3767 3768 #define _mm512_mask_cvt_roundps_epu32(W, U, A, R) \ 3769 ((__m512i)__builtin_ia32_cvtps2udq512_mask((__v16sf)(__m512)(A), \ 3770 (__v16si)(__m512i)(W), \ 3771 (__mmask16)(U), (int)(R))) 3772 3773 #define _mm512_maskz_cvt_roundps_epu32(U, A, R) \ 3774 ((__m512i)__builtin_ia32_cvtps2udq512_mask((__v16sf)(__m512)(A), \ 3775 (__v16si)_mm512_setzero_si512(), \ 3776 (__mmask16)(U), (int)(R))) 3777 3778 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3779 _mm512_cvtps_epu32 ( __m512 __A) 3780 { 3781 return (__m512i) __builtin_ia32_cvtps2udq512_mask ((__v16sf) __A,\ 3782 (__v16si)\ 3783 _mm512_undefined_epi32 (), 3784 (__mmask16) -1,\ 3785 _MM_FROUND_CUR_DIRECTION); 3786 } 3787 3788 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3789 _mm512_mask_cvtps_epu32 (__m512i __W, __mmask16 __U, __m512 __A) 3790 { 3791 return (__m512i) __builtin_ia32_cvtps2udq512_mask ((__v16sf) __A, 3792 (__v16si) __W, 3793 (__mmask16) __U, 3794 _MM_FROUND_CUR_DIRECTION); 3795 } 3796 3797 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3798 _mm512_maskz_cvtps_epu32 ( __mmask16 __U, __m512 __A) 3799 { 3800 return (__m512i) __builtin_ia32_cvtps2udq512_mask ((__v16sf) __A, 3801 (__v16si) 3802 _mm512_setzero_si512 (), 3803 (__mmask16) __U , 3804 _MM_FROUND_CUR_DIRECTION); 3805 } 3806 3807 #define _mm512_cvt_roundpd_epu32(A, R) \ 3808 ((__m256i)__builtin_ia32_cvtpd2udq512_mask((__v8df)(__m512d)(A), \ 3809 (__v8si)_mm256_setzero_si256(), \ 3810 (__mmask8)-1, (int)(R))) 3811 3812 #define _mm512_mask_cvt_roundpd_epu32(W, U, A, R) \ 3813 ((__m256i)__builtin_ia32_cvtpd2udq512_mask((__v8df)(__m512d)(A), \ 3814 (__v8si)(__m256i)(W), \ 3815 (__mmask8)(U), (int)(R))) 3816 3817 #define _mm512_maskz_cvt_roundpd_epu32(U, A, R) \ 3818 ((__m256i)__builtin_ia32_cvtpd2udq512_mask((__v8df)(__m512d)(A), \ 3819 (__v8si)_mm256_setzero_si256(), \ 3820 (__mmask8)(U), (int)(R))) 3821 3822 static __inline__ __m256i __DEFAULT_FN_ATTRS512 3823 _mm512_cvtpd_epu32 (__m512d __A) 3824 { 3825 return (__m256i) __builtin_ia32_cvtpd2udq512_mask ((__v8df) __A, 3826 (__v8si) 3827 _mm256_undefined_si256 (), 3828 (__mmask8) -1, 3829 _MM_FROUND_CUR_DIRECTION); 3830 } 3831 3832 static __inline__ __m256i __DEFAULT_FN_ATTRS512 3833 _mm512_mask_cvtpd_epu32 (__m256i __W, __mmask8 __U, __m512d __A) 3834 { 3835 return (__m256i) __builtin_ia32_cvtpd2udq512_mask ((__v8df) __A, 3836 (__v8si) __W, 3837 (__mmask8) __U, 3838 _MM_FROUND_CUR_DIRECTION); 3839 } 3840 3841 static __inline__ __m256i __DEFAULT_FN_ATTRS512 3842 _mm512_maskz_cvtpd_epu32 (__mmask8 __U, __m512d __A) 3843 { 3844 return (__m256i) __builtin_ia32_cvtpd2udq512_mask ((__v8df) __A, 3845 (__v8si) 3846 _mm256_setzero_si256 (), 3847 (__mmask8) __U, 3848 _MM_FROUND_CUR_DIRECTION); 3849 } 3850 3851 static __inline__ double __DEFAULT_FN_ATTRS512 3852 _mm512_cvtsd_f64(__m512d __a) 3853 { 3854 return __a[0]; 3855 } 3856 3857 static __inline__ float __DEFAULT_FN_ATTRS512 3858 _mm512_cvtss_f32(__m512 __a) 3859 { 3860 return __a[0]; 3861 } 3862 3863 /* Unpack and Interleave */ 3864 3865 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3866 _mm512_unpackhi_pd(__m512d __a, __m512d __b) { 3867 return (__m512d)__builtin_shufflevector((__v8df)__a, (__v8df)__b, 3868 1, 9, 1+2, 9+2, 1+4, 9+4, 1+6, 9+6); 3869 } 3870 3871 static __inline__ __m512d __DEFAULT_FN_ATTRS512 3872 _mm512_mask_unpackhi_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) 3873 { 3874 return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U, 3875 (__v8df)_mm512_unpackhi_pd(__A, __B), 3876 (__v8df)__W); 3877 } 3878 3879 static __inline__ __m512d __DEFAULT_FN_ATTRS512 3880 _mm512_maskz_unpackhi_pd(__mmask8 __U, __m512d __A, __m512d __B) 3881 { 3882 return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U, 3883 (__v8df)_mm512_unpackhi_pd(__A, __B), 3884 (__v8df)_mm512_setzero_pd()); 3885 } 3886 3887 static __inline __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 3888 _mm512_unpacklo_pd(__m512d __a, __m512d __b) { 3889 return (__m512d)__builtin_shufflevector((__v8df)__a, (__v8df)__b, 3890 0, 8, 0+2, 8+2, 0+4, 8+4, 0+6, 8+6); 3891 } 3892 3893 static __inline__ __m512d __DEFAULT_FN_ATTRS512 3894 _mm512_mask_unpacklo_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) 3895 { 3896 return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U, 3897 (__v8df)_mm512_unpacklo_pd(__A, __B), 3898 (__v8df)__W); 3899 } 3900 3901 static __inline__ __m512d __DEFAULT_FN_ATTRS512 3902 _mm512_maskz_unpacklo_pd (__mmask8 __U, __m512d __A, __m512d __B) 3903 { 3904 return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U, 3905 (__v8df)_mm512_unpacklo_pd(__A, __B), 3906 (__v8df)_mm512_setzero_pd()); 3907 } 3908 3909 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 3910 _mm512_unpackhi_ps(__m512 __a, __m512 __b) { 3911 return (__m512)__builtin_shufflevector((__v16sf)__a, (__v16sf)__b, 3912 2, 18, 3, 19, 3913 2+4, 18+4, 3+4, 19+4, 3914 2+8, 18+8, 3+8, 19+8, 3915 2+12, 18+12, 3+12, 19+12); 3916 } 3917 3918 static __inline__ __m512 __DEFAULT_FN_ATTRS512 3919 _mm512_mask_unpackhi_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) 3920 { 3921 return (__m512)__builtin_ia32_selectps_512((__mmask16) __U, 3922 (__v16sf)_mm512_unpackhi_ps(__A, __B), 3923 (__v16sf)__W); 3924 } 3925 3926 static __inline__ __m512 __DEFAULT_FN_ATTRS512 3927 _mm512_maskz_unpackhi_ps (__mmask16 __U, __m512 __A, __m512 __B) 3928 { 3929 return (__m512)__builtin_ia32_selectps_512((__mmask16) __U, 3930 (__v16sf)_mm512_unpackhi_ps(__A, __B), 3931 (__v16sf)_mm512_setzero_ps()); 3932 } 3933 3934 static __inline __m512 __DEFAULT_FN_ATTRS512_CONSTEXPR 3935 _mm512_unpacklo_ps(__m512 __a, __m512 __b) { 3936 return (__m512)__builtin_shufflevector((__v16sf)__a, (__v16sf)__b, 3937 0, 16, 1, 17, 3938 0+4, 16+4, 1+4, 17+4, 3939 0+8, 16+8, 1+8, 17+8, 3940 0+12, 16+12, 1+12, 17+12); 3941 } 3942 3943 static __inline__ __m512 __DEFAULT_FN_ATTRS512 3944 _mm512_mask_unpacklo_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) 3945 { 3946 return (__m512)__builtin_ia32_selectps_512((__mmask16) __U, 3947 (__v16sf)_mm512_unpacklo_ps(__A, __B), 3948 (__v16sf)__W); 3949 } 3950 3951 static __inline__ __m512 __DEFAULT_FN_ATTRS512 3952 _mm512_maskz_unpacklo_ps (__mmask16 __U, __m512 __A, __m512 __B) 3953 { 3954 return (__m512)__builtin_ia32_selectps_512((__mmask16) __U, 3955 (__v16sf)_mm512_unpacklo_ps(__A, __B), 3956 (__v16sf)_mm512_setzero_ps()); 3957 } 3958 3959 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 3960 _mm512_unpackhi_epi32(__m512i __A, __m512i __B) { 3961 return (__m512i)__builtin_shufflevector((__v16si)__A, (__v16si)__B, 3962 2, 18, 3, 19, 3963 2+4, 18+4, 3+4, 19+4, 3964 2+8, 18+8, 3+8, 19+8, 3965 2+12, 18+12, 3+12, 19+12); 3966 } 3967 3968 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3969 _mm512_mask_unpackhi_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) 3970 { 3971 return (__m512i)__builtin_ia32_selectd_512((__mmask16) __U, 3972 (__v16si)_mm512_unpackhi_epi32(__A, __B), 3973 (__v16si)__W); 3974 } 3975 3976 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3977 _mm512_maskz_unpackhi_epi32(__mmask16 __U, __m512i __A, __m512i __B) 3978 { 3979 return (__m512i)__builtin_ia32_selectd_512((__mmask16) __U, 3980 (__v16si)_mm512_unpackhi_epi32(__A, __B), 3981 (__v16si)_mm512_setzero_si512()); 3982 } 3983 3984 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 3985 _mm512_unpacklo_epi32(__m512i __A, __m512i __B) { 3986 return (__m512i)__builtin_shufflevector((__v16si)__A, (__v16si)__B, 3987 0, 16, 1, 17, 3988 0+4, 16+4, 1+4, 17+4, 3989 0+8, 16+8, 1+8, 17+8, 3990 0+12, 16+12, 1+12, 17+12); 3991 } 3992 3993 static __inline__ __m512i __DEFAULT_FN_ATTRS512 3994 _mm512_mask_unpacklo_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) 3995 { 3996 return (__m512i)__builtin_ia32_selectd_512((__mmask16) __U, 3997 (__v16si)_mm512_unpacklo_epi32(__A, __B), 3998 (__v16si)__W); 3999 } 4000 4001 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4002 _mm512_maskz_unpacklo_epi32(__mmask16 __U, __m512i __A, __m512i __B) 4003 { 4004 return (__m512i)__builtin_ia32_selectd_512((__mmask16) __U, 4005 (__v16si)_mm512_unpacklo_epi32(__A, __B), 4006 (__v16si)_mm512_setzero_si512()); 4007 } 4008 4009 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4010 _mm512_unpackhi_epi64(__m512i __A, __m512i __B) { 4011 return (__m512i)__builtin_shufflevector((__v8di)__A, (__v8di)__B, 4012 1, 9, 1+2, 9+2, 1+4, 9+4, 1+6, 9+6); 4013 } 4014 4015 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4016 _mm512_mask_unpackhi_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) 4017 { 4018 return (__m512i)__builtin_ia32_selectq_512((__mmask8) __U, 4019 (__v8di)_mm512_unpackhi_epi64(__A, __B), 4020 (__v8di)__W); 4021 } 4022 4023 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4024 _mm512_maskz_unpackhi_epi64(__mmask8 __U, __m512i __A, __m512i __B) 4025 { 4026 return (__m512i)__builtin_ia32_selectq_512((__mmask8) __U, 4027 (__v8di)_mm512_unpackhi_epi64(__A, __B), 4028 (__v8di)_mm512_setzero_si512()); 4029 } 4030 4031 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4032 _mm512_unpacklo_epi64(__m512i __A, __m512i __B) { 4033 return (__m512i)__builtin_shufflevector((__v8di)__A, (__v8di)__B, 4034 0, 8, 0+2, 8+2, 0+4, 8+4, 0+6, 8+6); 4035 } 4036 4037 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4038 _mm512_mask_unpacklo_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) 4039 { 4040 return (__m512i)__builtin_ia32_selectq_512((__mmask8) __U, 4041 (__v8di)_mm512_unpacklo_epi64(__A, __B), 4042 (__v8di)__W); 4043 } 4044 4045 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4046 _mm512_maskz_unpacklo_epi64 (__mmask8 __U, __m512i __A, __m512i __B) 4047 { 4048 return (__m512i)__builtin_ia32_selectq_512((__mmask8) __U, 4049 (__v8di)_mm512_unpacklo_epi64(__A, __B), 4050 (__v8di)_mm512_setzero_si512()); 4051 } 4052 4053 4054 /* SIMD load ops */ 4055 4056 static __inline __m512i __DEFAULT_FN_ATTRS512 4057 _mm512_loadu_si512 (void const *__P) 4058 { 4059 struct __loadu_si512 { 4060 __m512i_u __v; 4061 } __attribute__((__packed__, __may_alias__)); 4062 return ((const struct __loadu_si512*)__P)->__v; 4063 } 4064 4065 static __inline __m512i __DEFAULT_FN_ATTRS512 4066 _mm512_loadu_epi32 (void const *__P) 4067 { 4068 struct __loadu_epi32 { 4069 __m512i_u __v; 4070 } __attribute__((__packed__, __may_alias__)); 4071 return ((const struct __loadu_epi32*)__P)->__v; 4072 } 4073 4074 static __inline __m512i __DEFAULT_FN_ATTRS512 4075 _mm512_mask_loadu_epi32 (__m512i __W, __mmask16 __U, void const *__P) 4076 { 4077 return (__m512i) __builtin_ia32_loaddqusi512_mask ((const int *) __P, 4078 (__v16si) __W, 4079 (__mmask16) __U); 4080 } 4081 4082 4083 static __inline __m512i __DEFAULT_FN_ATTRS512 4084 _mm512_maskz_loadu_epi32(__mmask16 __U, void const *__P) 4085 { 4086 return (__m512i) __builtin_ia32_loaddqusi512_mask ((const int *)__P, 4087 (__v16si) 4088 _mm512_setzero_si512 (), 4089 (__mmask16) __U); 4090 } 4091 4092 static __inline __m512i __DEFAULT_FN_ATTRS512 4093 _mm512_loadu_epi64 (void const *__P) 4094 { 4095 struct __loadu_epi64 { 4096 __m512i_u __v; 4097 } __attribute__((__packed__, __may_alias__)); 4098 return ((const struct __loadu_epi64*)__P)->__v; 4099 } 4100 4101 static __inline __m512i __DEFAULT_FN_ATTRS512 4102 _mm512_mask_loadu_epi64 (__m512i __W, __mmask8 __U, void const *__P) 4103 { 4104 return (__m512i) __builtin_ia32_loaddqudi512_mask ((const long long *) __P, 4105 (__v8di) __W, 4106 (__mmask8) __U); 4107 } 4108 4109 static __inline __m512i __DEFAULT_FN_ATTRS512 4110 _mm512_maskz_loadu_epi64(__mmask8 __U, void const *__P) 4111 { 4112 return (__m512i) __builtin_ia32_loaddqudi512_mask ((const long long *)__P, 4113 (__v8di) 4114 _mm512_setzero_si512 (), 4115 (__mmask8) __U); 4116 } 4117 4118 static __inline __m512 __DEFAULT_FN_ATTRS512 4119 _mm512_mask_loadu_ps (__m512 __W, __mmask16 __U, void const *__P) 4120 { 4121 return (__m512) __builtin_ia32_loadups512_mask ((const float *) __P, 4122 (__v16sf) __W, 4123 (__mmask16) __U); 4124 } 4125 4126 static __inline __m512 __DEFAULT_FN_ATTRS512 4127 _mm512_maskz_loadu_ps(__mmask16 __U, void const *__P) 4128 { 4129 return (__m512) __builtin_ia32_loadups512_mask ((const float *)__P, 4130 (__v16sf) 4131 _mm512_setzero_ps (), 4132 (__mmask16) __U); 4133 } 4134 4135 static __inline __m512d __DEFAULT_FN_ATTRS512 4136 _mm512_mask_loadu_pd (__m512d __W, __mmask8 __U, void const *__P) 4137 { 4138 return (__m512d) __builtin_ia32_loadupd512_mask ((const double *) __P, 4139 (__v8df) __W, 4140 (__mmask8) __U); 4141 } 4142 4143 static __inline __m512d __DEFAULT_FN_ATTRS512 4144 _mm512_maskz_loadu_pd(__mmask8 __U, void const *__P) 4145 { 4146 return (__m512d) __builtin_ia32_loadupd512_mask ((const double *)__P, 4147 (__v8df) 4148 _mm512_setzero_pd (), 4149 (__mmask8) __U); 4150 } 4151 4152 static __inline __m512d __DEFAULT_FN_ATTRS512 4153 _mm512_loadu_pd(void const *__p) 4154 { 4155 struct __loadu_pd { 4156 __m512d_u __v; 4157 } __attribute__((__packed__, __may_alias__)); 4158 return ((const struct __loadu_pd*)__p)->__v; 4159 } 4160 4161 static __inline __m512 __DEFAULT_FN_ATTRS512 4162 _mm512_loadu_ps(void const *__p) 4163 { 4164 struct __loadu_ps { 4165 __m512_u __v; 4166 } __attribute__((__packed__, __may_alias__)); 4167 return ((const struct __loadu_ps*)__p)->__v; 4168 } 4169 4170 static __inline __m512 __DEFAULT_FN_ATTRS512 4171 _mm512_load_ps(void const *__p) 4172 { 4173 return *(const __m512*)__p; 4174 } 4175 4176 static __inline __m512 __DEFAULT_FN_ATTRS512 4177 _mm512_mask_load_ps (__m512 __W, __mmask16 __U, void const *__P) 4178 { 4179 return (__m512) __builtin_ia32_loadaps512_mask ((const __v16sf *) __P, 4180 (__v16sf) __W, 4181 (__mmask16) __U); 4182 } 4183 4184 static __inline __m512 __DEFAULT_FN_ATTRS512 4185 _mm512_maskz_load_ps(__mmask16 __U, void const *__P) 4186 { 4187 return (__m512) __builtin_ia32_loadaps512_mask ((const __v16sf *)__P, 4188 (__v16sf) 4189 _mm512_setzero_ps (), 4190 (__mmask16) __U); 4191 } 4192 4193 static __inline __m512d __DEFAULT_FN_ATTRS512 4194 _mm512_load_pd(void const *__p) 4195 { 4196 return *(const __m512d*)__p; 4197 } 4198 4199 static __inline __m512d __DEFAULT_FN_ATTRS512 4200 _mm512_mask_load_pd (__m512d __W, __mmask8 __U, void const *__P) 4201 { 4202 return (__m512d) __builtin_ia32_loadapd512_mask ((const __v8df *) __P, 4203 (__v8df) __W, 4204 (__mmask8) __U); 4205 } 4206 4207 static __inline __m512d __DEFAULT_FN_ATTRS512 4208 _mm512_maskz_load_pd(__mmask8 __U, void const *__P) 4209 { 4210 return (__m512d) __builtin_ia32_loadapd512_mask ((const __v8df *)__P, 4211 (__v8df) 4212 _mm512_setzero_pd (), 4213 (__mmask8) __U); 4214 } 4215 4216 static __inline __m512i __DEFAULT_FN_ATTRS512 4217 _mm512_load_si512 (void const *__P) 4218 { 4219 return *(const __m512i *) __P; 4220 } 4221 4222 static __inline __m512i __DEFAULT_FN_ATTRS512 4223 _mm512_load_epi32 (void const *__P) 4224 { 4225 return *(const __m512i *) __P; 4226 } 4227 4228 static __inline __m512i __DEFAULT_FN_ATTRS512 4229 _mm512_load_epi64 (void const *__P) 4230 { 4231 return *(const __m512i *) __P; 4232 } 4233 4234 /* SIMD store ops */ 4235 4236 static __inline void __DEFAULT_FN_ATTRS512 4237 _mm512_storeu_epi64 (void *__P, __m512i __A) 4238 { 4239 struct __storeu_epi64 { 4240 __m512i_u __v; 4241 } __attribute__((__packed__, __may_alias__)); 4242 ((struct __storeu_epi64*)__P)->__v = __A; 4243 } 4244 4245 static __inline void __DEFAULT_FN_ATTRS512 4246 _mm512_mask_storeu_epi64(void *__P, __mmask8 __U, __m512i __A) 4247 { 4248 __builtin_ia32_storedqudi512_mask ((long long *)__P, (__v8di) __A, 4249 (__mmask8) __U); 4250 } 4251 4252 static __inline void __DEFAULT_FN_ATTRS512 4253 _mm512_storeu_si512 (void *__P, __m512i __A) 4254 { 4255 struct __storeu_si512 { 4256 __m512i_u __v; 4257 } __attribute__((__packed__, __may_alias__)); 4258 ((struct __storeu_si512*)__P)->__v = __A; 4259 } 4260 4261 static __inline void __DEFAULT_FN_ATTRS512 4262 _mm512_storeu_epi32 (void *__P, __m512i __A) 4263 { 4264 struct __storeu_epi32 { 4265 __m512i_u __v; 4266 } __attribute__((__packed__, __may_alias__)); 4267 ((struct __storeu_epi32*)__P)->__v = __A; 4268 } 4269 4270 static __inline void __DEFAULT_FN_ATTRS512 4271 _mm512_mask_storeu_epi32(void *__P, __mmask16 __U, __m512i __A) 4272 { 4273 __builtin_ia32_storedqusi512_mask ((int *)__P, (__v16si) __A, 4274 (__mmask16) __U); 4275 } 4276 4277 static __inline void __DEFAULT_FN_ATTRS512 4278 _mm512_mask_storeu_pd(void *__P, __mmask8 __U, __m512d __A) 4279 { 4280 __builtin_ia32_storeupd512_mask ((double *)__P, (__v8df) __A, (__mmask8) __U); 4281 } 4282 4283 static __inline void __DEFAULT_FN_ATTRS512 4284 _mm512_storeu_pd(void *__P, __m512d __A) 4285 { 4286 struct __storeu_pd { 4287 __m512d_u __v; 4288 } __attribute__((__packed__, __may_alias__)); 4289 ((struct __storeu_pd*)__P)->__v = __A; 4290 } 4291 4292 static __inline void __DEFAULT_FN_ATTRS512 4293 _mm512_mask_storeu_ps(void *__P, __mmask16 __U, __m512 __A) 4294 { 4295 __builtin_ia32_storeups512_mask ((float *)__P, (__v16sf) __A, 4296 (__mmask16) __U); 4297 } 4298 4299 static __inline void __DEFAULT_FN_ATTRS512 4300 _mm512_storeu_ps(void *__P, __m512 __A) 4301 { 4302 struct __storeu_ps { 4303 __m512_u __v; 4304 } __attribute__((__packed__, __may_alias__)); 4305 ((struct __storeu_ps*)__P)->__v = __A; 4306 } 4307 4308 static __inline void __DEFAULT_FN_ATTRS512 4309 _mm512_mask_store_pd(void *__P, __mmask8 __U, __m512d __A) 4310 { 4311 __builtin_ia32_storeapd512_mask ((__v8df *)__P, (__v8df) __A, (__mmask8) __U); 4312 } 4313 4314 static __inline void __DEFAULT_FN_ATTRS512 4315 _mm512_store_pd(void *__P, __m512d __A) 4316 { 4317 *(__m512d*)__P = __A; 4318 } 4319 4320 static __inline void __DEFAULT_FN_ATTRS512 4321 _mm512_mask_store_ps(void *__P, __mmask16 __U, __m512 __A) 4322 { 4323 __builtin_ia32_storeaps512_mask ((__v16sf *)__P, (__v16sf) __A, 4324 (__mmask16) __U); 4325 } 4326 4327 static __inline void __DEFAULT_FN_ATTRS512 4328 _mm512_store_ps(void *__P, __m512 __A) 4329 { 4330 *(__m512*)__P = __A; 4331 } 4332 4333 static __inline void __DEFAULT_FN_ATTRS512 4334 _mm512_store_si512 (void *__P, __m512i __A) 4335 { 4336 *(__m512i *) __P = __A; 4337 } 4338 4339 static __inline void __DEFAULT_FN_ATTRS512 4340 _mm512_store_epi32 (void *__P, __m512i __A) 4341 { 4342 *(__m512i *) __P = __A; 4343 } 4344 4345 static __inline void __DEFAULT_FN_ATTRS512 4346 _mm512_store_epi64 (void *__P, __m512i __A) 4347 { 4348 *(__m512i *) __P = __A; 4349 } 4350 4351 /* Mask ops */ 4352 4353 static __inline __mmask16 __DEFAULT_FN_ATTRS_CONSTEXPR 4354 _mm512_knot(__mmask16 __M) { 4355 return __builtin_ia32_knothi(__M); 4356 } 4357 4358 /* Integer compare */ 4359 4360 #define _mm512_cmpeq_epi32_mask(A, B) \ 4361 _mm512_cmp_epi32_mask((A), (B), _MM_CMPINT_EQ) 4362 #define _mm512_mask_cmpeq_epi32_mask(k, A, B) \ 4363 _mm512_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_EQ) 4364 #define _mm512_cmpge_epi32_mask(A, B) \ 4365 _mm512_cmp_epi32_mask((A), (B), _MM_CMPINT_GE) 4366 #define _mm512_mask_cmpge_epi32_mask(k, A, B) \ 4367 _mm512_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_GE) 4368 #define _mm512_cmpgt_epi32_mask(A, B) \ 4369 _mm512_cmp_epi32_mask((A), (B), _MM_CMPINT_GT) 4370 #define _mm512_mask_cmpgt_epi32_mask(k, A, B) \ 4371 _mm512_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_GT) 4372 #define _mm512_cmple_epi32_mask(A, B) \ 4373 _mm512_cmp_epi32_mask((A), (B), _MM_CMPINT_LE) 4374 #define _mm512_mask_cmple_epi32_mask(k, A, B) \ 4375 _mm512_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_LE) 4376 #define _mm512_cmplt_epi32_mask(A, B) \ 4377 _mm512_cmp_epi32_mask((A), (B), _MM_CMPINT_LT) 4378 #define _mm512_mask_cmplt_epi32_mask(k, A, B) \ 4379 _mm512_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_LT) 4380 #define _mm512_cmpneq_epi32_mask(A, B) \ 4381 _mm512_cmp_epi32_mask((A), (B), _MM_CMPINT_NE) 4382 #define _mm512_mask_cmpneq_epi32_mask(k, A, B) \ 4383 _mm512_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_NE) 4384 4385 #define _mm512_cmpeq_epu32_mask(A, B) \ 4386 _mm512_cmp_epu32_mask((A), (B), _MM_CMPINT_EQ) 4387 #define _mm512_mask_cmpeq_epu32_mask(k, A, B) \ 4388 _mm512_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_EQ) 4389 #define _mm512_cmpge_epu32_mask(A, B) \ 4390 _mm512_cmp_epu32_mask((A), (B), _MM_CMPINT_GE) 4391 #define _mm512_mask_cmpge_epu32_mask(k, A, B) \ 4392 _mm512_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_GE) 4393 #define _mm512_cmpgt_epu32_mask(A, B) \ 4394 _mm512_cmp_epu32_mask((A), (B), _MM_CMPINT_GT) 4395 #define _mm512_mask_cmpgt_epu32_mask(k, A, B) \ 4396 _mm512_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_GT) 4397 #define _mm512_cmple_epu32_mask(A, B) \ 4398 _mm512_cmp_epu32_mask((A), (B), _MM_CMPINT_LE) 4399 #define _mm512_mask_cmple_epu32_mask(k, A, B) \ 4400 _mm512_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_LE) 4401 #define _mm512_cmplt_epu32_mask(A, B) \ 4402 _mm512_cmp_epu32_mask((A), (B), _MM_CMPINT_LT) 4403 #define _mm512_mask_cmplt_epu32_mask(k, A, B) \ 4404 _mm512_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_LT) 4405 #define _mm512_cmpneq_epu32_mask(A, B) \ 4406 _mm512_cmp_epu32_mask((A), (B), _MM_CMPINT_NE) 4407 #define _mm512_mask_cmpneq_epu32_mask(k, A, B) \ 4408 _mm512_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_NE) 4409 4410 #define _mm512_cmpeq_epi64_mask(A, B) \ 4411 _mm512_cmp_epi64_mask((A), (B), _MM_CMPINT_EQ) 4412 #define _mm512_mask_cmpeq_epi64_mask(k, A, B) \ 4413 _mm512_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_EQ) 4414 #define _mm512_cmpge_epi64_mask(A, B) \ 4415 _mm512_cmp_epi64_mask((A), (B), _MM_CMPINT_GE) 4416 #define _mm512_mask_cmpge_epi64_mask(k, A, B) \ 4417 _mm512_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_GE) 4418 #define _mm512_cmpgt_epi64_mask(A, B) \ 4419 _mm512_cmp_epi64_mask((A), (B), _MM_CMPINT_GT) 4420 #define _mm512_mask_cmpgt_epi64_mask(k, A, B) \ 4421 _mm512_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_GT) 4422 #define _mm512_cmple_epi64_mask(A, B) \ 4423 _mm512_cmp_epi64_mask((A), (B), _MM_CMPINT_LE) 4424 #define _mm512_mask_cmple_epi64_mask(k, A, B) \ 4425 _mm512_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_LE) 4426 #define _mm512_cmplt_epi64_mask(A, B) \ 4427 _mm512_cmp_epi64_mask((A), (B), _MM_CMPINT_LT) 4428 #define _mm512_mask_cmplt_epi64_mask(k, A, B) \ 4429 _mm512_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_LT) 4430 #define _mm512_cmpneq_epi64_mask(A, B) \ 4431 _mm512_cmp_epi64_mask((A), (B), _MM_CMPINT_NE) 4432 #define _mm512_mask_cmpneq_epi64_mask(k, A, B) \ 4433 _mm512_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_NE) 4434 4435 #define _mm512_cmpeq_epu64_mask(A, B) \ 4436 _mm512_cmp_epu64_mask((A), (B), _MM_CMPINT_EQ) 4437 #define _mm512_mask_cmpeq_epu64_mask(k, A, B) \ 4438 _mm512_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_EQ) 4439 #define _mm512_cmpge_epu64_mask(A, B) \ 4440 _mm512_cmp_epu64_mask((A), (B), _MM_CMPINT_GE) 4441 #define _mm512_mask_cmpge_epu64_mask(k, A, B) \ 4442 _mm512_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_GE) 4443 #define _mm512_cmpgt_epu64_mask(A, B) \ 4444 _mm512_cmp_epu64_mask((A), (B), _MM_CMPINT_GT) 4445 #define _mm512_mask_cmpgt_epu64_mask(k, A, B) \ 4446 _mm512_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_GT) 4447 #define _mm512_cmple_epu64_mask(A, B) \ 4448 _mm512_cmp_epu64_mask((A), (B), _MM_CMPINT_LE) 4449 #define _mm512_mask_cmple_epu64_mask(k, A, B) \ 4450 _mm512_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_LE) 4451 #define _mm512_cmplt_epu64_mask(A, B) \ 4452 _mm512_cmp_epu64_mask((A), (B), _MM_CMPINT_LT) 4453 #define _mm512_mask_cmplt_epu64_mask(k, A, B) \ 4454 _mm512_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_LT) 4455 #define _mm512_cmpneq_epu64_mask(A, B) \ 4456 _mm512_cmp_epu64_mask((A), (B), _MM_CMPINT_NE) 4457 #define _mm512_mask_cmpneq_epu64_mask(k, A, B) \ 4458 _mm512_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_NE) 4459 4460 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4461 _mm512_cvtepi8_epi32(__m128i __A) { 4462 /* This function always performs a signed extension, but __v16qi is a char 4463 which may be signed or unsigned, so use __v16qs. */ 4464 return (__m512i)__builtin_convertvector((__v16qs)__A, __v16si); 4465 } 4466 4467 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4468 _mm512_mask_cvtepi8_epi32(__m512i __W, __mmask16 __U, __m128i __A) { 4469 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 4470 (__v16si)_mm512_cvtepi8_epi32(__A), 4471 (__v16si)__W); 4472 } 4473 4474 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4475 _mm512_maskz_cvtepi8_epi32(__mmask16 __U, __m128i __A) { 4476 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 4477 (__v16si)_mm512_cvtepi8_epi32(__A), 4478 (__v16si)_mm512_setzero_si512()); 4479 } 4480 4481 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4482 _mm512_cvtepi8_epi64(__m128i __A) { 4483 /* This function always performs a signed extension, but __v16qi is a char 4484 which may be signed or unsigned, so use __v16qs. */ 4485 return (__m512i)__builtin_convertvector(__builtin_shufflevector((__v16qs)__A, (__v16qs)__A, 0, 1, 2, 3, 4, 5, 6, 7), __v8di); 4486 } 4487 4488 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4489 _mm512_mask_cvtepi8_epi64(__m512i __W, __mmask8 __U, __m128i __A) { 4490 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4491 (__v8di)_mm512_cvtepi8_epi64(__A), 4492 (__v8di)__W); 4493 } 4494 4495 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4496 _mm512_maskz_cvtepi8_epi64(__mmask8 __U, __m128i __A) { 4497 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4498 (__v8di)_mm512_cvtepi8_epi64(__A), 4499 (__v8di)_mm512_setzero_si512 ()); 4500 } 4501 4502 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4503 _mm512_cvtepi32_epi64(__m256i __X) { 4504 return (__m512i)__builtin_convertvector((__v8si)__X, __v8di); 4505 } 4506 4507 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4508 _mm512_mask_cvtepi32_epi64(__m512i __W, __mmask8 __U, __m256i __X) { 4509 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4510 (__v8di)_mm512_cvtepi32_epi64(__X), 4511 (__v8di)__W); 4512 } 4513 4514 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4515 _mm512_maskz_cvtepi32_epi64(__mmask8 __U, __m256i __X) { 4516 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4517 (__v8di)_mm512_cvtepi32_epi64(__X), 4518 (__v8di)_mm512_setzero_si512()); 4519 } 4520 4521 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4522 _mm512_cvtepi16_epi32(__m256i __A) { 4523 return (__m512i)__builtin_convertvector((__v16hi)__A, __v16si); 4524 } 4525 4526 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4527 _mm512_mask_cvtepi16_epi32(__m512i __W, __mmask16 __U, __m256i __A) { 4528 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 4529 (__v16si)_mm512_cvtepi16_epi32(__A), 4530 (__v16si)__W); 4531 } 4532 4533 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4534 _mm512_maskz_cvtepi16_epi32(__mmask16 __U, __m256i __A) { 4535 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 4536 (__v16si)_mm512_cvtepi16_epi32(__A), 4537 (__v16si)_mm512_setzero_si512 ()); 4538 } 4539 4540 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4541 _mm512_cvtepi16_epi64(__m128i __A) { 4542 return (__m512i)__builtin_convertvector((__v8hi)__A, __v8di); 4543 } 4544 4545 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4546 _mm512_mask_cvtepi16_epi64(__m512i __W, __mmask8 __U, __m128i __A) { 4547 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4548 (__v8di)_mm512_cvtepi16_epi64(__A), 4549 (__v8di)__W); 4550 } 4551 4552 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4553 _mm512_maskz_cvtepi16_epi64(__mmask8 __U, __m128i __A) { 4554 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4555 (__v8di)_mm512_cvtepi16_epi64(__A), 4556 (__v8di)_mm512_setzero_si512()); 4557 } 4558 4559 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4560 _mm512_cvtepu8_epi32(__m128i __A) { 4561 return (__m512i)__builtin_convertvector((__v16qu)__A, __v16si); 4562 } 4563 4564 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4565 _mm512_mask_cvtepu8_epi32(__m512i __W, __mmask16 __U, __m128i __A) { 4566 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 4567 (__v16si)_mm512_cvtepu8_epi32(__A), 4568 (__v16si)__W); 4569 } 4570 4571 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4572 _mm512_maskz_cvtepu8_epi32(__mmask16 __U, __m128i __A) { 4573 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 4574 (__v16si)_mm512_cvtepu8_epi32(__A), 4575 (__v16si)_mm512_setzero_si512()); 4576 } 4577 4578 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4579 _mm512_cvtepu8_epi64(__m128i __A) { 4580 return (__m512i)__builtin_convertvector(__builtin_shufflevector((__v16qu)__A, (__v16qu)__A, 0, 1, 2, 3, 4, 5, 6, 7), __v8di); 4581 } 4582 4583 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4584 _mm512_mask_cvtepu8_epi64(__m512i __W, __mmask8 __U, __m128i __A) { 4585 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4586 (__v8di)_mm512_cvtepu8_epi64(__A), 4587 (__v8di)__W); 4588 } 4589 4590 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4591 _mm512_maskz_cvtepu8_epi64(__mmask8 __U, __m128i __A) { 4592 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4593 (__v8di)_mm512_cvtepu8_epi64(__A), 4594 (__v8di)_mm512_setzero_si512()); 4595 } 4596 4597 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4598 _mm512_cvtepu32_epi64(__m256i __X) { 4599 return (__m512i)__builtin_convertvector((__v8su)__X, __v8di); 4600 } 4601 4602 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4603 _mm512_mask_cvtepu32_epi64(__m512i __W, __mmask8 __U, __m256i __X) { 4604 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4605 (__v8di)_mm512_cvtepu32_epi64(__X), 4606 (__v8di)__W); 4607 } 4608 4609 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4610 _mm512_maskz_cvtepu32_epi64(__mmask8 __U, __m256i __X) { 4611 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4612 (__v8di)_mm512_cvtepu32_epi64(__X), 4613 (__v8di)_mm512_setzero_si512()); 4614 } 4615 4616 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4617 _mm512_cvtepu16_epi32(__m256i __A) { 4618 return (__m512i)__builtin_convertvector((__v16hu)__A, __v16si); 4619 } 4620 4621 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4622 _mm512_mask_cvtepu16_epi32(__m512i __W, __mmask16 __U, __m256i __A) { 4623 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 4624 (__v16si)_mm512_cvtepu16_epi32(__A), 4625 (__v16si)__W); 4626 } 4627 4628 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4629 _mm512_maskz_cvtepu16_epi32(__mmask16 __U, __m256i __A) { 4630 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 4631 (__v16si)_mm512_cvtepu16_epi32(__A), 4632 (__v16si)_mm512_setzero_si512()); 4633 } 4634 4635 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4636 _mm512_cvtepu16_epi64(__m128i __A) { 4637 return (__m512i)__builtin_convertvector((__v8hu)__A, __v8di); 4638 } 4639 4640 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4641 _mm512_mask_cvtepu16_epi64(__m512i __W, __mmask8 __U, __m128i __A) { 4642 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4643 (__v8di)_mm512_cvtepu16_epi64(__A), 4644 (__v8di)__W); 4645 } 4646 4647 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4648 _mm512_maskz_cvtepu16_epi64(__mmask8 __U, __m128i __A) { 4649 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4650 (__v8di)_mm512_cvtepu16_epi64(__A), 4651 (__v8di)_mm512_setzero_si512()); 4652 } 4653 4654 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4655 _mm512_rorv_epi32 (__m512i __A, __m512i __B) 4656 { 4657 return (__m512i)__builtin_elementwise_fshr((__v16su)__A,(__v16su)__A, (__v16su)__B); 4658 } 4659 4660 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4661 _mm512_mask_rorv_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) 4662 { 4663 return (__m512i)__builtin_ia32_selectd_512(__U, 4664 (__v16si)_mm512_rorv_epi32(__A, __B), 4665 (__v16si)__W); 4666 } 4667 4668 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4669 _mm512_maskz_rorv_epi32 (__mmask16 __U, __m512i __A, __m512i __B) 4670 { 4671 return (__m512i)__builtin_ia32_selectd_512(__U, 4672 (__v16si)_mm512_rorv_epi32(__A, __B), 4673 (__v16si)_mm512_setzero_si512()); 4674 } 4675 4676 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4677 _mm512_rorv_epi64 (__m512i __A, __m512i __B) 4678 { 4679 return (__m512i)__builtin_elementwise_fshr((__v8du)__A, (__v8du)__A, (__v8du)__B); 4680 } 4681 4682 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4683 _mm512_mask_rorv_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) 4684 { 4685 return (__m512i)__builtin_ia32_selectq_512(__U, 4686 (__v8di)_mm512_rorv_epi64(__A, __B), 4687 (__v8di)__W); 4688 } 4689 4690 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4691 _mm512_maskz_rorv_epi64 (__mmask8 __U, __m512i __A, __m512i __B) 4692 { 4693 return (__m512i)__builtin_ia32_selectq_512(__U, 4694 (__v8di)_mm512_rorv_epi64(__A, __B), 4695 (__v8di)_mm512_setzero_si512()); 4696 } 4697 4698 4699 4700 #define _mm512_cmp_epi32_mask(a, b, p) \ 4701 ((__mmask16)__builtin_ia32_cmpd512_mask((__v16si)(__m512i)(a), \ 4702 (__v16si)(__m512i)(b), (int)(p), \ 4703 (__mmask16)-1)) 4704 4705 #define _mm512_cmp_epu32_mask(a, b, p) \ 4706 ((__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)(__m512i)(a), \ 4707 (__v16si)(__m512i)(b), (int)(p), \ 4708 (__mmask16)-1)) 4709 4710 #define _mm512_cmp_epi64_mask(a, b, p) \ 4711 ((__mmask8)__builtin_ia32_cmpq512_mask((__v8di)(__m512i)(a), \ 4712 (__v8di)(__m512i)(b), (int)(p), \ 4713 (__mmask8)-1)) 4714 4715 #define _mm512_cmp_epu64_mask(a, b, p) \ 4716 ((__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)(__m512i)(a), \ 4717 (__v8di)(__m512i)(b), (int)(p), \ 4718 (__mmask8)-1)) 4719 4720 #define _mm512_mask_cmp_epi32_mask(m, a, b, p) \ 4721 ((__mmask16)__builtin_ia32_cmpd512_mask((__v16si)(__m512i)(a), \ 4722 (__v16si)(__m512i)(b), (int)(p), \ 4723 (__mmask16)(m))) 4724 4725 #define _mm512_mask_cmp_epu32_mask(m, a, b, p) \ 4726 ((__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)(__m512i)(a), \ 4727 (__v16si)(__m512i)(b), (int)(p), \ 4728 (__mmask16)(m))) 4729 4730 #define _mm512_mask_cmp_epi64_mask(m, a, b, p) \ 4731 ((__mmask8)__builtin_ia32_cmpq512_mask((__v8di)(__m512i)(a), \ 4732 (__v8di)(__m512i)(b), (int)(p), \ 4733 (__mmask8)(m))) 4734 4735 #define _mm512_mask_cmp_epu64_mask(m, a, b, p) \ 4736 ((__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)(__m512i)(a), \ 4737 (__v8di)(__m512i)(b), (int)(p), \ 4738 (__mmask8)(m))) 4739 4740 #define _mm512_rol_epi32(a, b) \ 4741 ((__m512i)__builtin_ia32_prold512((__v16si)(__m512i)(a), (int)(b))) 4742 4743 #define _mm512_mask_rol_epi32(W, U, a, b) \ 4744 ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \ 4745 (__v16si)_mm512_rol_epi32((a), (b)), \ 4746 (__v16si)(__m512i)(W))) 4747 4748 #define _mm512_maskz_rol_epi32(U, a, b) \ 4749 ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \ 4750 (__v16si)_mm512_rol_epi32((a), (b)), \ 4751 (__v16si)_mm512_setzero_si512())) 4752 4753 #define _mm512_rol_epi64(a, b) \ 4754 ((__m512i)__builtin_ia32_prolq512((__v8di)(__m512i)(a), (int)(b))) 4755 4756 #define _mm512_mask_rol_epi64(W, U, a, b) \ 4757 ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \ 4758 (__v8di)_mm512_rol_epi64((a), (b)), \ 4759 (__v8di)(__m512i)(W))) 4760 4761 #define _mm512_maskz_rol_epi64(U, a, b) \ 4762 ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \ 4763 (__v8di)_mm512_rol_epi64((a), (b)), \ 4764 (__v8di)_mm512_setzero_si512())) 4765 4766 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4767 _mm512_rolv_epi32 (__m512i __A, __m512i __B) 4768 { 4769 return (__m512i)__builtin_elementwise_fshl((__v16su)__A, (__v16su)__A, (__v16su)__B); 4770 } 4771 4772 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4773 _mm512_mask_rolv_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) 4774 { 4775 return (__m512i)__builtin_ia32_selectd_512(__U, 4776 (__v16si)_mm512_rolv_epi32(__A, __B), 4777 (__v16si)__W); 4778 } 4779 4780 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4781 _mm512_maskz_rolv_epi32 (__mmask16 __U, __m512i __A, __m512i __B) 4782 { 4783 return (__m512i)__builtin_ia32_selectd_512(__U, 4784 (__v16si)_mm512_rolv_epi32(__A, __B), 4785 (__v16si)_mm512_setzero_si512()); 4786 } 4787 4788 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4789 _mm512_rolv_epi64 (__m512i __A, __m512i __B) 4790 { 4791 return (__m512i)__builtin_elementwise_fshl((__v8du)__A, (__v8du)__A, (__v8du)__B); 4792 } 4793 4794 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4795 _mm512_mask_rolv_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) 4796 { 4797 return (__m512i)__builtin_ia32_selectq_512(__U, 4798 (__v8di)_mm512_rolv_epi64(__A, __B), 4799 (__v8di)__W); 4800 } 4801 4802 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4803 _mm512_maskz_rolv_epi64 (__mmask8 __U, __m512i __A, __m512i __B) 4804 { 4805 return (__m512i)__builtin_ia32_selectq_512(__U, 4806 (__v8di)_mm512_rolv_epi64(__A, __B), 4807 (__v8di)_mm512_setzero_si512()); 4808 } 4809 4810 #define _mm512_ror_epi32(A, B) \ 4811 ((__m512i)__builtin_ia32_prord512((__v16si)(__m512i)(A), (int)(B))) 4812 4813 #define _mm512_mask_ror_epi32(W, U, A, B) \ 4814 ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \ 4815 (__v16si)_mm512_ror_epi32((A), (B)), \ 4816 (__v16si)(__m512i)(W))) 4817 4818 #define _mm512_maskz_ror_epi32(U, A, B) \ 4819 ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \ 4820 (__v16si)_mm512_ror_epi32((A), (B)), \ 4821 (__v16si)_mm512_setzero_si512())) 4822 4823 #define _mm512_ror_epi64(A, B) \ 4824 ((__m512i)__builtin_ia32_prorq512((__v8di)(__m512i)(A), (int)(B))) 4825 4826 #define _mm512_mask_ror_epi64(W, U, A, B) \ 4827 ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \ 4828 (__v8di)_mm512_ror_epi64((A), (B)), \ 4829 (__v8di)(__m512i)(W))) 4830 4831 #define _mm512_maskz_ror_epi64(U, A, B) \ 4832 ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \ 4833 (__v8di)_mm512_ror_epi64((A), (B)), \ 4834 (__v8di)_mm512_setzero_si512())) 4835 4836 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4837 _mm512_slli_epi32(__m512i __A, unsigned int __B) { 4838 return (__m512i)__builtin_ia32_pslldi512((__v16si)__A, (int)__B); 4839 } 4840 4841 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4842 _mm512_mask_slli_epi32(__m512i __W, __mmask16 __U, __m512i __A, 4843 unsigned int __B) { 4844 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 4845 (__v16si)_mm512_slli_epi32(__A, __B), 4846 (__v16si)__W); 4847 } 4848 4849 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4850 _mm512_maskz_slli_epi32(__mmask16 __U, __m512i __A, unsigned int __B) { 4851 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 4852 (__v16si)_mm512_slli_epi32(__A, __B), 4853 (__v16si)_mm512_setzero_si512()); 4854 } 4855 4856 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4857 _mm512_slli_epi64(__m512i __A, unsigned int __B) { 4858 return (__m512i)__builtin_ia32_psllqi512((__v8di)__A, (int)__B); 4859 } 4860 4861 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4862 _mm512_mask_slli_epi64(__m512i __W, __mmask8 __U, __m512i __A, 4863 unsigned int __B) { 4864 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4865 (__v8di)_mm512_slli_epi64(__A, __B), 4866 (__v8di)__W); 4867 } 4868 4869 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4870 _mm512_maskz_slli_epi64(__mmask8 __U, __m512i __A, unsigned int __B) { 4871 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4872 (__v8di)_mm512_slli_epi64(__A, __B), 4873 (__v8di)_mm512_setzero_si512()); 4874 } 4875 4876 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4877 _mm512_srli_epi32(__m512i __A, unsigned int __B) { 4878 return (__m512i)__builtin_ia32_psrldi512((__v16si)__A, (int)__B); 4879 } 4880 4881 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4882 _mm512_mask_srli_epi32(__m512i __W, __mmask16 __U, __m512i __A, 4883 unsigned int __B) { 4884 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 4885 (__v16si)_mm512_srli_epi32(__A, __B), 4886 (__v16si)__W); 4887 } 4888 4889 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4890 _mm512_maskz_srli_epi32(__mmask16 __U, __m512i __A, unsigned int __B) { 4891 return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, 4892 (__v16si)_mm512_srli_epi32(__A, __B), 4893 (__v16si)_mm512_setzero_si512()); 4894 } 4895 4896 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4897 _mm512_srli_epi64(__m512i __A, unsigned int __B) { 4898 return (__m512i)__builtin_ia32_psrlqi512((__v8di)__A, (int)__B); 4899 } 4900 4901 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4902 _mm512_mask_srli_epi64(__m512i __W, __mmask8 __U, __m512i __A, 4903 unsigned int __B) { 4904 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4905 (__v8di)_mm512_srli_epi64(__A, __B), 4906 (__v8di)__W); 4907 } 4908 4909 static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR 4910 _mm512_maskz_srli_epi64(__mmask8 __U, __m512i __A, unsigned int __B) { 4911 return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U, 4912 (__v8di)_mm512_srli_epi64(__A, __B), 4913 (__v8di)_mm512_setzero_si512()); 4914 } 4915 4916 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4917 _mm512_mask_load_epi32 (__m512i __W, __mmask16 __U, void const *__P) 4918 { 4919 return (__m512i) __builtin_ia32_movdqa32load512_mask ((const __v16si *) __P, 4920 (__v16si) __W, 4921 (__mmask16) __U); 4922 } 4923 4924 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4925 _mm512_maskz_load_epi32 (__mmask16 __U, void const *__P) 4926 { 4927 return (__m512i) __builtin_ia32_movdqa32load512_mask ((const __v16si *) __P, 4928 (__v16si) 4929 _mm512_setzero_si512 (), 4930 (__mmask16) __U); 4931 } 4932 4933 static __inline__ void __DEFAULT_FN_ATTRS512 4934 _mm512_mask_store_epi32 (void *__P, __mmask16 __U, __m512i __A) 4935 { 4936 __builtin_ia32_movdqa32store512_mask ((__v16si *) __P, (__v16si) __A, 4937 (__mmask16) __U); 4938 } 4939 4940 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4941 _mm512_mask_mov_epi32 (__m512i __W, __mmask16 __U, __m512i __A) 4942 { 4943 return (__m512i) __builtin_ia32_selectd_512 ((__mmask16) __U, 4944 (__v16si) __A, 4945 (__v16si) __W); 4946 } 4947 4948 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4949 _mm512_maskz_mov_epi32 (__mmask16 __U, __m512i __A) 4950 { 4951 return (__m512i) __builtin_ia32_selectd_512 ((__mmask16) __U, 4952 (__v16si) __A, 4953 (__v16si) _mm512_setzero_si512 ()); 4954 } 4955 4956 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4957 _mm512_mask_mov_epi64 (__m512i __W, __mmask8 __U, __m512i __A) 4958 { 4959 return (__m512i) __builtin_ia32_selectq_512 ((__mmask8) __U, 4960 (__v8di) __A, 4961 (__v8di) __W); 4962 } 4963 4964 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4965 _mm512_maskz_mov_epi64 (__mmask8 __U, __m512i __A) 4966 { 4967 return (__m512i) __builtin_ia32_selectq_512 ((__mmask8) __U, 4968 (__v8di) __A, 4969 (__v8di) _mm512_setzero_si512 ()); 4970 } 4971 4972 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4973 _mm512_mask_load_epi64 (__m512i __W, __mmask8 __U, void const *__P) 4974 { 4975 return (__m512i) __builtin_ia32_movdqa64load512_mask ((const __v8di *) __P, 4976 (__v8di) __W, 4977 (__mmask8) __U); 4978 } 4979 4980 static __inline__ __m512i __DEFAULT_FN_ATTRS512 4981 _mm512_maskz_load_epi64 (__mmask8 __U, void const *__P) 4982 { 4983 return (__m512i) __builtin_ia32_movdqa64load512_mask ((const __v8di *) __P, 4984 (__v8di) 4985 _mm512_setzero_si512 (), 4986 (__mmask8) __U); 4987 } 4988 4989 static __inline__ void __DEFAULT_FN_ATTRS512 4990 _mm512_mask_store_epi64 (void *__P, __mmask8 __U, __m512i __A) 4991 { 4992 __builtin_ia32_movdqa64store512_mask ((__v8di *) __P, (__v8di) __A, 4993 (__mmask8) __U); 4994 } 4995 4996 static __inline__ __m512d __DEFAULT_FN_ATTRS512_CONSTEXPR 4997 _mm512_movedup_pd (__m512d __A) 4998 { 4999 return (__m512d)__builtin_shufflevector((__v8df)__A, (__v8df)__A, 5000 0, 0, 2, 2, 4, 4, 6, 6);