test compile precise-output
set enable_llvm_abi_extensions=true
target x86_64



function %ishl_i128_i128(i128, i8) -> i128 {
block0(v0: i128, v1: i8):
    v2 = uextend.i64 v1
    v3 = iconcat v2, v2

    v4 = ishl.i128 v0, v3

    return v4
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movzbq  %dl, %rcx
;   movq    %rdi, %rdx
;   shlq    %cl, %rdx, %rdx
;   movq    %rsi, %r11
;   shlq    %cl, %r11, %r11
;   movq    %rcx, %r9
;   movl    $64, %ecx
;   movq    %r9, %r8
;   subq    %rcx, %r8, %rcx
;   movq    %rdi, %r10
;   shrq    %cl, %r10, %r10
;   xorq    %rax, %rax, %rax
;   testq   $127, %r8
;   cmovzq  %rax, %r10, %r10
;   orq     %r10, %r11, %r10
;   testq   $64, %r8
;   cmovzq  %rdx, %rax, %rax
;   cmovzq  %r10, %rdx, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movzbq %dl, %rcx
;   movq %rdi, %rdx
;   shlq %cl, %rdx
;   movq %rsi, %r11
;   shlq %cl, %r11
;   movq %rcx, %r9
;   movl $0x40, %ecx
;   movq %r9, %r8
;   subq %r8, %rcx
;   movq %rdi, %r10
;   shrq %cl, %r10
;   xorq %rax, %rax
;   testq $0x7f, %r8
;   cmoveq %rax, %r10
;   orq %r11, %r10
;   testq $0x40, %r8
;   cmoveq %rdx, %rax
;   cmoveq %r10, %rdx
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i128_i64(i128, i64) -> i128 {
block0(v0: i128, v1: i64):
    v2 = ishl.i128 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdx, %rcx
;   movq    %rdi, %rdx
;   shlq    %cl, %rdx, %rdx
;   movq    %rsi, %r10
;   shlq    %cl, %r10, %r10
;   movq    %rcx, %r9
;   movl    $64, %ecx
;   movq    %r9, %rsi
;   subq    %rcx, %rsi, %rcx
;   movq    %rdi, %r9
;   shrq    %cl, %r9, %r9
;   xorq    %rax, %rax, %rax
;   testq   $127, %rsi
;   cmovzq  %rax, %r9, %r9
;   orq     %r9, %r10, %r9
;   testq   $64, %rsi
;   cmovzq  %rdx, %rax, %rax
;   cmovzq  %r9, %rdx, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rdx, %rcx
;   movq %rdi, %rdx
;   shlq %cl, %rdx
;   movq %rsi, %r10
;   shlq %cl, %r10
;   movq %rcx, %r9
;   movl $0x40, %ecx
;   movq %r9, %rsi
;   subq %rsi, %rcx
;   movq %rdi, %r9
;   shrq %cl, %r9
;   xorq %rax, %rax
;   testq $0x7f, %rsi
;   cmoveq %rax, %r9
;   orq %r10, %r9
;   testq $0x40, %rsi
;   cmoveq %rdx, %rax
;   cmoveq %r9, %rdx
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i128_i32(i128, i32) -> i128 {
block0(v0: i128, v1: i32):
    v2 = ishl.i128 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdx, %rcx
;   movq    %rdi, %rdx
;   shlq    %cl, %rdx, %rdx
;   movq    %rsi, %r10
;   shlq    %cl, %r10, %r10
;   movq    %rcx, %r9
;   movl    $64, %ecx
;   movq    %r9, %rsi
;   subq    %rcx, %rsi, %rcx
;   movq    %rdi, %r9
;   shrq    %cl, %r9, %r9
;   xorq    %rax, %rax, %rax
;   testq   $127, %rsi
;   cmovzq  %rax, %r9, %r9
;   orq     %r9, %r10, %r9
;   testq   $64, %rsi
;   cmovzq  %rdx, %rax, %rax
;   cmovzq  %r9, %rdx, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rdx, %rcx
;   movq %rdi, %rdx
;   shlq %cl, %rdx
;   movq %rsi, %r10
;   shlq %cl, %r10
;   movq %rcx, %r9
;   movl $0x40, %ecx
;   movq %r9, %rsi
;   subq %rsi, %rcx
;   movq %rdi, %r9
;   shrq %cl, %r9
;   xorq %rax, %rax
;   testq $0x7f, %rsi
;   cmoveq %rax, %r9
;   orq %r10, %r9
;   testq $0x40, %rsi
;   cmoveq %rdx, %rax
;   cmoveq %r9, %rdx
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i128_i16(i128, i16) -> i128 {
block0(v0: i128, v1: i16):
    v2 = ishl.i128 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdx, %rcx
;   movq    %rdi, %rdx
;   shlq    %cl, %rdx, %rdx
;   movq    %rsi, %r10
;   shlq    %cl, %r10, %r10
;   movq    %rcx, %r9
;   movl    $64, %ecx
;   movq    %r9, %rsi
;   subq    %rcx, %rsi, %rcx
;   movq    %rdi, %r9
;   shrq    %cl, %r9, %r9
;   xorq    %rax, %rax, %rax
;   testq   $127, %rsi
;   cmovzq  %rax, %r9, %r9
;   orq     %r9, %r10, %r9
;   testq   $64, %rsi
;   cmovzq  %rdx, %rax, %rax
;   cmovzq  %r9, %rdx, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rdx, %rcx
;   movq %rdi, %rdx
;   shlq %cl, %rdx
;   movq %rsi, %r10
;   shlq %cl, %r10
;   movq %rcx, %r9
;   movl $0x40, %ecx
;   movq %r9, %rsi
;   subq %rsi, %rcx
;   movq %rdi, %r9
;   shrq %cl, %r9
;   xorq %rax, %rax
;   testq $0x7f, %rsi
;   cmoveq %rax, %r9
;   orq %r10, %r9
;   testq $0x40, %rsi
;   cmoveq %rdx, %rax
;   cmoveq %r9, %rdx
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i128_i8(i128, i8) -> i128 {
block0(v0: i128, v1: i8):
    v2 = ishl.i128 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdx, %rcx
;   movq    %rdi, %rdx
;   shlq    %cl, %rdx, %rdx
;   movq    %rsi, %r10
;   shlq    %cl, %r10, %r10
;   movq    %rcx, %r9
;   movl    $64, %ecx
;   movq    %r9, %rsi
;   subq    %rcx, %rsi, %rcx
;   movq    %rdi, %r9
;   shrq    %cl, %r9, %r9
;   xorq    %rax, %rax, %rax
;   testq   $127, %rsi
;   cmovzq  %rax, %r9, %r9
;   orq     %r9, %r10, %r9
;   testq   $64, %rsi
;   cmovzq  %rdx, %rax, %rax
;   cmovzq  %r9, %rdx, %rdx
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rdx, %rcx
;   movq %rdi, %rdx
;   shlq %cl, %rdx
;   movq %rsi, %r10
;   shlq %cl, %r10
;   movq %rcx, %r9
;   movl $0x40, %ecx
;   movq %r9, %rsi
;   subq %rsi, %rcx
;   movq %rdi, %r9
;   shrq %cl, %r9
;   xorq %rax, %rax
;   testq $0x7f, %rsi
;   cmoveq %rax, %r9
;   orq %r10, %r9
;   testq $0x40, %rsi
;   cmoveq %rdx, %rax
;   cmoveq %r9, %rdx
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i64_i128(i64, i128) -> i64 {
block0(v0: i64, v1: i128):
    v2 = ishl.i64 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   movq    %rdi, %rax
;   shlq    %cl, %rax, %rax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   movq %rdi, %rax
;   shlq %cl, %rax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i32_i128(i32, i128) -> i32 {
block0(v0: i32, v1: i128):
    v2 = ishl.i32 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   movq    %rdi, %rax
;   shll    %cl, %eax, %eax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   movq %rdi, %rax
;   shll %cl, %eax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i16_i128(i16, i128) -> i16 {
block0(v0: i16, v1: i128):
    v2 = ishl.i16 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   andq    %rcx, $15, %rcx
;   movq    %rdi, %rax
;   shlw    %cl, %ax, %ax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   andq $0xf, %rcx
;   movq %rdi, %rax
;   shlw %cl, %ax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i8_i128(i8, i128) -> i8 {
block0(v0: i8, v1: i128):
    v2 = ishl.i8 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   andq    %rcx, $7, %rcx
;   movq    %rdi, %rax
;   shlb    %cl, %al, %al
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   andq $7, %rcx
;   movq %rdi, %rax
;   shlb %cl, %al
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i64_i64(i64, i64) -> i64 {
block0(v0: i64, v1: i64):
    v2 = ishl.i64 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   movq    %rdi, %rax
;   shlq    %cl, %rax, %rax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   movq %rdi, %rax
;   shlq %cl, %rax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i64_i32(i64, i32) -> i64 {
block0(v0: i64, v1: i32):
    v2 = ishl.i64 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   movq    %rdi, %rax
;   shlq    %cl, %rax, %rax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   movq %rdi, %rax
;   shlq %cl, %rax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i64_i16(i64, i16) -> i64 {
block0(v0: i64, v1: i16):
    v2 = ishl.i64 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   movq    %rdi, %rax
;   shlq    %cl, %rax, %rax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   movq %rdi, %rax
;   shlq %cl, %rax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i64_i8(i64, i8) -> i64 {
block0(v0: i64, v1: i8):
    v2 = ishl.i64 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   movq    %rdi, %rax
;   shlq    %cl, %rax, %rax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   movq %rdi, %rax
;   shlq %cl, %rax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i32_i64(i32, i64) -> i32 {
block0(v0: i32, v1: i64):
    v2 = ishl.i32 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   movq    %rdi, %rax
;   shll    %cl, %eax, %eax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   movq %rdi, %rax
;   shll %cl, %eax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i32_i32(i32, i32) -> i32 {
block0(v0: i32, v1: i32):
    v2 = ishl.i32 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   movq    %rdi, %rax
;   shll    %cl, %eax, %eax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   movq %rdi, %rax
;   shll %cl, %eax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i32_i16(i32, i16) -> i32 {
block0(v0: i32, v1: i16):
    v2 = ishl.i32 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   movq    %rdi, %rax
;   shll    %cl, %eax, %eax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   movq %rdi, %rax
;   shll %cl, %eax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i32_i8(i32, i8) -> i32 {
block0(v0: i32, v1: i8):
    v2 = ishl.i32 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   movq    %rdi, %rax
;   shll    %cl, %eax, %eax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   movq %rdi, %rax
;   shll %cl, %eax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i16_i64(i16, i64) -> i16 {
block0(v0: i16, v1: i64):
    v2 = ishl.i16 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   andq    %rcx, $15, %rcx
;   movq    %rdi, %rax
;   shlw    %cl, %ax, %ax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   andq $0xf, %rcx
;   movq %rdi, %rax
;   shlw %cl, %ax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i16_i32(i16, i32) -> i16 {
block0(v0: i16, v1: i32):
    v2 = ishl.i16 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   andq    %rcx, $15, %rcx
;   movq    %rdi, %rax
;   shlw    %cl, %ax, %ax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   andq $0xf, %rcx
;   movq %rdi, %rax
;   shlw %cl, %ax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i16_i16(i16, i16) -> i16 {
block0(v0: i16, v1: i16):
    v2 = ishl.i16 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   andq    %rcx, $15, %rcx
;   movq    %rdi, %rax
;   shlw    %cl, %ax, %ax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   andq $0xf, %rcx
;   movq %rdi, %rax
;   shlw %cl, %ax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i16_i8(i16, i8) -> i16 {
block0(v0: i16, v1: i8):
    v2 = ishl.i16 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   andq    %rcx, $15, %rcx
;   movq    %rdi, %rax
;   shlw    %cl, %ax, %ax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   andq $0xf, %rcx
;   movq %rdi, %rax
;   shlw %cl, %ax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i8_i64(i8, i64) -> i8 {
block0(v0: i8, v1: i64):
    v2 = ishl.i8 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   andq    %rcx, $7, %rcx
;   movq    %rdi, %rax
;   shlb    %cl, %al, %al
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   andq $7, %rcx
;   movq %rdi, %rax
;   shlb %cl, %al
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i8_i32(i8, i32) -> i8 {
block0(v0: i8, v1: i32):
    v2 = ishl.i8 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   andq    %rcx, $7, %rcx
;   movq    %rdi, %rax
;   shlb    %cl, %al, %al
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   andq $7, %rcx
;   movq %rdi, %rax
;   shlb %cl, %al
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i8_i16(i8, i16) -> i8 {
block0(v0: i8, v1: i16):
    v2 = ishl.i8 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   andq    %rcx, $7, %rcx
;   movq    %rdi, %rax
;   shlb    %cl, %al, %al
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   andq $7, %rcx
;   movq %rdi, %rax
;   shlb %cl, %al
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i8_i8(i8, i8) -> i8 {
block0(v0: i8, v1: i8):
    v2 = ishl.i8 v0, v1
    return v2
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rsi, %rcx
;   andq    %rcx, $7, %rcx
;   movq    %rdi, %rax
;   shlb    %cl, %al, %al
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rsi, %rcx
;   andq $7, %rcx
;   movq %rdi, %rax
;   shlb %cl, %al
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i64_const(i64) -> i64 {
block0(v0: i64):
    v1 = ishl_imm.i64 v0, 65
    return v1
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdi, %rax
;   shlq    $1, %rax, %rax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rdi, %rax
;   shlq $1, %rax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i32_const(i32) -> i32 {
block0(v0: i32):
    v1 = ishl_imm.i32 v0, 33
    return v1
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdi, %rax
;   shll    $1, %eax, %eax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rdi, %rax
;   shll $1, %eax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i16_const(i16) -> i16 {
block0(v0: i16):
    v1 = ishl_imm.i16 v0, 17
    return v1
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdi, %rax
;   shlw    $1, %ax, %ax
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rdi, %rax
;   shlw $1, %ax
;   movq %rbp, %rsp
;   popq %rbp
;   retq

function %ishl_i8_const(i8) -> i8 {
block0(v0: i8):
    v1 = ishl_imm.i8 v0, 9
    return v1
}

; VCode:
;   pushq   %rbp
;   movq    %rsp, %rbp
; block0:
;   movq    %rdi, %rax
;   shlb    $1, %al, %al
;   movq    %rbp, %rsp
;   popq    %rbp
;   ret
; 
; Disassembled:
; block0: ; offset 0x0
;   pushq %rbp
;   movq %rsp, %rbp
; block1: ; offset 0x4
;   movq %rdi, %rax
;   shlb $1, %al
;   movq %rbp, %rsp
;   popq %rbp
;   retq