LLVM SIMD code generation bug - "Both operands to ICmp instruction are not of the same type!"

[ChuuniMage]

Context

Please provide any relevant information about your setup. This is important in case the issue is not reproducible except for under certain conditions.

• Operating System & Odin Version: Windows 10, version dev-2024-12:597fba7c3
• Please paste odin report output:
  Odin: dev-2024-12:597fba7c3
  OS: Windows 10 Professional (version: 20H2), build 19042.1706
  CPU: Intel(R) Core(TM) i7-10700KF CPU @ 3.80GHz
  RAM: 32637 MiB
  Backend: LLVM 18.1.8

Expected Behavior

LLVM compiles the proc GET_ANIM_IDX_SIMD correctly

Current Behavior

Following llvm error is generated with "odin run .":

`
LLVM CODE GEN FAILED FOR PROCEDURE: main.GET_ANIM_IDX_SIMD
define i32 @main.GET_ANIM_IDX_SIMD(ptr %0, i32 %1, ptr noalias nocapture nonnull %__.context_ptr) {
decls:
%2 = alloca <4 x i32>, align 16
%3 = alloca i32, align 4
%4 = alloca <4 x i32>, align 16
%INDICES = alloca <4 x i32>, align 16
%GT = alloca <4 x i32>, align 16
%result = alloca i32, align 4
br label %entry

entry: ; preds = %decls
call void @llvm.memcpy.inline.p0.p0.i64(ptr %2, ptr %0, i64 16, i1 false)
store i32 %1, ptr %3, align 4
store <4 x i32> zeroinitializer, ptr %4, align 16
%5 = insertelement <4 x i32> zeroinitializer, i32 %1, i32 0
%6 = insertelement <4 x i32> %5, i32 %1, i32 1
%7 = insertelement <4 x i32> %6, i32 %1, i32 2
%8 = insertelement <4 x i32> %7, i32 %1, i32 3
store <4 x i32> %8, ptr %4, align 16
%9 = load <4 x i32>, ptr %4, align 16
store <4 x i32> %9, ptr %INDICES, align 16
%10 = load <4 x i32>, ptr %2, align 16
%11 = icmp sgt <4 x i32> %10, i32 %1
%12 = sext <4 x i1> %11 to <4 x i32>
store <4 x i32> %12, ptr %GT, align 16
%13 = load <4 x i32>, ptr %GT, align 16
%14 = sub <4 x i32> zeroinitializer, %13
store <4 x i32> %14, ptr %GT, align 16
%15 = load <4 x i32>, ptr %GT, align 16
%16 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %15)
store i32 %16, ptr %result, align 4
%17 = load i32, ptr %result, align 4
ret i32 %17
}

Both operands to ICmp instruction are not of the same type!
%11 = icmp sgt <4 x i32> %10, i32 %1

Steps to Reproduce

Run the provided code

package main;

import "core:fmt";

Universal_Player_States :: enum {
_5,
_2,
_Transition_5_to_2,
_Transition_2_to_5,
_WALK_F,
_WALK_B,
_DASH_F,
_DASH_B,
_5G,
_2G,
_Transition_5G_to_2G,
_Transition_2G_to_5G,
_Blockstun_5ing,
_Blockstun_2ing,
_Hitstun_Stand_Highreel,
_Hitstun_Stand_Midgut,
_Hitstun_Crouch_Reel,
_ThrowBreaking,
_Dead,
_Ringout,
}

// Optimise this to make this a flat array of 5 elements? perhaps 8 for cache alignment? or does just the whole thing need to be cache aligned?
// curious optimisation cases

HBOX_DURATIONS_UNIVERSAL :: [Universal_Player_States][]i32{
._5 = {66, },
._2 = {255,},
._Transition_5_to_2 = {3,},
._Transition_2_to_5 = {3, },
._WALK_F = {32,},
._WALK_B = {28,},
._DASH_F = {16,},
._DASH_B = {14,},
._5G = {255,},
._2G = {255,},
._Transition_5G_to_2G = {5,},
._Transition_2G_to_5G = {4,},
._Blockstun_5ing = {255,},
._Blockstun_2ing = {255,},
._Hitstun_Stand_Highreel = {255,},
._Hitstun_Stand_Midgut = {255,},
._Hitstun_Crouch_Reel = {255,},
._ThrowBreaking = {38,},
._Dead = {35, 155},
._Ringout = {255,},
}

HBOX_DURATIONS_CLASSIC :: [Classic_Player_State][]i32{
._5S = {11, 14, 18, 27,},
._2S = {11, 13, 17, 33,},
._6S = {13, 15, 26, 32, 36,},
._3S = {14, 16, 20, 42,},
._8S = {7, 19, 21, 27, 42,},
._5Throw = {9, 14, 33,},
._5Throw_Hitting = {12, 14, 36},
._4Throw = {9, 14, 33,},
._4Throw_Hitting = {24, 34, 45, 52,},
}

Character :: enum {
Classic,
Wrassler,
Striker,
CounterMan,
}

Classic_Player_State :: enum {
_5S,
_2S,
_6S,
_3S,
_8S,
_5Throw,
_5Throw_Hitting,
_4Throw,
_4Throw_Hitting,
}

Wrassler_Player_State :: enum {
_5S,
_2S,
_6S,
_3S,
_4S,
_5Throw,
_5Throw_Hitting,
_4Throw,
_4Throw_Hitting,
_6Throw,
_6Throw_Hitting,
}

Striker_Player_State :: enum {
_5S,
_2S,
_6S,
_6Sstr_S,
_3S,
_1S,
_5Throw,
_5Throw_Hitting,
_6Throw,
_6Throw_Hitting,
}

CounterMan_Player_State :: enum {
_5S,
_2S,
_6S,
_8S,
_3S,
_1S,
_5Throw,
_5Throw_Hitting,
_6Throw,
_6Throw_Hitting,
_4Throw,
_4Throw_Hitting,
}

Which_Player_State :: enum {
_Universal,
_CharSpecific,
}

// Problem: Need to use an enum for which character they are using anyway
// so which should just be 1 bit 61 thingo anyway

_Player_State_1 :: bit_field u64 {
which: Which_Player_State | 1,
p_state: Universal_Player_States | 63,
}

_Player_State_2 :: bit_field u64 {
which: Which_Player_State | 1,
c_state: Classic_Player_State | 63,
}

_Player_State_3 :: bit_field u64 {
which: Which_Player_State | 1,
c_state: Wrassler_Player_State | 63,
}

_Player_State_4 :: bit_field u64 {
which: Which_Player_State | 1,
c_state: Striker_Player_State | 63,
}

_Player_State_5 :: bit_field u64 {
which: Which_Player_State | 1,
c_state: CounterMan_Player_State | 63,
}

Player_State :: struct #raw_union {
using _: _Player_State_1,
using _: _Player_State_2,
using _: _Player_State_3,
using _: _Player_State_4,
using _: _Player_State_5,
}

Cursed_1 :: bit_field u64 {
uh_oh: i32 | 32,
}

Cursed_2 :: bit_field u64 {
uh_oh: u8 | 8,
}

Cursed :: struct #raw_union {
using _:Cursed_1
}

Player_Data :: struct {
state_counter: i32,
character: Character,
current_state: Player_State,
}

GET_ANIM_IDX_ORIGINAL :: proc (dur:[]i32, state_counter:i32) -> i32 {
anim_idx := i32{}
for el, idx in dur {
if state_counter > el do continue;
anim_idx = cast(i32)idx
break;
}
return anim_idx
}

_5S_SIMD :: #simd[4]i32{11, 14, 18, 27,}

import "core:simd"

GET_ANIM_IDX_SIMD :: proc (dur:#simd[4]i32, state_counter:i32) -> i32 {

INDICES : #simd[4]i32 = {state_counter, state_counter, state_counter, state_counter}

GT := simd.lanes_gt(dur, state_counter)
GT = simd.neg(GT)
result := simd.reduce_add_ordered(GT)
return transmute(i32)result
}

// import "shared:prof"

expected_5S_index := [28]i32 {
0 = 0,
1 = 0,
2 = 0,
3 = 0,
4 = 0,
5 = 0,
6 = 0,
7 = 0,
8 = 0,
9 = 0,
10 = 0,
11 = 0,
12 = 1,
13 = 1,
14 = 1,
15 = 2,
16 = 2,
17 = 2,
18 = 2,
19 = 3,
20 = 3,
21 = 3,
22 = 3,
23 = 3,
24 = 3,
25 = 3,
26 = 3,
27 = 3,
}

main :: proc(){
fmt.printf("Hello, world! Your Odin project is set up.\n")
honk:Player_State
honk.which = ._Universal
honk.p_state = ._5
honk.c_state = ._5S
for i in cast(i32)0..=27 {
result := GET_ANIM_IDX_ORIGINAL(HBOX_DURATIONS_CLASSIC[._5S], i)
assert(result == expected_5S_index[i])
}
fmt.printf("Original test passed!")
for i in cast(i32)0..=27 {
result := GET_ANIM_IDX_SIMD(_5S_SIMD, i)
assert(result == expected_5S_index[i])
}
fmt.printf("SIMD test passed!")
result:i32
// prof.TIME_TYPE = .micros

fmt.printf("Original algorithm: ")
for x in 0..<1_000_000 {
for i in cast(i32)0..=27 {
// prof.profile_start(.micros)
result = GET_ANIM_IDX_ORIGINAL(HBOX_DURATIONS_CLASSIC[._5S], i)
// prof.profile_end()
assert(result != -1)
}
}
// prof.average_profiling_data()

fmt.printf("SIMD algorithm: ")
for x in 0..<1_000_000 {
for i in cast(i32)0..=27 {
// prof.profile_start(.micros)
result = GET_ANIM_IDX_SIMD(_5S_SIMD, i)
// prof.profile_end()
assert(result != -1)
}
}
// prof.average_profiling_data()

fmt.printf("cursed %v \n", honk.which)
};