averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
revert-82265-revert-80405-t/main/update_swiftpm_presets
swift-mirror/test/IRGen/integer_literal.sil
Arnold Schwaighofer 3b5ebaa46c Fix some tests in IRGen folder
2023-06-21 10:10:32 -07:00

391 lines
19 KiB
Plaintext
Raw Permalink Blame History

// RUN: %swift -target armv7-apple-ios10 -disable-legacy-type-info -module-name integer_literal %s -gnone -emit-ir | %FileCheck %s
// REQUIRES: CODEGENERATOR=ARM
// We use a 32-bit target because it makes the literals smaller.
sil_stage canonical
import Builtin
/***************************************************************************/
/* constant emission tests */
/***************************************************************************/
// CHECK: @intliteral.-2147483648 =
// CHECK-SAME: private unnamed_addr constant [1 x i32] [i32 -2147483648]
// CHECK: @intliteral.2147483648 =
// CHECK-SAME: private unnamed_addr constant [2 x i32] [i32 -2147483648, i32 0]
// CHECK: @intliteral.0 =
// CHECK-SAME: private unnamed_addr constant [1 x i32] zeroinitializer
// CHECK: @intliteral.-1 =
// CHECK-SAME: private unnamed_addr constant [1 x i32] [i32 -1]
// CHECK: @intliteral.60 =
// CHECK-SAME: private unnamed_addr constant [1 x i32] [i32 60]
sil @use_literal : $@convention(thin) (Builtin.IntLiteral) -> ()
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @constant_corner_cases
sil @constant_corner_cases : $() -> () {
entry:
%fn = function_ref @use_literal : $@convention(thin) (Builtin.IntLiteral) -> ()
// CHECK: call swiftcc void @use_literal(ptr @intliteral.-2147483648, i32 8193)
// 8193 == 32 << 8 + 1 (negative)
%0 = integer_literal $Builtin.IntLiteral, -0x8000_0000
apply %fn(%0) : $@convention(thin) (Builtin.IntLiteral) -> ()
// CHECK-NEXT: call swiftcc void @use_literal(ptr @intliteral.2147483648, i32 8448)
// 8448 == 33 << 8
%1 = integer_literal $Builtin.IntLiteral, 0x8000_0000
apply %fn(%1) : $@convention(thin) (Builtin.IntLiteral) -> ()
// CHECK-NEXT: call swiftcc void @use_literal(ptr @intliteral.0, i32 256)
// 256 == 1 << 8
%3 = integer_literal $Builtin.IntLiteral, 0
apply %fn(%3) : $@convention(thin) (Builtin.IntLiteral) -> ()
// CHECK-NEXT: call swiftcc void @use_literal(ptr @intliteral.-1, i32 257)
// 257 == 1 << 8 + 1 (negative)
%4 = integer_literal $Builtin.IntLiteral, -1
apply %fn(%4) : $@convention(thin) (Builtin.IntLiteral) -> ()
// CHECK-NEXT: ret void
%v = tuple ()
return %v : $()
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @redundant_literals
sil @redundant_literals : $() -> () {
entry:
%fn = function_ref @use_literal : $@convention(thin) (Builtin.IntLiteral) -> ()
// CHECK: call swiftcc void @use_literal(ptr @intliteral.60, i32 1792)
// 1792 == 7 << 8
%0 = integer_literal $Builtin.IntLiteral, 60
apply %fn(%0) : $@convention(thin) (Builtin.IntLiteral) -> ()
// CHECK-NEXT: call swiftcc void @use_literal(ptr @intliteral.60, i32 1792)
// 1792 == 7 << 8
%1 = integer_literal $Builtin.IntLiteral, 60
apply %fn(%1) : $@convention(thin) (Builtin.IntLiteral) -> ()
// CHECK-NEXT: ret void
%v = tuple ()
return %v : $()
}
/***************************************************************************/
/* s_to_s_checked_trunc tests */
/***************************************************************************/
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc {{.*}} @trunc_s16
sil @trunc_s16 : $(Builtin.IntLiteral) -> (Builtin.Int16, Builtin.Int1) {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[WIDTH:%.*]] = lshr i32 %1, 8
// CHECK-NEXT: [[OVERFLOW:%.*]] = icmp ugt i32 [[WIDTH]], 16
// CHECK-NEXT: br i1 [[OVERFLOW]], label %[[INVALID:[a-z.]+]], label %[[VALID:[a-z.]+]]
// CHECK: [[INVALID]]:
// CHECK-NEXT: br label %[[DONE:[a-z.]+]]
// CHECK: [[VALID]]:
// CHECK-NEXT: [[CHUNK0:%.*]] = load i32, ptr %0, align 4
// CHECK-NEXT: [[CHUNK0_TRUNC:%.*]] = trunc i32 [[CHUNK0]] to i16
// CHECK-NEXT: br label %[[DONE]]
// CHECK: [[DONE]]:
// CHECK-NEXT: [[RESULT:%.*]] = phi i16 [ 0, %[[INVALID]] ], [ [[CHUNK0_TRUNC]], %[[VALID]] ]
// CHECK-NEXT: [[OVERFLOW:%.*]] = phi i1 [ true, %[[INVALID]] ], [ false, %[[VALID]] ]
%tuple = builtin "s_to_s_checked_trunc_IntLiteral_Int16"(%0 : $Builtin.IntLiteral) : $(Builtin.Int16, Builtin.Int1)
return %tuple : $(Builtin.Int16, Builtin.Int1)
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i32, i1 } @trunc_s32
sil @trunc_s32 : $(Builtin.IntLiteral) -> (Builtin.Int32, Builtin.Int1) {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[WIDTH:%.*]] = lshr i32 %1, 8
// CHECK-NEXT: [[OVERFLOW:%.*]] = icmp ugt i32 [[WIDTH]], 32
// CHECK-NEXT: br i1 [[OVERFLOW]], label %[[INVALID:[a-z.]+]], label %[[VALID:[a-z.]+]]
// CHECK: [[INVALID]]:
// CHECK-NEXT: br label %[[DONE:[a-z.]+]]
// CHECK: [[VALID]]:
// CHECK-NEXT: [[CHUNK0:%.*]] = load i32, ptr %0, align 4
// CHECK-NEXT: br label %[[DONE]]
// CHECK: [[DONE]]:
// CHECK-NEXT: [[RESULT:%.*]] = phi i32 [ 0, %[[INVALID]] ], [ [[CHUNK0]], %[[VALID]] ]
// CHECK-NEXT: [[OVERFLOW:%.*]] = phi i1 [ true, %[[INVALID]] ], [ false, %[[VALID]] ]
%tuple = builtin "s_to_s_checked_trunc_IntLiteral_Int32"(%0 : $Builtin.IntLiteral) : $(Builtin.Int32, Builtin.Int1)
return %tuple : $(Builtin.Int32, Builtin.Int1)
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc {{.*}} @trunc_s48
sil @trunc_s48 : $(Builtin.IntLiteral) -> (Builtin.Int48, Builtin.Int1) {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[WIDTH:%.*]] = lshr i32 %1, 8
// CHECK-NEXT: [[OVERFLOW:%.*]] = icmp ugt i32 [[WIDTH]], 48
// CHECK-NEXT: br i1 [[OVERFLOW]], label %[[INVALID:[a-z.]+]], label %[[VALID:[a-z.]+]]
// CHECK: [[INVALID]]:
// CHECK-NEXT: br label %[[DONE:[a-z.]+]]
// CHECK: [[VALID]]:
// CHECK-NEXT: [[CHUNK0:%.*]] = load i32, ptr %0, align 4
// CHECK-NEXT: [[FINISHED0:%.*]] = icmp ule i32 [[WIDTH]], 32
// CHECK-NEXT: br i1 [[FINISHED0]], label %[[FINISH0:[a-z.]+]], label %[[NEXT0:[a-z.]+]]
// CHECK: [[FINISH0]]:
// CHECK-NEXT: [[RESULT0:%.*]] = sext i32 [[CHUNK0]] to i48
// CHECK-NEXT: br label %[[DONE]]
// CHECK: [[NEXT0]]:
// CHECK-NEXT: [[CHUNKADDR1:%.*]] = getelementptr inbounds i32, ptr %0, i32 1
// CHECK-NEXT: [[CHUNK1:%.*]] = load i32, ptr [[CHUNKADDR1]], align 4
// CHECK-NEXT: [[EXTEND1:%.*]] = zext i32 [[CHUNK0]] to i48
// CHECK-NEXT: [[CHUNK1EXT:%.*]] = zext i32 [[CHUNK1]] to i48
// CHECK-NEXT: [[CHUNK1SHIFT:%.*]] = shl i48 [[CHUNK1EXT]], 32
// CHECK-NEXT: [[RESULT1:%.*]] = add i48 [[EXTEND1]], [[CHUNK1SHIFT]]
// CHECK-NEXT: br label %[[DONE]]
// CHECK: [[DONE]]:
// CHECK-NEXT: [[RESULT:%.*]] = phi i48 [ 0, %[[INVALID]] ], [ [[RESULT0]], %[[FINISH0]] ], [ [[RESULT1]], %[[NEXT0]] ]
// CHECK-NEXT: [[OVERFLOW:%.*]] = phi i1 [ true, %[[INVALID]] ], [ false, %[[FINISH0]] ], [ false, %[[NEXT0]] ]
%tuple = builtin "s_to_s_checked_trunc_IntLiteral_Int48"(%0 : $Builtin.IntLiteral) : $(Builtin.Int48, Builtin.Int1)
return %tuple : $(Builtin.Int48, Builtin.Int1)
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i1 } @trunc_s64
sil @trunc_s64 : $(Builtin.IntLiteral) -> (Builtin.Int64, Builtin.Int1) {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[WIDTH:%.*]] = lshr i32 %1, 8
// CHECK-NEXT: [[OVERFLOW:%.*]] = icmp ugt i32 [[WIDTH]], 64
// CHECK-NEXT: br i1 [[OVERFLOW]], label %[[INVALID:[a-z.]+]], label %[[VALID:[a-z.]+]]
// CHECK: [[INVALID]]:
// CHECK-NEXT: br label %[[DONE:[a-z.]+]]
// CHECK: [[VALID]]:
// CHECK-NEXT: [[CHUNK0:%.*]] = load i32, ptr %0, align 4
// CHECK-NEXT: [[FINISHED0:%.*]] = icmp ule i32 [[WIDTH]], 32
// CHECK-NEXT: br i1 [[FINISHED0]], label %[[FINISH0:[a-z.]+]], label %[[NEXT0:[a-z.]+]]
// CHECK: [[FINISH0]]:
// CHECK-NEXT: [[RESULT0:%.*]] = sext i32 [[CHUNK0]] to i64
// CHECK-NEXT: br label %[[DONE]]
// CHECK: [[NEXT0]]:
// CHECK-NEXT: [[CHUNKADDR1:%.*]] = getelementptr inbounds i32, ptr %0, i32 1
// CHECK-NEXT: [[CHUNK1:%.*]] = load i32, ptr [[CHUNKADDR1]], align 4
// CHECK-NEXT: [[EXTEND1:%.*]] = zext i32 [[CHUNK0]] to i64
// CHECK-NEXT: [[CHUNK1EXT:%.*]] = zext i32 [[CHUNK1]] to i64
// CHECK-NEXT: [[CHUNK1SHIFT:%.*]] = shl i64 [[CHUNK1EXT]], 32
// CHECK-NEXT: [[RESULT1:%.*]] = add i64 [[EXTEND1]], [[CHUNK1SHIFT]]
// CHECK-NEXT: br label %[[DONE]]
// CHECK: [[DONE]]:
// CHECK-NEXT: [[RESULT:%.*]] = phi i64 [ 0, %[[INVALID]] ], [ [[RESULT0]], %[[FINISH0]] ], [ [[RESULT1]], %[[NEXT0]] ]
// CHECK-NEXT: [[OVERFLOW:%.*]] = phi i1 [ true, %[[INVALID]] ], [ false, %[[FINISH0]] ], [ false, %[[NEXT0]] ]
%tuple = builtin "s_to_s_checked_trunc_IntLiteral_Int64"(%0 : $Builtin.IntLiteral) : $(Builtin.Int64, Builtin.Int1)
return %tuple : $(Builtin.Int64, Builtin.Int1)
}
/***************************************************************************/
/* s_to_u_checked_trunc tests */
/***************************************************************************/
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc {{.*}} @trunc_u16
sil @trunc_u16 : $(Builtin.IntLiteral) -> (Builtin.Int16, Builtin.Int1) {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[WIDTH:%.*]] = lshr i32 %1, 8
// CHECK-NEXT: [[NEGATIVE:%.*]] = trunc i32 %1 to i1
// CHECK-NEXT: [[LARGE:%.*]] = icmp ugt i32 [[WIDTH]], 17
// CHECK-NEXT: [[OVERFLOW:%.*]] = or i1 [[NEGATIVE]], [[LARGE]]
// CHECK-NEXT: br i1 [[OVERFLOW]], label %[[INVALID:[a-z.]+]], label %[[VALID:[a-z.]+]]
// CHECK: [[INVALID]]:
// CHECK-NEXT: br label %[[DONE:[a-z.]+]]
// CHECK: [[VALID]]:
// CHECK-NEXT: [[CHUNK0:%.*]] = load i32, ptr %0, align 4
// CHECK-NEXT: [[CHUNK0_TRUNC:%.*]] = trunc i32 [[CHUNK0]] to i16
// CHECK-NEXT: br label %[[DONE]]
// CHECK: [[DONE]]:
// CHECK-NEXT: [[RESULT:%.*]] = phi i16 [ 0, %[[INVALID]] ], [ [[CHUNK0_TRUNC]], %[[VALID]] ]
// CHECK-NEXT: [[OVERFLOW:%.*]] = phi i1 [ true, %[[INVALID]] ], [ false, %[[VALID]] ]
%tuple = builtin "s_to_u_checked_trunc_IntLiteral_Int16"(%0 : $Builtin.IntLiteral) : $(Builtin.Int16, Builtin.Int1)
return %tuple : $(Builtin.Int16, Builtin.Int1)
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i32, i1 } @trunc_u32
sil @trunc_u32 : $(Builtin.IntLiteral) -> (Builtin.Int32, Builtin.Int1) {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[WIDTH:%.*]] = lshr i32 %1, 8
// CHECK-NEXT: [[NEGATIVE:%.*]] = trunc i32 %1 to i1
// CHECK-NEXT: [[LARGE:%.*]] = icmp ugt i32 [[WIDTH]], 33
// CHECK-NEXT: [[OVERFLOW:%.*]] = or i1 [[NEGATIVE]], [[LARGE]]
// CHECK-NEXT: br i1 [[OVERFLOW]], label %[[INVALID:[a-z.]+]], label %[[VALID:[a-z.]+]]
// CHECK: [[INVALID]]:
// CHECK-NEXT: br label %[[DONE:[a-z.]+]]
// CHECK: [[VALID]]:
// CHECK-NEXT: [[CHUNK0:%.*]] = load i32, ptr %0, align 4
// CHECK-NEXT: br label %[[DONE]]
// CHECK: [[DONE]]:
// CHECK-NEXT: [[RESULT:%.*]] = phi i32 [ 0, %[[INVALID]] ], [ [[CHUNK0]], %[[VALID]] ]
// CHECK-NEXT: [[OVERFLOW:%.*]] = phi i1 [ true, %[[INVALID]] ], [ false, %[[VALID]] ]
%tuple = builtin "s_to_u_checked_trunc_IntLiteral_Int32"(%0 : $Builtin.IntLiteral) : $(Builtin.Int32, Builtin.Int1)
return %tuple : $(Builtin.Int32, Builtin.Int1)
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc {{.*}} @trunc_u48
sil @trunc_u48 : $(Builtin.IntLiteral) -> (Builtin.Int48, Builtin.Int1) {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[WIDTH:%.*]] = lshr i32 %1, 8
// CHECK-NEXT: [[NEGATIVE:%.*]] = trunc i32 %1 to i1
// CHECK-NEXT: [[LARGE:%.*]] = icmp ugt i32 [[WIDTH]], 49
// CHECK-NEXT: [[OVERFLOW:%.*]] = or i1 [[NEGATIVE]], [[LARGE]]
// CHECK-NEXT: br i1 [[OVERFLOW]], label %[[INVALID:[a-z.]+]], label %[[VALID:[a-z.]+]]
// CHECK: [[INVALID]]:
// CHECK-NEXT: br label %[[DONE:[a-z.]+]]
// CHECK: [[VALID]]:
// CHECK-NEXT: [[CHUNK0:%.*]] = load i32, ptr %0, align 4
// CHECK-NEXT: [[FINISHED0:%.*]] = icmp ule i32 [[WIDTH]], 33
// CHECK-NEXT: br i1 [[FINISHED0]], label %[[FINISH0:[a-z.]+]], label %[[NEXT0:[a-z.]+]]
// CHECK: [[FINISH0]]:
// CHECK-NEXT: [[RESULT0:%.*]] = zext i32 [[CHUNK0]] to i48
// CHECK-NEXT: br label %[[DONE]]
// CHECK: [[NEXT0]]:
// CHECK-NEXT: [[CHUNKADDR1:%.*]] = getelementptr inbounds i32, ptr %0, i32 1
// CHECK-NEXT: [[CHUNK1:%.*]] = load i32, ptr [[CHUNKADDR1]], align 4
// CHECK-NEXT: [[EXTEND1:%.*]] = zext i32 [[CHUNK0]] to i48
// CHECK-NEXT: [[CHUNK1EXT:%.*]] = zext i32 [[CHUNK1]] to i48
// CHECK-NEXT: [[CHUNK1SHIFT:%.*]] = shl i48 [[CHUNK1EXT]], 32
// CHECK-NEXT: [[RESULT1:%.*]] = add i48 [[EXTEND1]], [[CHUNK1SHIFT]]
// CHECK-NEXT: br label %[[DONE]]
// CHECK: [[DONE]]:
// CHECK-NEXT: [[RESULT:%.*]] = phi i48 [ 0, %[[INVALID]] ], [ [[RESULT0]], %[[FINISH0]] ], [ [[RESULT1]], %[[NEXT0]] ]
// CHECK-NEXT: [[OVERFLOW:%.*]] = phi i1 [ true, %[[INVALID]] ], [ false, %[[FINISH0]] ], [ false, %[[NEXT0]] ]
%tuple = builtin "s_to_u_checked_trunc_IntLiteral_Int48"(%0 : $Builtin.IntLiteral) : $(Builtin.Int48, Builtin.Int1)
return %tuple : $(Builtin.Int48, Builtin.Int1)
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i64, i1 } @trunc_u64
sil @trunc_u64 : $(Builtin.IntLiteral) -> (Builtin.Int64, Builtin.Int1) {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[WIDTH:%.*]] = lshr i32 %1, 8
// CHECK-NEXT: [[NEGATIVE:%.*]] = trunc i32 %1 to i1
// CHECK-NEXT: [[LARGE:%.*]] = icmp ugt i32 [[WIDTH]], 65
// CHECK-NEXT: [[OVERFLOW:%.*]] = or i1 [[NEGATIVE]], [[LARGE]]
// CHECK-NEXT: br i1 [[OVERFLOW]], label %[[INVALID:[a-z.]+]], label %[[VALID:[a-z.]+]]
// CHECK: [[INVALID]]:
// CHECK-NEXT: br label %[[DONE:[a-z.]+]]
// CHECK: [[VALID]]:
// CHECK-NEXT: [[CHUNK0:%.*]] = load i32, ptr %0, align 4
// CHECK-NEXT: [[FINISHED0:%.*]] = icmp ule i32 [[WIDTH]], 33
// CHECK-NEXT: br i1 [[FINISHED0]], label %[[FINISH0:[a-z.]+]], label %[[NEXT0:[a-z.]+]]
// CHECK: [[FINISH0]]:
// CHECK-NEXT: [[RESULT0:%.*]] = zext i32 [[CHUNK0]] to i64
// CHECK-NEXT: br label %[[DONE]]
// CHECK: [[NEXT0]]:
// CHECK-NEXT: [[CHUNKADDR1:%.*]] = getelementptr inbounds i32, ptr %0, i32 1
// CHECK-NEXT: [[CHUNK1:%.*]] = load i32, ptr [[CHUNKADDR1]], align 4
// CHECK-NEXT: [[EXTEND1:%.*]] = zext i32 [[CHUNK0]] to i64
// CHECK-NEXT: [[CHUNK1EXT:%.*]] = zext i32 [[CHUNK1]] to i64
// CHECK-NEXT: [[CHUNK1SHIFT:%.*]] = shl i64 [[CHUNK1EXT]], 32
// CHECK-NEXT: [[RESULT1:%.*]] = add i64 [[EXTEND1]], [[CHUNK1SHIFT]]
// CHECK-NEXT: br label %[[DONE]]
// CHECK: [[DONE]]:
// CHECK-NEXT: [[RESULT:%.*]] = phi i64 [ 0, %[[INVALID]] ], [ [[RESULT0]], %[[FINISH0]] ], [ [[RESULT1]], %[[NEXT0]] ]
// CHECK-NEXT: [[OVERFLOW:%.*]] = phi i1 [ true, %[[INVALID]] ], [ false, %[[FINISH0]] ], [ false, %[[NEXT0]] ]
%tuple = builtin "s_to_u_checked_trunc_IntLiteral_Int64"(%0 : $Builtin.IntLiteral) : $(Builtin.Int64, Builtin.Int1)
return %tuple : $(Builtin.Int64, Builtin.Int1)
}
/***************************************************************************/
/* itofp_with_overflow tests */
/***************************************************************************/
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc half @sitofp16
sil @sitofp16 : $(Builtin.IntLiteral) -> Builtin.FPIEEE16 {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[T0:%.*]] = call swiftcc float @swift_intToFloat32(ptr %0, i32 %1)
// CHECK-NEXT: [[T1:%.*]] = fptrunc float [[T0]] to half
// CHECK-NEXT: ret half [[T1]]
%result = builtin "itofp_with_overflow_IntLiteral_FPIEEE16"(%0 : $Builtin.IntLiteral) : $Builtin.FPIEEE16
return %result : $Builtin.FPIEEE16
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc float @sitofp32
sil @sitofp32 : $(Builtin.IntLiteral) -> Builtin.FPIEEE32 {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[T0:%.*]] = call swiftcc float @swift_intToFloat32(ptr %0, i32 %1)
// CHECK-NEXT: ret float [[T0]]
%result = builtin "itofp_with_overflow_IntLiteral_FPIEEE32"(%0 : $Builtin.IntLiteral) : $Builtin.FPIEEE32
return %result : $Builtin.FPIEEE32
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc double @sitofp64
sil @sitofp64 : $(Builtin.IntLiteral) -> Builtin.FPIEEE64 {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[T0:%.*]] = call swiftcc double @swift_intToFloat64(ptr %0, i32 %1)
// CHECK-NEXT: ret double [[T0]]
%result = builtin "itofp_with_overflow_IntLiteral_FPIEEE64"(%0 : $Builtin.IntLiteral) : $Builtin.FPIEEE64
return %result : $Builtin.FPIEEE64
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc x86_fp80 @sitofp80
sil @sitofp80 : $(Builtin.IntLiteral) -> Builtin.FPIEEE80 {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[T0:%.*]] = call swiftcc double @swift_intToFloat64(ptr %0, i32 %1)
// CHECK-NEXT: [[T1:%.*]] = fpext double [[T0]] to x86_fp80
// CHECK-NEXT: ret x86_fp80 [[T1]]
%result = builtin "itofp_with_overflow_IntLiteral_FPIEEE80"(%0 : $Builtin.IntLiteral) : $Builtin.FPIEEE80
return %result : $Builtin.FPIEEE80
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc fp128 @sitofp128
sil @sitofp128 : $(Builtin.IntLiteral) -> Builtin.FPIEEE128 {
entry(%0 : $Builtin.IntLiteral):
// CHECK: [[T0:%.*]] = call swiftcc double @swift_intToFloat64(ptr %0, i32 %1)
// CHECK-NEXT: [[T1:%.*]] = fpext double [[T0]] to fp128
// CHECK-NEXT: ret fp128 [[T1]]
%result = builtin "itofp_with_overflow_IntLiteral_FPIEEE128"(%0 : $Builtin.IntLiteral) : $Builtin.FPIEEE128
return %result : $Builtin.FPIEEE128
}
/***************************************************************************/
/* bitWidth, isNegative, wordAtIndex */
/***************************************************************************/
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @test_bitWidth(ptr %0, i32 %1)
sil @test_bitWidth : $(Builtin.IntLiteral) -> Builtin.Word {
entry(%value : $Builtin.IntLiteral):
// CHECK: %2 = lshr i32 %1, 8
// CHECK-NEXT: ret i32 %2
%result = builtin "bitWidth_IntLiteral"(%value : $Builtin.IntLiteral) : $Builtin.Word
return %result : $Builtin.Word
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i1 @test_isNegative(ptr %0, i32 %1)
sil @test_isNegative : $(Builtin.IntLiteral) -> Builtin.Int1 {
entry(%value : $Builtin.IntLiteral):
// CHECK: %2 = trunc i32 %1 to i1
// CHECK-NEXT: ret i1 %2
%result = builtin "isNegative_IntLiteral"(%value : $Builtin.IntLiteral) : $Builtin.Int1
return %result : $Builtin.Int1
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @test_wordAtIndex(ptr %0, i32 %1, i32 %2)
sil @test_wordAtIndex : $(Builtin.IntLiteral, Builtin.Word) -> Builtin.Word {
entry(%value : $Builtin.IntLiteral, %index : $Builtin.Word):
// CHECK: %3 = getelementptr inbounds i32, ptr %0, i32 %2
// CHECK-NEXT: %4 = load i32, ptr %3, align 4
// CHECK-NEXT: ret i32 %4
%result = builtin "wordAtIndex_IntLiteral"(%value : $Builtin.IntLiteral, %index : $Builtin.Word) : $Builtin.Word
return %result : $Builtin.Word
}
Reference in New Issue View Git Blame Copy Permalink