From c5761d2d16d23c25209db460103165eea7bb0250 Mon Sep 17 00:00:00 2001 From: Jon Ross-Perkins Date: Mon, 16 Mar 2026 13:00:51 -0700 Subject: [PATCH] Improve parsing large integers (#6908) Though I started this thinking about performance of parse of large decimal integers, I extended it to generally improve performance of integer values (TBH I hadn't expected such a difference for binary/hex, but I'll take it). Note I think tests change because I'm making subtle changes to bit widths. The changes themselves appear harmless to me, but happy to make changes if it'd help. Bumping up the number of digits by 10x because it's not really a performance issue anymore (eh, maybe somebody will want to specify a 256-byte value in binary). But, at a certain point it still seems like a mistake if somebody has that many digits in a row. Fixes #980 Highlighting benchmark differences: ```diff - BM_ComputeValue_IntDecimalN/1 37.1 ns 37.1 ns 18887116 + BM_ComputeValue_IntDecimalN/1 21.9 ns 21.9 ns 31902433 - BM_ComputeValue_IntDecimalN/10000 1251228680 ns 1250457559 ns 1 + BM_ComputeValue_IntDecimalN/10000 458818 ns 458626 ns 1523 - BM_ComputeValue_IntBinaryN/1 29.0 ns 29.0 ns 24058533 + BM_ComputeValue_IntBinaryN/1 22.2 ns 22.1 ns 31566949 - BM_ComputeValue_IntBinaryN/10000 1390557 ns 1389782 ns 506 + BM_ComputeValue_IntBinaryN/10000 16402 ns 16396 ns 42744 - BM_ComputeValue_IntHexN/1 34.0 ns 34.0 ns 20562432 + BM_ComputeValue_IntHexN/1 22.4 ns 22.4 ns 31238055 - BM_ComputeValue_IntHexN/10000 5387942 ns 5385262 ns 130 + BM_ComputeValue_IntHexN/10000 39249 ns 39233 ns 17859 ``` Benchmark before: ``` ---------------------------------------------------------------------------- Benchmark Time CPU Iterations ---------------------------------------------------------------------------- BM_Lex_Float 10.6 ns 10.6 ns 66138191 BM_Lex_Int 15.5 ns 15.4 ns 45149703 BM_Lex_IntDecimalN/1 3.11 ns 3.11 ns 225524908 BM_Lex_IntDecimalN/10 11.8 ns 11.8 ns 56719805 BM_Lex_IntDecimalN/100 102 ns 102 ns 6867468 BM_Lex_IntDecimalN/1000 943 ns 942 ns 745313 BM_Lex_IntDecimalN/10000 9465 ns 9461 ns 73970 BM_ComputeValue_Float 61.6 ns 61.6 ns 11377463 BM_ComputeValue_Int 106 ns 106 ns 6587381 BM_ComputeValue_IntDecimalN/1 37.1 ns 37.1 ns 18887116 BM_ComputeValue_IntDecimalN/10 87.7 ns 87.7 ns 7960837 BM_ComputeValue_IntDecimalN/100 7963 ns 7956 ns 88858 BM_ComputeValue_IntDecimalN/1000 1212577 ns 1211906 ns 578 BM_ComputeValue_IntDecimalN/10000 1251228680 ns 1250457559 ns 1 BM_ComputeValue_IntBinaryN/1 29.0 ns 29.0 ns 24058533 BM_ComputeValue_IntBinaryN/10 69.4 ns 69.4 ns 10108642 BM_ComputeValue_IntBinaryN/100 963 ns 962 ns 726982 BM_ComputeValue_IntBinaryN/1000 21562 ns 21551 ns 32506 BM_ComputeValue_IntBinaryN/10000 1390557 ns 1389782 ns 506 BM_ComputeValue_IntHexN/1 34.0 ns 34.0 ns 20562432 BM_ComputeValue_IntHexN/10 70.4 ns 70.4 ns 9953165 BM_ComputeValue_IntHexN/100 1474 ns 1473 ns 472776 BM_ComputeValue_IntHexN/1000 61818 ns 61762 ns 11363 BM_ComputeValue_IntHexN/10000 5387942 ns 5385262 ns 130 ``` Benchmark after: ``` ---------------------------------------------------------------------------- Benchmark Time CPU Iterations ---------------------------------------------------------------------------- BM_Lex_Float 10.9 ns 10.9 ns 63993114 BM_Lex_Int 15.1 ns 15.1 ns 46869766 BM_Lex_IntDecimalN/1 3.16 ns 3.16 ns 220923300 BM_Lex_IntDecimalN/10 12.2 ns 12.2 ns 57731654 BM_Lex_IntDecimalN/100 102 ns 102 ns 6875516 BM_Lex_IntDecimalN/1000 942 ns 942 ns 742359 BM_Lex_IntDecimalN/10000 9353 ns 9350 ns 75096 BM_ComputeValue_Float 44.9 ns 44.9 ns 15619691 BM_ComputeValue_Int 48.9 ns 48.9 ns 14361507 BM_ComputeValue_IntDecimalN/1 21.9 ns 21.9 ns 31902433 BM_ComputeValue_IntDecimalN/10 30.3 ns 30.3 ns 23134117 BM_ComputeValue_IntDecimalN/100 224 ns 223 ns 3092567 BM_ComputeValue_IntDecimalN/1000 5834 ns 5830 ns 117469 BM_ComputeValue_IntDecimalN/10000 458818 ns 458626 ns 1523 BM_ComputeValue_IntBinaryN/1 22.2 ns 22.1 ns 31566949 BM_ComputeValue_IntBinaryN/10 32.9 ns 32.9 ns 21306927 BM_ComputeValue_IntBinaryN/100 198 ns 198 ns 3545277 BM_ComputeValue_IntBinaryN/1000 1671 ns 1669 ns 419656 BM_ComputeValue_IntBinaryN/10000 16402 ns 16396 ns 42744 BM_ComputeValue_IntHexN/1 22.4 ns 22.4 ns 31238055 BM_ComputeValue_IntHexN/10 47.8 ns 47.7 ns 14694407 BM_ComputeValue_IntHexN/100 436 ns 436 ns 1609794 BM_ComputeValue_IntHexN/1000 3966 ns 3962 ns 177109 BM_ComputeValue_IntHexN/10000 39249 ns 39233 ns 17859 ``` Assisted-by: Google Antigravity with Gemini --- toolchain/base/int.h | 5 +- .../builtins/float/convert_checked.carbon | 112 +++++++++--------- .../call/fail_return_type_mismatch.carbon | 8 +- .../testdata/interop/cpp/builtins.carbon | 32 ++--- .../interop/cpp/builtins.llp64.carbon | 46 +++---- .../testdata/interop/cpp/builtins.lp64.carbon | 46 +++---- .../function/arithmetic_types_bridged.carbon | 40 +++---- .../interop/cpp/function/overloads.carbon | 10 +- .../check/testdata/interop/cpp/macros.carbon | 12 +- .../primitives/import_symbolic.carbon | 12 +- .../primitives/numeric_literals.carbon | 24 ++-- .../struct/fail_member_access_type.carbon | 12 +- toolchain/lex/BUILD | 1 + toolchain/lex/helpers.cpp | 10 +- toolchain/lex/numeric_literal.cpp | 103 +++++++++++++++- toolchain/lex/numeric_literal_benchmark.cpp | 58 +++++++++ toolchain/lex/numeric_literal_test.cpp | 2 +- .../lex/testdata/numeric_literals.carbon | 71 +++++------ 18 files changed, 380 insertions(+), 224 deletions(-) diff --git a/toolchain/base/int.h b/toolchain/base/int.h index 7cc07bfd553e..52e3ae264496 100644 --- a/toolchain/base/int.h +++ b/toolchain/base/int.h @@ -232,6 +232,9 @@ inline constexpr int32_t IntId::NoneIndex = None.AsIndex(); // an array of `APInt` values and represented as an index in the ID. class IntStore { public: + // We rely on `APInt` values having a minimum bit width. + static constexpr int MinAPWidth = 64; + // The maximum supported bit width of an integer type. // TODO: Pick a maximum size and document it in the design. For now // we use 2^^23, because that's the largest size that LLVM supports. @@ -370,8 +373,6 @@ class IntStore { using IdBase::IdBase; }; - static constexpr int MinAPWidth = 64; - static auto MakeIndexOrNone(int index) -> IntId { CARBON_DCHECK(index >= 0 && index <= IntId::NoneIndex); return IntId(IntId::ZeroIndexId - index); diff --git a/toolchain/check/testdata/builtins/float/convert_checked.carbon b/toolchain/check/testdata/builtins/float/convert_checked.carbon index 9e7f036a563b..30c5709dee1d 100644 --- a/toolchain/check/testdata/builtins/float/convert_checked.carbon +++ b/toolchain/check/testdata/builtins/float/convert_checked.carbon @@ -203,9 +203,9 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %FloatLiteralToFloat64: %FloatLiteralToFloat64.type = struct_value () [concrete] // CHECK:STDOUT: %float.1f7: Core.FloatLiteral = float_literal_value 0e-1 [concrete] // CHECK:STDOUT: %float.0a8: %f64.d77 = float_value 0 [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %float.d20: %f64.d77 = float_value 1 [concrete] -// CHECK:STDOUT: %float.173: Core.FloatLiteral = float_literal_value 10e307 [concrete] +// CHECK:STDOUT: %float.12a: Core.FloatLiteral = float_literal_value 10e307 [concrete] // CHECK:STDOUT: %float.bde: %f64.d77 = float_value 1.0E+308 [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: @@ -243,10 +243,10 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %float.loc6: Core.FloatLiteral = float_literal_value 0e-1 [concrete = constants.%float.1f7] // CHECK:STDOUT: %FloatLiteralToFloat64.call.loc6: init %f64.d77 = call %FloatLiteralToFloat64.ref.loc6(%float.loc6) [concrete = constants.%float.0a8] // CHECK:STDOUT: %FloatLiteralToFloat64.ref.loc7: %FloatLiteralToFloat64.type = name_ref FloatLiteralToFloat64, imports.%Main.FloatLiteralToFloat64 [concrete = constants.%FloatLiteralToFloat64] -// CHECK:STDOUT: %float.loc7: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float.loc7: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %FloatLiteralToFloat64.call.loc7: init %f64.d77 = call %FloatLiteralToFloat64.ref.loc7(%float.loc7) [concrete = constants.%float.d20] // CHECK:STDOUT: %FloatLiteralToFloat64.ref.loc8: %FloatLiteralToFloat64.type = name_ref FloatLiteralToFloat64, imports.%Main.FloatLiteralToFloat64 [concrete = constants.%FloatLiteralToFloat64] -// CHECK:STDOUT: %float.loc8: Core.FloatLiteral = float_literal_value 10e307 [concrete = constants.%float.173] +// CHECK:STDOUT: %float.loc8: Core.FloatLiteral = float_literal_value 10e307 [concrete = constants.%float.12a] // CHECK:STDOUT: %FloatLiteralToFloat64.call.loc8: init %f64.d77 = call %FloatLiteralToFloat64.ref.loc8(%float.loc8) [concrete = constants.%float.bde] // CHECK:STDOUT: // CHECK:STDOUT: } @@ -261,9 +261,9 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %FloatLiteralToFloat32: %FloatLiteralToFloat32.type = struct_value () [concrete] // CHECK:STDOUT: %float.1f7: Core.FloatLiteral = float_literal_value 0e-1 [concrete] // CHECK:STDOUT: %float.4db: %f32.97e = float_value 0 [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] -// CHECK:STDOUT: %float.516: Core.FloatLiteral = float_literal_value 10e37 [concrete] +// CHECK:STDOUT: %float.8d2: Core.FloatLiteral = float_literal_value 10e37 [concrete] // CHECK:STDOUT: %float.520: %f32.97e = float_value 9.99999968E+37 [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: @@ -301,10 +301,10 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %float.loc6: Core.FloatLiteral = float_literal_value 0e-1 [concrete = constants.%float.1f7] // CHECK:STDOUT: %FloatLiteralToFloat32.call.loc6: init %f32.97e = call %FloatLiteralToFloat32.ref.loc6(%float.loc6) [concrete = constants.%float.4db] // CHECK:STDOUT: %FloatLiteralToFloat32.ref.loc7: %FloatLiteralToFloat32.type = name_ref FloatLiteralToFloat32, imports.%Main.FloatLiteralToFloat32 [concrete = constants.%FloatLiteralToFloat32] -// CHECK:STDOUT: %float.loc7: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float.loc7: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %FloatLiteralToFloat32.call.loc7: init %f32.97e = call %FloatLiteralToFloat32.ref.loc7(%float.loc7) [concrete = constants.%float.e3b] // CHECK:STDOUT: %FloatLiteralToFloat32.ref.loc8: %FloatLiteralToFloat32.type = name_ref FloatLiteralToFloat32, imports.%Main.FloatLiteralToFloat32 [concrete = constants.%FloatLiteralToFloat32] -// CHECK:STDOUT: %float.loc8: Core.FloatLiteral = float_literal_value 10e37 [concrete = constants.%float.516] +// CHECK:STDOUT: %float.loc8: Core.FloatLiteral = float_literal_value 10e37 [concrete = constants.%float.8d2] // CHECK:STDOUT: %FloatLiteralToFloat32.call.loc8: init %f32.97e = call %FloatLiteralToFloat32.ref.loc8(%float.loc8) [concrete = constants.%float.520] // CHECK:STDOUT: // CHECK:STDOUT: } @@ -332,13 +332,13 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_64) [concrete] // CHECK:STDOUT: %bound_method.f2b: = bound_method %float.1f7, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.0a8: %f64.d77 = float_value 0 [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.d80: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] -// CHECK:STDOUT: %bound_method.581: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.1ed: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] +// CHECK:STDOUT: %bound_method.50c: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.d20: %f64.d77 = float_value 1 [concrete] -// CHECK:STDOUT: %float.173: Core.FloatLiteral = float_literal_value 10e307 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.d3f: = bound_method %float.173, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] -// CHECK:STDOUT: %bound_method.0fc: = bound_method %float.173, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %float.12a: Core.FloatLiteral = float_literal_value 10e307 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.dee: = bound_method %float.12a, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] +// CHECK:STDOUT: %bound_method.d56: = bound_method %float.12a, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.bde: %f64.d77 = float_value 1.0E+308 [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: @@ -385,21 +385,21 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %.loc6_31.2: %f64.d77 = converted %float.loc6, %.loc6_31.1 [concrete = constants.%float.0a8] // CHECK:STDOUT: %Float64ToFloat64.call.loc6: init %f64.d77 = call %Float64ToFloat64.ref.loc6(%.loc6_31.2) [concrete = constants.%float.0a8] // CHECK:STDOUT: %Float64ToFloat64.ref.loc7: %Float64ToFloat64.type = name_ref Float64ToFloat64, imports.%Main.Float64ToFloat64 [concrete = constants.%Float64ToFloat64] -// CHECK:STDOUT: %float.loc7: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float.loc7: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %impl.elem0.loc7: %.6c5 = impl_witness_access constants.%ImplicitAs.impl_witness.cb2, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.239] -// CHECK:STDOUT: %bound_method.loc7_31.1: = bound_method %float.loc7, %impl.elem0.loc7 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.d80] +// CHECK:STDOUT: %bound_method.loc7_31.1: = bound_method %float.loc7, %impl.elem0.loc7 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.1ed] // CHECK:STDOUT: %specific_fn.loc7: = specific_function %impl.elem0.loc7, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_64) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc7_31.2: = bound_method %float.loc7, %specific_fn.loc7 [concrete = constants.%bound_method.581] +// CHECK:STDOUT: %bound_method.loc7_31.2: = bound_method %float.loc7, %specific_fn.loc7 [concrete = constants.%bound_method.50c] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call.loc7: init %f64.d77 = call %bound_method.loc7_31.2(%float.loc7) [concrete = constants.%float.d20] // CHECK:STDOUT: %.loc7_31.1: %f64.d77 = value_of_initializer %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call.loc7 [concrete = constants.%float.d20] // CHECK:STDOUT: %.loc7_31.2: %f64.d77 = converted %float.loc7, %.loc7_31.1 [concrete = constants.%float.d20] // CHECK:STDOUT: %Float64ToFloat64.call.loc7: init %f64.d77 = call %Float64ToFloat64.ref.loc7(%.loc7_31.2) [concrete = constants.%float.d20] // CHECK:STDOUT: %Float64ToFloat64.ref.loc8: %Float64ToFloat64.type = name_ref Float64ToFloat64, imports.%Main.Float64ToFloat64 [concrete = constants.%Float64ToFloat64] -// CHECK:STDOUT: %float.loc8: Core.FloatLiteral = float_literal_value 10e307 [concrete = constants.%float.173] +// CHECK:STDOUT: %float.loc8: Core.FloatLiteral = float_literal_value 10e307 [concrete = constants.%float.12a] // CHECK:STDOUT: %impl.elem0.loc8: %.6c5 = impl_witness_access constants.%ImplicitAs.impl_witness.cb2, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.239] -// CHECK:STDOUT: %bound_method.loc8_31.1: = bound_method %float.loc8, %impl.elem0.loc8 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.d3f] +// CHECK:STDOUT: %bound_method.loc8_31.1: = bound_method %float.loc8, %impl.elem0.loc8 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.dee] // CHECK:STDOUT: %specific_fn.loc8: = specific_function %impl.elem0.loc8, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_64) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc8_31.2: = bound_method %float.loc8, %specific_fn.loc8 [concrete = constants.%bound_method.0fc] +// CHECK:STDOUT: %bound_method.loc8_31.2: = bound_method %float.loc8, %specific_fn.loc8 [concrete = constants.%bound_method.d56] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call.loc8: init %f64.d77 = call %bound_method.loc8_31.2(%float.loc8) [concrete = constants.%float.bde] // CHECK:STDOUT: %.loc8_31.1: %f64.d77 = value_of_initializer %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call.loc8 [concrete = constants.%float.bde] // CHECK:STDOUT: %.loc8_31.2: %f64.d77 = converted %float.loc8, %.loc8_31.1 [concrete = constants.%float.bde] @@ -430,13 +430,13 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] // CHECK:STDOUT: %bound_method.577: = bound_method %float.1f7, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.4db: %f32.97e = float_value 0 [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.3ff: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] -// CHECK:STDOUT: %bound_method.1e4: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.c4b: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %bound_method.57d: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] -// CHECK:STDOUT: %float.516: Core.FloatLiteral = float_literal_value 10e37 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.b7f: = bound_method %float.516, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] -// CHECK:STDOUT: %bound_method.40e: = bound_method %float.516, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %float.8d2: Core.FloatLiteral = float_literal_value 10e37 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.d1f: = bound_method %float.8d2, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %bound_method.bed: = bound_method %float.8d2, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.520: %f32.97e = float_value 9.99999968E+37 [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: @@ -483,21 +483,21 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %.loc6_31.2: %f32.97e = converted %float.loc6, %.loc6_31.1 [concrete = constants.%float.4db] // CHECK:STDOUT: %Float32ToFloat32.call.loc6: init %f32.97e = call %Float32ToFloat32.ref.loc6(%.loc6_31.2) [concrete = constants.%float.4db] // CHECK:STDOUT: %Float32ToFloat32.ref.loc7: %Float32ToFloat32.type = name_ref Float32ToFloat32, imports.%Main.Float32ToFloat32 [concrete = constants.%Float32ToFloat32] -// CHECK:STDOUT: %float.loc7: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float.loc7: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %impl.elem0.loc7: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] -// CHECK:STDOUT: %bound_method.loc7_31.1: = bound_method %float.loc7, %impl.elem0.loc7 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.3ff] +// CHECK:STDOUT: %bound_method.loc7_31.1: = bound_method %float.loc7, %impl.elem0.loc7 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.c4b] // CHECK:STDOUT: %specific_fn.loc7: = specific_function %impl.elem0.loc7, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc7_31.2: = bound_method %float.loc7, %specific_fn.loc7 [concrete = constants.%bound_method.1e4] +// CHECK:STDOUT: %bound_method.loc7_31.2: = bound_method %float.loc7, %specific_fn.loc7 [concrete = constants.%bound_method.57d] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call.loc7: init %f32.97e = call %bound_method.loc7_31.2(%float.loc7) [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc7_31.1: %f32.97e = value_of_initializer %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call.loc7 [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc7_31.2: %f32.97e = converted %float.loc7, %.loc7_31.1 [concrete = constants.%float.e3b] // CHECK:STDOUT: %Float32ToFloat32.call.loc7: init %f32.97e = call %Float32ToFloat32.ref.loc7(%.loc7_31.2) [concrete = constants.%float.e3b] // CHECK:STDOUT: %Float32ToFloat32.ref.loc8: %Float32ToFloat32.type = name_ref Float32ToFloat32, imports.%Main.Float32ToFloat32 [concrete = constants.%Float32ToFloat32] -// CHECK:STDOUT: %float.loc8: Core.FloatLiteral = float_literal_value 10e37 [concrete = constants.%float.516] +// CHECK:STDOUT: %float.loc8: Core.FloatLiteral = float_literal_value 10e37 [concrete = constants.%float.8d2] // CHECK:STDOUT: %impl.elem0.loc8: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] -// CHECK:STDOUT: %bound_method.loc8_31.1: = bound_method %float.loc8, %impl.elem0.loc8 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.b7f] +// CHECK:STDOUT: %bound_method.loc8_31.1: = bound_method %float.loc8, %impl.elem0.loc8 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.d1f] // CHECK:STDOUT: %specific_fn.loc8: = specific_function %impl.elem0.loc8, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc8_31.2: = bound_method %float.loc8, %specific_fn.loc8 [concrete = constants.%bound_method.40e] +// CHECK:STDOUT: %bound_method.loc8_31.2: = bound_method %float.loc8, %specific_fn.loc8 [concrete = constants.%bound_method.bed] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call.loc8: init %f32.97e = call %bound_method.loc8_31.2(%float.loc8) [concrete = constants.%float.520] // CHECK:STDOUT: %.loc8_31.1: %f32.97e = value_of_initializer %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call.loc8 [concrete = constants.%float.520] // CHECK:STDOUT: %.loc8_31.2: %f32.97e = converted %float.loc8, %.loc8_31.1 [concrete = constants.%float.520] @@ -515,7 +515,7 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %Float64ToFloat32: %Float64ToFloat32.type = struct_value () [concrete] // CHECK:STDOUT: %int_64: Core.IntLiteral = int_value 64 [concrete] // CHECK:STDOUT: %f64.d77: type = class_type @Float, @Float(%int_64) [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %ImplicitAs.type.4a8: type = facet_type <@ImplicitAs, @ImplicitAs(%f64.d77)> [concrete] // CHECK:STDOUT: %To: Core.IntLiteral = symbolic_binding To, 0 [symbolic] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.type.02f: type = fn_type @Core.FloatLiteral.as.ImplicitAs.impl.Convert, @Core.FloatLiteral.as.ImplicitAs.impl(%To) [symbolic] @@ -526,9 +526,9 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %ImplicitAs.facet: %ImplicitAs.type.4a8 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.cb2) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.a33: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f64.d77, %ImplicitAs.facet) [concrete] // CHECK:STDOUT: %.6c5: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.a33, %ImplicitAs.facet [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_64) [concrete] -// CHECK:STDOUT: %bound_method: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.d20: %f64.d77 = float_value 1 [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] // CHECK:STDOUT: } @@ -552,7 +552,7 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: fn @__global_init() { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Float64ToFloat32.ref: %Float64ToFloat32.type = name_ref Float64ToFloat32, imports.%Main.Float64ToFloat32 [concrete = constants.%Float64ToFloat32] -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %impl.elem0: %.6c5 = impl_witness_access constants.%ImplicitAs.impl_witness.cb2, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.239] // CHECK:STDOUT: %bound_method.loc6_31.1: = bound_method %float, %impl.elem0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_64) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] @@ -575,7 +575,7 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %int_64: Core.IntLiteral = int_value 64 [concrete] // CHECK:STDOUT: %f64.d77: type = class_type @Float, @Float(%int_64) [concrete] // CHECK:STDOUT: %pattern_type.0ae: type = pattern_type %f64.d77 [concrete] -// CHECK:STDOUT: %float.bfd691.1: Core.FloatLiteral = float_literal_value 10e38 [concrete] +// CHECK:STDOUT: %float.cfcfd2.1: Core.FloatLiteral = float_literal_value 10e38 [concrete] // CHECK:STDOUT: %ImplicitAs.type.4a8: type = facet_type <@ImplicitAs, @ImplicitAs(%f64.d77)> [concrete] // CHECK:STDOUT: %To: Core.IntLiteral = symbolic_binding To, 0 [symbolic] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.type.02f: type = fn_type @Core.FloatLiteral.as.ImplicitAs.impl.Convert, @Core.FloatLiteral.as.ImplicitAs.impl(%To) [symbolic] @@ -586,16 +586,16 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %ImplicitAs.facet: %ImplicitAs.type.4a8 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.cb2) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.a33: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f64.d77, %ImplicitAs.facet) [concrete] // CHECK:STDOUT: %.6c5: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.a33, %ImplicitAs.facet [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.bfd691.1, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.cfcfd2.1, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_64) [concrete] -// CHECK:STDOUT: %bound_method: = bound_method %float.bfd691.1, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method: = bound_method %float.cfcfd2.1, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.c37: %f64.d77 = float_value 9.9999999999999994E+38 [concrete] // CHECK:STDOUT: %FloatLiteralToFloat32.type: type = fn_type @FloatLiteralToFloat32 [concrete] // CHECK:STDOUT: %FloatLiteralToFloat32: %FloatLiteralToFloat32.type = struct_value () [concrete] -// CHECK:STDOUT: %float.bfd691.2: Core.FloatLiteral = float_literal_value 10e38 [concrete] +// CHECK:STDOUT: %float.cfcfd2.2: Core.FloatLiteral = float_literal_value 10e38 [concrete] // CHECK:STDOUT: %FloatLiteralToFloat64.type: type = fn_type @FloatLiteralToFloat64 [concrete] // CHECK:STDOUT: %FloatLiteralToFloat64: %FloatLiteralToFloat64.type = struct_value () [concrete] -// CHECK:STDOUT: %float.bb5: Core.FloatLiteral = float_literal_value 10e308 [concrete] +// CHECK:STDOUT: %float.82f: Core.FloatLiteral = float_literal_value 10e308 [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -633,7 +633,7 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: fn @__global_init() { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Float64ToFloat32.ref: %Float64ToFloat32.type = name_ref Float64ToFloat32, imports.%Main.Float64ToFloat32 [concrete = constants.%Float64ToFloat32] -// CHECK:STDOUT: %float.loc11: Core.FloatLiteral = float_literal_value 10e38 [concrete = constants.%float.bfd691.1] +// CHECK:STDOUT: %float.loc11: Core.FloatLiteral = float_literal_value 10e38 [concrete = constants.%float.cfcfd2.1] // CHECK:STDOUT: %impl.elem0: %.6c5 = impl_witness_access constants.%ImplicitAs.impl_witness.cb2, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.239] // CHECK:STDOUT: %bound_method.loc11_31.1: = bound_method %float.loc11, %impl.elem0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_64) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] @@ -643,10 +643,10 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %.loc11_31.2: %f64.d77 = converted %float.loc11, %.loc11_31.1 [concrete = constants.%float.c37] // CHECK:STDOUT: %Float64ToFloat32.call: init %f32.97e = call %Float64ToFloat32.ref(%.loc11_31.2) [concrete = ] // CHECK:STDOUT: %FloatLiteralToFloat32.ref: %FloatLiteralToFloat32.type = name_ref FloatLiteralToFloat32, imports.%Main.FloatLiteralToFloat32 [concrete = constants.%FloatLiteralToFloat32] -// CHECK:STDOUT: %float.loc16: Core.FloatLiteral = float_literal_value 10e38 [concrete = constants.%float.bfd691.2] +// CHECK:STDOUT: %float.loc16: Core.FloatLiteral = float_literal_value 10e38 [concrete = constants.%float.cfcfd2.2] // CHECK:STDOUT: %FloatLiteralToFloat32.call: init %f32.97e = call %FloatLiteralToFloat32.ref(%float.loc16) [concrete = ] // CHECK:STDOUT: %FloatLiteralToFloat64.ref: %FloatLiteralToFloat64.type = name_ref FloatLiteralToFloat64, imports.%Main.FloatLiteralToFloat64 [concrete = constants.%FloatLiteralToFloat64] -// CHECK:STDOUT: %float.loc21: Core.FloatLiteral = float_literal_value 10e308 [concrete = constants.%float.bb5] +// CHECK:STDOUT: %float.loc21: Core.FloatLiteral = float_literal_value 10e308 [concrete = constants.%float.82f] // CHECK:STDOUT: %FloatLiteralToFloat64.call: init %f64.d77 = call %FloatLiteralToFloat64.ref(%float.loc21) [concrete = ] // CHECK:STDOUT: // CHECK:STDOUT: } @@ -661,7 +661,7 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %Float32ToFloat64: %Float32ToFloat64.type = struct_value () [concrete] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] // CHECK:STDOUT: %f32.97e: type = class_type @Float, @Float(%int_32) [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %ImplicitAs.type.223: type = facet_type <@ImplicitAs, @ImplicitAs(%f32.97e)> [concrete] // CHECK:STDOUT: %To: Core.IntLiteral = symbolic_binding To, 0 [symbolic] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.type.02f: type = fn_type @Core.FloatLiteral.as.ImplicitAs.impl.Convert, @Core.FloatLiteral.as.ImplicitAs.impl(%To) [symbolic] @@ -672,14 +672,14 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: %ImplicitAs.facet: %ImplicitAs.type.223 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.bc6) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.e4d: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f32.97e, %ImplicitAs.facet) [concrete] // CHECK:STDOUT: %.98d: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.e4d, %ImplicitAs.facet [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.3ff: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.c4b: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.1e4: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.57d: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] // CHECK:STDOUT: %float.d20: %f64.d77 = float_value 1 [concrete] -// CHECK:STDOUT: %float.9bd: Core.FloatLiteral = float_literal_value 10e29 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.204: = bound_method %float.9bd, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] -// CHECK:STDOUT: %bound_method.0b8: = bound_method %float.9bd, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %float.c02: Core.FloatLiteral = float_literal_value 10e29 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.9ad: = bound_method %float.c02, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %bound_method.601: = bound_method %float.c02, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.7d4: %f32.97e = float_value 1.00000002E+30 [concrete] // CHECK:STDOUT: %float.6a7: %f64.d77 = float_value 1.0000000150474662E+30 [concrete] // CHECK:STDOUT: } @@ -710,21 +710,21 @@ let convert_not_constant: f64 = Float64ToFloat64(not_constant_64); // CHECK:STDOUT: fn @__global_init() { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Float32ToFloat64.ref.loc6: %Float32ToFloat64.type = name_ref Float32ToFloat64, imports.%Main.Float32ToFloat64 [concrete = constants.%Float32ToFloat64] -// CHECK:STDOUT: %float.loc6: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float.loc6: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %impl.elem0.loc6: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] -// CHECK:STDOUT: %bound_method.loc6_31.1: = bound_method %float.loc6, %impl.elem0.loc6 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.3ff] +// CHECK:STDOUT: %bound_method.loc6_31.1: = bound_method %float.loc6, %impl.elem0.loc6 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.c4b] // CHECK:STDOUT: %specific_fn.loc6: = specific_function %impl.elem0.loc6, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc6_31.2: = bound_method %float.loc6, %specific_fn.loc6 [concrete = constants.%bound_method.1e4] +// CHECK:STDOUT: %bound_method.loc6_31.2: = bound_method %float.loc6, %specific_fn.loc6 [concrete = constants.%bound_method.57d] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call.loc6: init %f32.97e = call %bound_method.loc6_31.2(%float.loc6) [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc6_31.1: %f32.97e = value_of_initializer %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call.loc6 [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc6_31.2: %f32.97e = converted %float.loc6, %.loc6_31.1 [concrete = constants.%float.e3b] // CHECK:STDOUT: %Float32ToFloat64.call.loc6: init %f64.d77 = call %Float32ToFloat64.ref.loc6(%.loc6_31.2) [concrete = constants.%float.d20] // CHECK:STDOUT: %Float32ToFloat64.ref.loc7: %Float32ToFloat64.type = name_ref Float32ToFloat64, imports.%Main.Float32ToFloat64 [concrete = constants.%Float32ToFloat64] -// CHECK:STDOUT: %float.loc7: Core.FloatLiteral = float_literal_value 10e29 [concrete = constants.%float.9bd] +// CHECK:STDOUT: %float.loc7: Core.FloatLiteral = float_literal_value 10e29 [concrete = constants.%float.c02] // CHECK:STDOUT: %impl.elem0.loc7: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] -// CHECK:STDOUT: %bound_method.loc7_31.1: = bound_method %float.loc7, %impl.elem0.loc7 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.204] +// CHECK:STDOUT: %bound_method.loc7_31.1: = bound_method %float.loc7, %impl.elem0.loc7 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound.9ad] // CHECK:STDOUT: %specific_fn.loc7: = specific_function %impl.elem0.loc7, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc7_31.2: = bound_method %float.loc7, %specific_fn.loc7 [concrete = constants.%bound_method.0b8] +// CHECK:STDOUT: %bound_method.loc7_31.2: = bound_method %float.loc7, %specific_fn.loc7 [concrete = constants.%bound_method.601] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call.loc7: init %f32.97e = call %bound_method.loc7_31.2(%float.loc7) [concrete = constants.%float.7d4] // CHECK:STDOUT: %.loc7_31.1: %f32.97e = value_of_initializer %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call.loc7 [concrete = constants.%float.7d4] // CHECK:STDOUT: %.loc7_31.2: %f32.97e = converted %float.loc7, %.loc7_31.1 [concrete = constants.%float.7d4] diff --git a/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon b/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon index a833f751779f..9bb549c51464 100644 --- a/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon +++ b/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon @@ -37,7 +37,7 @@ fn Run() { // CHECK:STDOUT: %pattern_type.0ae: type = pattern_type %f64.d77 [concrete] // CHECK:STDOUT: %Foo.type: type = fn_type @Foo [concrete] // CHECK:STDOUT: %Foo: %Foo.type = struct_value () [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %ImplicitAs.type.cc7: type = generic_interface_type @ImplicitAs [concrete] // CHECK:STDOUT: %ImplicitAs.generic: %ImplicitAs.type.cc7 = struct_value () [concrete] // CHECK:STDOUT: %ImplicitAs.type.4a8: type = facet_type <@ImplicitAs, @ImplicitAs(%f64.d77)> [concrete] @@ -50,9 +50,9 @@ fn Run() { // CHECK:STDOUT: %ImplicitAs.facet: %ImplicitAs.type.4a8 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.cb2) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.a33: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f64.d77, %ImplicitAs.facet) [concrete] // CHECK:STDOUT: %.6c5: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.a33, %ImplicitAs.facet [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_64) [concrete] -// CHECK:STDOUT: %bound_method: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.d20: %f64.d77 = float_value 1 [concrete] // CHECK:STDOUT: %Run.type: type = fn_type @Run [concrete] // CHECK:STDOUT: %Run: %Run.type = struct_value () [concrete] @@ -104,7 +104,7 @@ fn Run() { // CHECK:STDOUT: // CHECK:STDOUT: fn @Foo() -> out %return.param: %f64.d77 { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %impl.elem0: %.6c5 = impl_witness_access constants.%ImplicitAs.impl_witness.cb2, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.239] // CHECK:STDOUT: %bound_method.loc15_29.1: = bound_method %float, %impl.elem0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_64) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] diff --git a/toolchain/check/testdata/interop/cpp/builtins.carbon b/toolchain/check/testdata/interop/cpp/builtins.carbon index 206eefa1885f..b6e4c7bfcb8f 100644 --- a/toolchain/check/testdata/interop/cpp/builtins.carbon +++ b/toolchain/check/testdata/interop/cpp/builtins.carbon @@ -203,7 +203,7 @@ fn F() { // CHECK:STDOUT: %int_1.c1d: %u32 = int_value 1 [concrete] // CHECK:STDOUT: %f32.97e: type = class_type @Float, @Float(%int_32) [concrete] // CHECK:STDOUT: %pattern_type.201: type = pattern_type %f32.97e [concrete] -// CHECK:STDOUT: %float.674bbc.1: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6daae3.1: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %As.type.9fc: type = facet_type <@As, @As(%f32.97e)> [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.type.882: type = fn_type @Core.FloatLiteral.as.As.impl.Convert, @Core.FloatLiteral.as.As.impl(%To) [symbolic] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.27d: %Core.FloatLiteral.as.As.impl.Convert.type.882 = struct_value () [symbolic] @@ -213,14 +213,14 @@ fn F() { // CHECK:STDOUT: %As.facet.58f: %As.type.9fc = facet_value Core.FloatLiteral, (%As.impl_witness.748) [concrete] // CHECK:STDOUT: %As.WithSelf.Convert.type.85f: type = fn_type @As.WithSelf.Convert, @As.WithSelf(%f32.97e, %As.facet.58f) [concrete] // CHECK:STDOUT: %.49e: type = fn_type_with_self_type %As.WithSelf.Convert.type.85f, %As.facet.58f [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound.ec8: = bound_method %float.674bbc.1, %Core.FloatLiteral.as.As.impl.Convert.683 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound.04c: = bound_method %float.6daae3.1, %Core.FloatLiteral.as.As.impl.Convert.683 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.specific_fn.10a: = specific_function %Core.FloatLiteral.as.As.impl.Convert.683, @Core.FloatLiteral.as.As.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.cae: = bound_method %float.674bbc.1, %Core.FloatLiteral.as.As.impl.Convert.specific_fn.10a [concrete] +// CHECK:STDOUT: %bound_method.4ec: = bound_method %float.6daae3.1, %Core.FloatLiteral.as.As.impl.Convert.specific_fn.10a [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] // CHECK:STDOUT: %int_64: Core.IntLiteral = int_value 64 [concrete] // CHECK:STDOUT: %f64.d77: type = class_type @Float, @Float(%int_64) [concrete] // CHECK:STDOUT: %pattern_type.0ae: type = pattern_type %f64.d77 [concrete] -// CHECK:STDOUT: %float.674bbc.2: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6daae3.2: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %As.type.a57: type = facet_type <@As, @As(%f64.d77)> [concrete] // CHECK:STDOUT: %As.impl_witness.187: = impl_witness imports.%As.impl_witness_table.7c1, @Core.FloatLiteral.as.As.impl(%int_64) [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.type.07c: type = fn_type @Core.FloatLiteral.as.As.impl.Convert, @Core.FloatLiteral.as.As.impl(%int_64) [concrete] @@ -228,9 +228,9 @@ fn F() { // CHECK:STDOUT: %As.facet.750: %As.type.a57 = facet_value Core.FloatLiteral, (%As.impl_witness.187) [concrete] // CHECK:STDOUT: %As.WithSelf.Convert.type.dab: type = fn_type @As.WithSelf.Convert, @As.WithSelf(%f64.d77, %As.facet.750) [concrete] // CHECK:STDOUT: %.293: type = fn_type_with_self_type %As.WithSelf.Convert.type.dab, %As.facet.750 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound.f54: = bound_method %float.674bbc.2, %Core.FloatLiteral.as.As.impl.Convert.4b9 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound.9c5: = bound_method %float.6daae3.2, %Core.FloatLiteral.as.As.impl.Convert.4b9 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.specific_fn.b2e: = specific_function %Core.FloatLiteral.as.As.impl.Convert.4b9, @Core.FloatLiteral.as.As.impl.Convert(%int_64) [concrete] -// CHECK:STDOUT: %bound_method.20b: = bound_method %float.674bbc.2, %Core.FloatLiteral.as.As.impl.Convert.specific_fn.b2e [concrete] +// CHECK:STDOUT: %bound_method.18b: = bound_method %float.6daae3.2, %Core.FloatLiteral.as.As.impl.Convert.specific_fn.b2e [concrete] // CHECK:STDOUT: %float.d20: %f64.d77 = float_value 1 [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: @@ -403,12 +403,12 @@ fn F() { // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %cpp_float.patt: %pattern_type.201 = value_binding_pattern cpp_float [concrete] // CHECK:STDOUT: } -// CHECK:STDOUT: %float.loc26: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674bbc.1] +// CHECK:STDOUT: %float.loc26: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6daae3.1] // CHECK:STDOUT: %f32.loc26: type = type_literal constants.%f32.97e [concrete = constants.%f32.97e] // CHECK:STDOUT: %impl.elem0.loc26: %.49e = impl_witness_access constants.%As.impl_witness.748, element0 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.683] -// CHECK:STDOUT: %bound_method.loc26_35.1: = bound_method %float.loc26, %impl.elem0.loc26 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.bound.ec8] +// CHECK:STDOUT: %bound_method.loc26_35.1: = bound_method %float.loc26, %impl.elem0.loc26 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.bound.04c] // CHECK:STDOUT: %specific_fn.loc26: = specific_function %impl.elem0.loc26, @Core.FloatLiteral.as.As.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.specific_fn.10a] -// CHECK:STDOUT: %bound_method.loc26_35.2: = bound_method %float.loc26, %specific_fn.loc26 [concrete = constants.%bound_method.cae] +// CHECK:STDOUT: %bound_method.loc26_35.2: = bound_method %float.loc26, %specific_fn.loc26 [concrete = constants.%bound_method.4ec] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.call.loc26: init %f32.97e = call %bound_method.loc26_35.2(%float.loc26) [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc26_35.1: %f32.97e = value_of_initializer %Core.FloatLiteral.as.As.impl.Convert.call.loc26 [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc26_35.2: %f32.97e = converted %float.loc26, %.loc26_35.1 [concrete = constants.%float.e3b] @@ -427,12 +427,12 @@ fn F() { // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %cpp_double.patt: %pattern_type.0ae = value_binding_pattern cpp_double [concrete] // CHECK:STDOUT: } -// CHECK:STDOUT: %float.loc29: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674bbc.2] +// CHECK:STDOUT: %float.loc29: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6daae3.2] // CHECK:STDOUT: %f64.loc29: type = type_literal constants.%f64.d77 [concrete = constants.%f64.d77] // CHECK:STDOUT: %impl.elem0.loc29: %.293 = impl_witness_access constants.%As.impl_witness.187, element0 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.4b9] -// CHECK:STDOUT: %bound_method.loc29_37.1: = bound_method %float.loc29, %impl.elem0.loc29 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.bound.f54] +// CHECK:STDOUT: %bound_method.loc29_37.1: = bound_method %float.loc29, %impl.elem0.loc29 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.bound.9c5] // CHECK:STDOUT: %specific_fn.loc29: = specific_function %impl.elem0.loc29, @Core.FloatLiteral.as.As.impl.Convert(constants.%int_64) [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.specific_fn.b2e] -// CHECK:STDOUT: %bound_method.loc29_37.2: = bound_method %float.loc29, %specific_fn.loc29 [concrete = constants.%bound_method.20b] +// CHECK:STDOUT: %bound_method.loc29_37.2: = bound_method %float.loc29, %specific_fn.loc29 [concrete = constants.%bound_method.18b] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.call.loc29: init %f64.d77 = call %bound_method.loc29_37.2(%float.loc29) [concrete = constants.%float.d20] // CHECK:STDOUT: %.loc29_37.1: %f64.d77 = value_of_initializer %Core.FloatLiteral.as.As.impl.Convert.call.loc29 [concrete = constants.%float.d20] // CHECK:STDOUT: %.loc29_37.2: %f64.d77 = converted %float.loc29, %.loc29_37.1 [concrete = constants.%float.d20] @@ -454,7 +454,7 @@ fn F() { // CHECK:STDOUT: --- fail_todo_unsupported_types.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %int_64: Core.IntLiteral = int_value 64 [concrete] // CHECK:STDOUT: %f64.d77: type = class_type @Float, @Float(%int_64) [concrete] // CHECK:STDOUT: %As.type.a57: type = facet_type <@As, @As(%f64.d77)> [concrete] @@ -467,10 +467,10 @@ fn F() { // CHECK:STDOUT: %As.facet: %As.type.a57 = facet_value Core.FloatLiteral, (%As.impl_witness.187) [concrete] // CHECK:STDOUT: %As.WithSelf.Convert.type.dab: type = fn_type @As.WithSelf.Convert, @As.WithSelf(%f64.d77, %As.facet) [concrete] // CHECK:STDOUT: %.293: type = fn_type_with_self_type %As.WithSelf.Convert.type.dab, %As.facet [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.As.impl.Convert.4b9 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.As.impl.Convert.4b9 [concrete] // CHECK:STDOUT: %pattern_type.0ae: type = pattern_type %f64.d77 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.As.impl.Convert.4b9, @Core.FloatLiteral.as.As.impl.Convert(%int_64) [concrete] -// CHECK:STDOUT: %bound_method: = bound_method %float.674, %Core.FloatLiteral.as.As.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method: = bound_method %float.6da, %Core.FloatLiteral.as.As.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.d20: %f64.d77 = float_value 1 [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: @@ -484,7 +484,7 @@ fn F() { // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %cpp_long_double.patt: = value_binding_pattern cpp_long_double [concrete] // CHECK:STDOUT: } -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %f64.loc15: type = type_literal constants.%f64.d77 [concrete = constants.%f64.d77] // CHECK:STDOUT: %impl.elem0: %.293 = impl_witness_access constants.%As.impl_witness.187, element0 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.4b9] // CHECK:STDOUT: %bound_method.loc15_47.1: = bound_method %float, %impl.elem0 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.bound] diff --git a/toolchain/check/testdata/interop/cpp/builtins.llp64.carbon b/toolchain/check/testdata/interop/cpp/builtins.llp64.carbon index 2e04f3d01202..a568fa6fd715 100644 --- a/toolchain/check/testdata/interop/cpp/builtins.llp64.carbon +++ b/toolchain/check/testdata/interop/cpp/builtins.llp64.carbon @@ -735,9 +735,9 @@ fn CopyUnsignedLong() { // CHECK:STDOUT: %bound_method.d1e: = bound_method %int_1.41a, %Int.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %array_type: type = array_type %int_1.5b8, %f32.97e [concrete] // CHECK:STDOUT: %pattern_type.b36: type = pattern_type %array_type [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %tuple.type: type = tuple_type (Core.FloatLiteral) [concrete] -// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.674) [concrete] +// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.6da) [concrete] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete] // CHECK:STDOUT: %ImplicitAs.type.223: type = facet_type <@ImplicitAs, @ImplicitAs(%f32.97e)> [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.type.02f: type = fn_type @Core.FloatLiteral.as.ImplicitAs.impl.Convert, @Core.FloatLiteral.as.ImplicitAs.impl(%N) [symbolic] @@ -748,9 +748,9 @@ fn CopyUnsignedLong() { // CHECK:STDOUT: %ImplicitAs.facet.945: %ImplicitAs.type.223 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.bc6) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.e4d: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f32.97e, %ImplicitAs.facet.945) [concrete] // CHECK:STDOUT: %.98d: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.e4d, %ImplicitAs.facet.945 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.1e4: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.57d: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] // CHECK:STDOUT: %array: %array_type = tuple_value (%float.e3b) [concrete] // CHECK:STDOUT: %Destroy.Op.type: type = fn_type @Destroy.Op [concrete] @@ -802,12 +802,12 @@ fn CopyUnsignedLong() { // CHECK:STDOUT: %a.var_patt: %pattern_type.b36 = var_pattern %a.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %a.var: ref %array_type = var %a.var_patt -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %.loc11_55.1: %tuple.type = tuple_literal (%float) [concrete = constants.%tuple] // CHECK:STDOUT: %impl.elem0.loc11_55: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] // CHECK:STDOUT: %bound_method.loc11_55.1: = bound_method %float, %impl.elem0.loc11_55 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn.loc11_55: = specific_function %impl.elem0.loc11_55, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc11_55.2: = bound_method %float, %specific_fn.loc11_55 [concrete = constants.%bound_method.1e4] +// CHECK:STDOUT: %bound_method.loc11_55.2: = bound_method %float, %specific_fn.loc11_55 [concrete = constants.%bound_method.57d] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call: init %f32.97e = call %bound_method.loc11_55.2(%float) [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc11_55.2: init %f32.97e = converted %float, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%float.e3b] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0] @@ -897,9 +897,9 @@ fn CopyUnsignedLong() { // CHECK:STDOUT: %bound_method.f18: = bound_method %int_1.f23, %UInt.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %array_type: type = array_type %int_1.5b8, %f32.97e [concrete] // CHECK:STDOUT: %pattern_type.b36: type = pattern_type %array_type [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %tuple.type: type = tuple_type (Core.FloatLiteral) [concrete] -// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.674) [concrete] +// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.6da) [concrete] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete] // CHECK:STDOUT: %ImplicitAs.type.223: type = facet_type <@ImplicitAs, @ImplicitAs(%f32.97e)> [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.type.02f: type = fn_type @Core.FloatLiteral.as.ImplicitAs.impl.Convert, @Core.FloatLiteral.as.ImplicitAs.impl(%N) [symbolic] @@ -910,9 +910,9 @@ fn CopyUnsignedLong() { // CHECK:STDOUT: %ImplicitAs.facet.945: %ImplicitAs.type.223 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.bc6) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.e4d: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f32.97e, %ImplicitAs.facet.945) [concrete] // CHECK:STDOUT: %.98d: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.e4d, %ImplicitAs.facet.945 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.1e4: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.57d: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] // CHECK:STDOUT: %array: %array_type = tuple_value (%float.e3b) [concrete] // CHECK:STDOUT: %Destroy.Op.type: type = fn_type @Destroy.Op [concrete] @@ -964,12 +964,12 @@ fn CopyUnsignedLong() { // CHECK:STDOUT: %a.var_patt: %pattern_type.b36 = var_pattern %a.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %a.var: ref %array_type = var %a.var_patt -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %.loc11_64.1: %tuple.type = tuple_literal (%float) [concrete = constants.%tuple] // CHECK:STDOUT: %impl.elem0.loc11_64: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] // CHECK:STDOUT: %bound_method.loc11_64.1: = bound_method %float, %impl.elem0.loc11_64 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn.loc11_64: = specific_function %impl.elem0.loc11_64, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc11_64.2: = bound_method %float, %specific_fn.loc11_64 [concrete = constants.%bound_method.1e4] +// CHECK:STDOUT: %bound_method.loc11_64.2: = bound_method %float, %specific_fn.loc11_64 [concrete = constants.%bound_method.57d] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call: init %f32.97e = call %bound_method.loc11_64.2(%float) [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc11_64.2: init %f32.97e = converted %float, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%float.e3b] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0] @@ -1076,9 +1076,9 @@ fn CopyUnsignedLong() { // CHECK:STDOUT: %Cpp.long.as.ImplicitAs.impl.Convert.bound: = bound_method %int_1.5a4, %Cpp.long.as.ImplicitAs.impl.Convert.d49 [concrete] // CHECK:STDOUT: %array_type: type = array_type %int_1.5b8, %f32.97e [concrete] // CHECK:STDOUT: %pattern_type.b36: type = pattern_type %array_type [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %tuple.type: type = tuple_type (Core.FloatLiteral) [concrete] -// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.674) [concrete] +// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.6da) [concrete] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete] // CHECK:STDOUT: %ImplicitAs.type.223: type = facet_type <@ImplicitAs, @ImplicitAs(%f32.97e)> [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.type.02f: type = fn_type @Core.FloatLiteral.as.ImplicitAs.impl.Convert, @Core.FloatLiteral.as.ImplicitAs.impl(%N) [symbolic] @@ -1089,9 +1089,9 @@ fn CopyUnsignedLong() { // CHECK:STDOUT: %ImplicitAs.facet.945: %ImplicitAs.type.223 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.bc6) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.e4d: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f32.97e, %ImplicitAs.facet.945) [concrete] // CHECK:STDOUT: %.98d: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.e4d, %ImplicitAs.facet.945 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] // CHECK:STDOUT: %array: %array_type = tuple_value (%float.e3b) [concrete] // CHECK:STDOUT: %Destroy.type: type = facet_type <@Destroy> [concrete] @@ -1260,7 +1260,7 @@ fn CopyUnsignedLong() { // CHECK:STDOUT: %a.var_patt: %pattern_type.b36 = var_pattern %a.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %a.var: ref %array_type = var %a.var_patt -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %.loc26_50.1: %tuple.type = tuple_literal (%float) [concrete = constants.%tuple] // CHECK:STDOUT: %impl.elem0.loc26_50: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] // CHECK:STDOUT: %bound_method.loc26_50.1: = bound_method %float, %impl.elem0.loc26_50 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] @@ -3931,9 +3931,9 @@ fn CopyUnsignedLong() { // CHECK:STDOUT: %Cpp.unsigned_long.as.ImplicitAs.impl.Convert.bound: = bound_method %int_1.0ab, %Cpp.unsigned_long.as.ImplicitAs.impl.Convert [concrete] // CHECK:STDOUT: %array_type: type = array_type %int_1.5b8, %f32.97e [concrete] // CHECK:STDOUT: %pattern_type.b36: type = pattern_type %array_type [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %tuple.type: type = tuple_type (Core.FloatLiteral) [concrete] -// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.674) [concrete] +// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.6da) [concrete] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete] // CHECK:STDOUT: %ImplicitAs.type.223: type = facet_type <@ImplicitAs, @ImplicitAs(%f32.97e)> [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.type.02f: type = fn_type @Core.FloatLiteral.as.ImplicitAs.impl.Convert, @Core.FloatLiteral.as.ImplicitAs.impl(%N) [symbolic] @@ -3944,9 +3944,9 @@ fn CopyUnsignedLong() { // CHECK:STDOUT: %ImplicitAs.facet.945: %ImplicitAs.type.223 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.bc6) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.e4d: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f32.97e, %ImplicitAs.facet.945) [concrete] // CHECK:STDOUT: %.98d: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.e4d, %ImplicitAs.facet.945 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.1e4: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.57d: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] // CHECK:STDOUT: %array: %array_type = tuple_value (%float.e3b) [concrete] // CHECK:STDOUT: %Destroy.type: type = facet_type <@Destroy> [concrete] @@ -4108,12 +4108,12 @@ fn CopyUnsignedLong() { // CHECK:STDOUT: %a.var_patt: %pattern_type.b36 = var_pattern %a.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %a.var: ref %array_type = var %a.var_patt -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %.loc24_59.1: %tuple.type = tuple_literal (%float) [concrete = constants.%tuple] // CHECK:STDOUT: %impl.elem0.loc24_59: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] // CHECK:STDOUT: %bound_method.loc24_59.1: = bound_method %float, %impl.elem0.loc24_59 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn.loc24: = specific_function %impl.elem0.loc24_59, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc24_59.2: = bound_method %float, %specific_fn.loc24 [concrete = constants.%bound_method.1e4] +// CHECK:STDOUT: %bound_method.loc24_59.2: = bound_method %float, %specific_fn.loc24 [concrete = constants.%bound_method.57d] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call: init %f32.97e = call %bound_method.loc24_59.2(%float) [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc24_59.2: init %f32.97e = converted %float, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%float.e3b] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0] diff --git a/toolchain/check/testdata/interop/cpp/builtins.lp64.carbon b/toolchain/check/testdata/interop/cpp/builtins.lp64.carbon index f79a91b22868..be754b771d08 100644 --- a/toolchain/check/testdata/interop/cpp/builtins.lp64.carbon +++ b/toolchain/check/testdata/interop/cpp/builtins.lp64.carbon @@ -683,9 +683,9 @@ fn CopyUnsignedLongLong() { // CHECK:STDOUT: %bound_method.d1e: = bound_method %int_1.41a, %Int.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %array_type: type = array_type %int_1.5b8, %f32.97e [concrete] // CHECK:STDOUT: %pattern_type.b36: type = pattern_type %array_type [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %tuple.type: type = tuple_type (Core.FloatLiteral) [concrete] -// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.674) [concrete] +// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.6da) [concrete] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete] // CHECK:STDOUT: %ImplicitAs.type.223: type = facet_type <@ImplicitAs, @ImplicitAs(%f32.97e)> [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.type.02f: type = fn_type @Core.FloatLiteral.as.ImplicitAs.impl.Convert, @Core.FloatLiteral.as.ImplicitAs.impl(%N) [symbolic] @@ -696,9 +696,9 @@ fn CopyUnsignedLongLong() { // CHECK:STDOUT: %ImplicitAs.facet.945: %ImplicitAs.type.223 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.bc6) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.e4d: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f32.97e, %ImplicitAs.facet.945) [concrete] // CHECK:STDOUT: %.98d: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.e4d, %ImplicitAs.facet.945 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.1e4: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.57d: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] // CHECK:STDOUT: %array: %array_type = tuple_value (%float.e3b) [concrete] // CHECK:STDOUT: %Destroy.Op.type: type = fn_type @Destroy.Op [concrete] @@ -750,12 +750,12 @@ fn CopyUnsignedLongLong() { // CHECK:STDOUT: %a.var_patt: %pattern_type.b36 = var_pattern %a.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %a.var: ref %array_type = var %a.var_patt -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %.loc11_50.1: %tuple.type = tuple_literal (%float) [concrete = constants.%tuple] // CHECK:STDOUT: %impl.elem0.loc11_50: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] // CHECK:STDOUT: %bound_method.loc11_50.1: = bound_method %float, %impl.elem0.loc11_50 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn.loc11_50: = specific_function %impl.elem0.loc11_50, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc11_50.2: = bound_method %float, %specific_fn.loc11_50 [concrete = constants.%bound_method.1e4] +// CHECK:STDOUT: %bound_method.loc11_50.2: = bound_method %float, %specific_fn.loc11_50 [concrete = constants.%bound_method.57d] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call: init %f32.97e = call %bound_method.loc11_50.2(%float) [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc11_50.2: init %f32.97e = converted %float, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%float.e3b] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0] @@ -845,9 +845,9 @@ fn CopyUnsignedLongLong() { // CHECK:STDOUT: %bound_method.f18: = bound_method %int_1.f23, %UInt.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %array_type: type = array_type %int_1.5b8, %f32.97e [concrete] // CHECK:STDOUT: %pattern_type.b36: type = pattern_type %array_type [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %tuple.type: type = tuple_type (Core.FloatLiteral) [concrete] -// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.674) [concrete] +// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.6da) [concrete] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete] // CHECK:STDOUT: %ImplicitAs.type.223: type = facet_type <@ImplicitAs, @ImplicitAs(%f32.97e)> [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.type.02f: type = fn_type @Core.FloatLiteral.as.ImplicitAs.impl.Convert, @Core.FloatLiteral.as.ImplicitAs.impl(%N) [symbolic] @@ -858,9 +858,9 @@ fn CopyUnsignedLongLong() { // CHECK:STDOUT: %ImplicitAs.facet.945: %ImplicitAs.type.223 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.bc6) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.e4d: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f32.97e, %ImplicitAs.facet.945) [concrete] // CHECK:STDOUT: %.98d: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.e4d, %ImplicitAs.facet.945 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.1e4: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.57d: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] // CHECK:STDOUT: %array: %array_type = tuple_value (%float.e3b) [concrete] // CHECK:STDOUT: %Destroy.Op.type: type = fn_type @Destroy.Op [concrete] @@ -912,12 +912,12 @@ fn CopyUnsignedLongLong() { // CHECK:STDOUT: %a.var_patt: %pattern_type.b36 = var_pattern %a.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %a.var: ref %array_type = var %a.var_patt -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %.loc11_59.1: %tuple.type = tuple_literal (%float) [concrete = constants.%tuple] // CHECK:STDOUT: %impl.elem0.loc11_59: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] // CHECK:STDOUT: %bound_method.loc11_59.1: = bound_method %float, %impl.elem0.loc11_59 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn.loc11_59: = specific_function %impl.elem0.loc11_59, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc11_59.2: = bound_method %float, %specific_fn.loc11_59 [concrete = constants.%bound_method.1e4] +// CHECK:STDOUT: %bound_method.loc11_59.2: = bound_method %float, %specific_fn.loc11_59 [concrete = constants.%bound_method.57d] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call: init %f32.97e = call %bound_method.loc11_59.2(%float) [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc11_59.2: init %f32.97e = converted %float, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%float.e3b] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0] @@ -1015,9 +1015,9 @@ fn CopyUnsignedLongLong() { // CHECK:STDOUT: %Cpp.long_long.as.ImplicitAs.impl.Convert.bound: = bound_method %int_1.092, %Cpp.long_long.as.ImplicitAs.impl.Convert [concrete] // CHECK:STDOUT: %array_type: type = array_type %int_1.5b8, %f32.97e [concrete] // CHECK:STDOUT: %pattern_type.b36: type = pattern_type %array_type [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %tuple.type: type = tuple_type (Core.FloatLiteral) [concrete] -// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.674) [concrete] +// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.6da) [concrete] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete] // CHECK:STDOUT: %ImplicitAs.type.223: type = facet_type <@ImplicitAs, @ImplicitAs(%f32.97e)> [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.type.02f: type = fn_type @Core.FloatLiteral.as.ImplicitAs.impl.Convert, @Core.FloatLiteral.as.ImplicitAs.impl(%N) [symbolic] @@ -1028,9 +1028,9 @@ fn CopyUnsignedLongLong() { // CHECK:STDOUT: %ImplicitAs.facet.945: %ImplicitAs.type.223 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.bc6) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.e4d: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f32.97e, %ImplicitAs.facet.945) [concrete] // CHECK:STDOUT: %.98d: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.e4d, %ImplicitAs.facet.945 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] // CHECK:STDOUT: %array: %array_type = tuple_value (%float.e3b) [concrete] // CHECK:STDOUT: %Destroy.type: type = facet_type <@Destroy> [concrete] @@ -1186,7 +1186,7 @@ fn CopyUnsignedLongLong() { // CHECK:STDOUT: %a.var_patt: %pattern_type.b36 = var_pattern %a.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %a.var: ref %array_type = var %a.var_patt -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %.loc24_55.1: %tuple.type = tuple_literal (%float) [concrete = constants.%tuple] // CHECK:STDOUT: %impl.elem0.loc24_55: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] // CHECK:STDOUT: %bound_method.loc24_55.1: = bound_method %float, %impl.elem0.loc24_55 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] @@ -3650,9 +3650,9 @@ fn CopyUnsignedLongLong() { // CHECK:STDOUT: %Cpp.unsigned_long_long.as.ImplicitAs.impl.Convert.bound: = bound_method %int_1.79a, %Cpp.unsigned_long_long.as.ImplicitAs.impl.Convert [concrete] // CHECK:STDOUT: %array_type: type = array_type %int_1.5b8, %f32.97e [concrete] // CHECK:STDOUT: %pattern_type.b36: type = pattern_type %array_type [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %tuple.type: type = tuple_type (Core.FloatLiteral) [concrete] -// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.674) [concrete] +// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.6da) [concrete] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete] // CHECK:STDOUT: %ImplicitAs.type.223: type = facet_type <@ImplicitAs, @ImplicitAs(%f32.97e)> [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.type.02f: type = fn_type @Core.FloatLiteral.as.ImplicitAs.impl.Convert, @Core.FloatLiteral.as.ImplicitAs.impl(%N) [symbolic] @@ -3663,9 +3663,9 @@ fn CopyUnsignedLongLong() { // CHECK:STDOUT: %ImplicitAs.facet.945: %ImplicitAs.type.223 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.bc6) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.e4d: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f32.97e, %ImplicitAs.facet.945) [concrete] // CHECK:STDOUT: %.98d: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.e4d, %ImplicitAs.facet.945 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.1e4: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.57d: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] // CHECK:STDOUT: %array: %array_type = tuple_value (%float.e3b) [concrete] // CHECK:STDOUT: %Destroy.type: type = facet_type <@Destroy> [concrete] @@ -3827,12 +3827,12 @@ fn CopyUnsignedLongLong() { // CHECK:STDOUT: %a.var_patt: %pattern_type.b36 = var_pattern %a.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %a.var: ref %array_type = var %a.var_patt -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %.loc24_64.1: %tuple.type = tuple_literal (%float) [concrete = constants.%tuple] // CHECK:STDOUT: %impl.elem0.loc24_64: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] // CHECK:STDOUT: %bound_method.loc24_64.1: = bound_method %float, %impl.elem0.loc24_64 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn.loc24: = specific_function %impl.elem0.loc24_64, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc24_64.2: = bound_method %float, %specific_fn.loc24 [concrete = constants.%bound_method.1e4] +// CHECK:STDOUT: %bound_method.loc24_64.2: = bound_method %float, %specific_fn.loc24 [concrete = constants.%bound_method.57d] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call: init %f32.97e = call %bound_method.loc24_64.2(%float) [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc24_64.2: init %f32.97e = converted %float, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%float.e3b] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0] diff --git a/toolchain/check/testdata/interop/cpp/function/arithmetic_types_bridged.carbon b/toolchain/check/testdata/interop/cpp/function/arithmetic_types_bridged.carbon index cd841cab5709..a206f3c945e3 100644 --- a/toolchain/check/testdata/interop/cpp/function/arithmetic_types_bridged.carbon +++ b/toolchain/check/testdata/interop/cpp/function/arithmetic_types_bridged.carbon @@ -1707,7 +1707,7 @@ fn F() { // CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] // CHECK:STDOUT: %foo.cpp_overload_set.type: type = cpp_overload_set_type @foo.cpp_overload_set [concrete] // CHECK:STDOUT: %foo.cpp_overload_set.value: %foo.cpp_overload_set.type = cpp_overload_set_value @foo.cpp_overload_set [concrete] -// CHECK:STDOUT: %float.c64: Core.FloatLiteral = float_literal_value 8e-1 [concrete] +// CHECK:STDOUT: %float.96e: Core.FloatLiteral = float_literal_value 8e-1 [concrete] // CHECK:STDOUT: %int_16: Core.IntLiteral = int_value 16 [concrete] // CHECK:STDOUT: %N: Core.IntLiteral = symbolic_binding N, 0 [symbolic] // CHECK:STDOUT: %f16.a6a: type = class_type @Float, @Float(%int_16) [concrete] @@ -1720,9 +1720,9 @@ fn F() { // CHECK:STDOUT: %As.facet: %As.type.b64 = facet_value Core.FloatLiteral, (%As.impl_witness.0d1) [concrete] // CHECK:STDOUT: %As.WithSelf.Convert.type.a0a: type = fn_type @As.WithSelf.Convert, @As.WithSelf(%f16.a6a, %As.facet) [concrete] // CHECK:STDOUT: %.9fd: type = fn_type_with_self_type %As.WithSelf.Convert.type.a0a, %As.facet [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound: = bound_method %float.c64, %Core.FloatLiteral.as.As.impl.Convert.3fd [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound: = bound_method %float.96e, %Core.FloatLiteral.as.As.impl.Convert.3fd [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.As.impl.Convert.3fd, @Core.FloatLiteral.as.As.impl.Convert(%int_16) [concrete] -// CHECK:STDOUT: %bound_method.8cf: = bound_method %float.c64, %Core.FloatLiteral.as.As.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.e12: = bound_method %float.96e, %Core.FloatLiteral.as.As.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.032: %f16.a6a = float_value 0.7998 [concrete] // CHECK:STDOUT: %ptr.823: type = ptr_type %f16.a6a [concrete] // CHECK:STDOUT: %foo__carbon_thunk.type: type = fn_type @foo__carbon_thunk [concrete] @@ -1764,12 +1764,12 @@ fn F() { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.cpp_overload_set.type = name_ref foo, imports.%foo.cpp_overload_set.value [concrete = constants.%foo.cpp_overload_set.value] -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 8e-1 [concrete = constants.%float.c64] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 8e-1 [concrete = constants.%float.96e] // CHECK:STDOUT: %f16: type = type_literal constants.%f16.a6a [concrete = constants.%f16.a6a] // CHECK:STDOUT: %impl.elem0.loc8_15.1: %.9fd = impl_witness_access constants.%As.impl_witness.0d1, element0 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.3fd] // CHECK:STDOUT: %bound_method.loc8_15.1: = bound_method %float, %impl.elem0.loc8_15.1 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.bound] // CHECK:STDOUT: %specific_fn.loc8_15.1: = specific_function %impl.elem0.loc8_15.1, @Core.FloatLiteral.as.As.impl.Convert(constants.%int_16) [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc8_15.2: = bound_method %float, %specific_fn.loc8_15.1 [concrete = constants.%bound_method.8cf] +// CHECK:STDOUT: %bound_method.loc8_15.2: = bound_method %float, %specific_fn.loc8_15.1 [concrete = constants.%bound_method.e12] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.call: init %f16.a6a = call %bound_method.loc8_15.2(%float) [concrete = constants.%float.032] // CHECK:STDOUT: %.loc8_15.1: %f16.a6a = value_of_initializer %Core.FloatLiteral.as.As.impl.Convert.call [concrete = constants.%float.032] // CHECK:STDOUT: %.loc8_15.2: %f16.a6a = converted %float, %.loc8_15.1 [concrete = constants.%float.032] @@ -1795,7 +1795,7 @@ fn F() { // CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] // CHECK:STDOUT: %foo.cpp_overload_set.type: type = cpp_overload_set_type @foo.cpp_overload_set [concrete] // CHECK:STDOUT: %foo.cpp_overload_set.value: %foo.cpp_overload_set.type = cpp_overload_set_value @foo.cpp_overload_set [concrete] -// CHECK:STDOUT: %float.c64: Core.FloatLiteral = float_literal_value 8e-1 [concrete] +// CHECK:STDOUT: %float.96e: Core.FloatLiteral = float_literal_value 8e-1 [concrete] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] // CHECK:STDOUT: %N: Core.IntLiteral = symbolic_binding N, 0 [symbolic] // CHECK:STDOUT: %f32.97e: type = class_type @Float, @Float(%int_32) [concrete] @@ -1808,9 +1808,9 @@ fn F() { // CHECK:STDOUT: %As.facet: %As.type.9fc = facet_value Core.FloatLiteral, (%As.impl_witness.748) [concrete] // CHECK:STDOUT: %As.WithSelf.Convert.type.85f: type = fn_type @As.WithSelf.Convert, @As.WithSelf(%f32.97e, %As.facet) [concrete] // CHECK:STDOUT: %.49e: type = fn_type_with_self_type %As.WithSelf.Convert.type.85f, %As.facet [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound: = bound_method %float.c64, %Core.FloatLiteral.as.As.impl.Convert.683 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound: = bound_method %float.96e, %Core.FloatLiteral.as.As.impl.Convert.683 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.As.impl.Convert.683, @Core.FloatLiteral.as.As.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.f4f: = bound_method %float.c64, %Core.FloatLiteral.as.As.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.5b6: = bound_method %float.96e, %Core.FloatLiteral.as.As.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.4cb: %f32.97e = float_value 0.800000011 [concrete] // CHECK:STDOUT: %ptr.0bc: type = ptr_type %f32.97e [concrete] // CHECK:STDOUT: %foo__carbon_thunk.type: type = fn_type @foo__carbon_thunk [concrete] @@ -1852,12 +1852,12 @@ fn F() { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.cpp_overload_set.type = name_ref foo, imports.%foo.cpp_overload_set.value [concrete = constants.%foo.cpp_overload_set.value] -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 8e-1 [concrete = constants.%float.c64] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 8e-1 [concrete = constants.%float.96e] // CHECK:STDOUT: %f32: type = type_literal constants.%f32.97e [concrete = constants.%f32.97e] // CHECK:STDOUT: %impl.elem0.loc8_15.1: %.49e = impl_witness_access constants.%As.impl_witness.748, element0 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.683] // CHECK:STDOUT: %bound_method.loc8_15.1: = bound_method %float, %impl.elem0.loc8_15.1 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.bound] // CHECK:STDOUT: %specific_fn.loc8_15.1: = specific_function %impl.elem0.loc8_15.1, @Core.FloatLiteral.as.As.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc8_15.2: = bound_method %float, %specific_fn.loc8_15.1 [concrete = constants.%bound_method.f4f] +// CHECK:STDOUT: %bound_method.loc8_15.2: = bound_method %float, %specific_fn.loc8_15.1 [concrete = constants.%bound_method.5b6] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.call: init %f32.97e = call %bound_method.loc8_15.2(%float) [concrete = constants.%float.4cb] // CHECK:STDOUT: %.loc8_15.1: %f32.97e = value_of_initializer %Core.FloatLiteral.as.As.impl.Convert.call [concrete = constants.%float.4cb] // CHECK:STDOUT: %.loc8_15.2: %f32.97e = converted %float, %.loc8_15.1 [concrete = constants.%float.4cb] @@ -1883,7 +1883,7 @@ fn F() { // CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] // CHECK:STDOUT: %foo.cpp_overload_set.type: type = cpp_overload_set_type @foo.cpp_overload_set [concrete] // CHECK:STDOUT: %foo.cpp_overload_set.value: %foo.cpp_overload_set.type = cpp_overload_set_value @foo.cpp_overload_set [concrete] -// CHECK:STDOUT: %float.c64: Core.FloatLiteral = float_literal_value 8e-1 [concrete] +// CHECK:STDOUT: %float.96e: Core.FloatLiteral = float_literal_value 8e-1 [concrete] // CHECK:STDOUT: %int_64: Core.IntLiteral = int_value 64 [concrete] // CHECK:STDOUT: %N: Core.IntLiteral = symbolic_binding N, 0 [symbolic] // CHECK:STDOUT: %f64.d77: type = class_type @Float, @Float(%int_64) [concrete] @@ -1896,9 +1896,9 @@ fn F() { // CHECK:STDOUT: %As.facet: %As.type.a57 = facet_value Core.FloatLiteral, (%As.impl_witness.187) [concrete] // CHECK:STDOUT: %As.WithSelf.Convert.type.dab: type = fn_type @As.WithSelf.Convert, @As.WithSelf(%f64.d77, %As.facet) [concrete] // CHECK:STDOUT: %.293: type = fn_type_with_self_type %As.WithSelf.Convert.type.dab, %As.facet [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound: = bound_method %float.c64, %Core.FloatLiteral.as.As.impl.Convert.4b9 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound: = bound_method %float.96e, %Core.FloatLiteral.as.As.impl.Convert.4b9 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.As.impl.Convert.4b9, @Core.FloatLiteral.as.As.impl.Convert(%int_64) [concrete] -// CHECK:STDOUT: %bound_method.083: = bound_method %float.c64, %Core.FloatLiteral.as.As.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.a40: = bound_method %float.96e, %Core.FloatLiteral.as.As.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.0fc: %f64.d77 = float_value 0.80000000000000004 [concrete] // CHECK:STDOUT: %ptr.bcc: type = ptr_type %f64.d77 [concrete] // CHECK:STDOUT: %foo__carbon_thunk.type: type = fn_type @foo__carbon_thunk [concrete] @@ -1940,12 +1940,12 @@ fn F() { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.cpp_overload_set.type = name_ref foo, imports.%foo.cpp_overload_set.value [concrete = constants.%foo.cpp_overload_set.value] -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 8e-1 [concrete = constants.%float.c64] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 8e-1 [concrete = constants.%float.96e] // CHECK:STDOUT: %f64: type = type_literal constants.%f64.d77 [concrete = constants.%f64.d77] // CHECK:STDOUT: %impl.elem0.loc8_15.1: %.293 = impl_witness_access constants.%As.impl_witness.187, element0 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.4b9] // CHECK:STDOUT: %bound_method.loc8_15.1: = bound_method %float, %impl.elem0.loc8_15.1 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.bound] // CHECK:STDOUT: %specific_fn.loc8_15.1: = specific_function %impl.elem0.loc8_15.1, @Core.FloatLiteral.as.As.impl.Convert(constants.%int_64) [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc8_15.2: = bound_method %float, %specific_fn.loc8_15.1 [concrete = constants.%bound_method.083] +// CHECK:STDOUT: %bound_method.loc8_15.2: = bound_method %float, %specific_fn.loc8_15.1 [concrete = constants.%bound_method.a40] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.call: init %f64.d77 = call %bound_method.loc8_15.2(%float) [concrete = constants.%float.0fc] // CHECK:STDOUT: %.loc8_15.1: %f64.d77 = value_of_initializer %Core.FloatLiteral.as.As.impl.Convert.call [concrete = constants.%float.0fc] // CHECK:STDOUT: %.loc8_15.2: %f64.d77 = converted %float, %.loc8_15.1 [concrete = constants.%float.0fc] @@ -1971,7 +1971,7 @@ fn F() { // CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] // CHECK:STDOUT: %foo.cpp_overload_set.type: type = cpp_overload_set_type @foo.cpp_overload_set [concrete] // CHECK:STDOUT: %foo.cpp_overload_set.value: %foo.cpp_overload_set.type = cpp_overload_set_value @foo.cpp_overload_set [concrete] -// CHECK:STDOUT: %float.c64: Core.FloatLiteral = float_literal_value 8e-1 [concrete] +// CHECK:STDOUT: %float.96e: Core.FloatLiteral = float_literal_value 8e-1 [concrete] // CHECK:STDOUT: %int_128: Core.IntLiteral = int_value 128 [concrete] // CHECK:STDOUT: %N: Core.IntLiteral = symbolic_binding N, 0 [symbolic] // CHECK:STDOUT: %f128.b8c: type = class_type @Float, @Float(%int_128) [concrete] @@ -1984,9 +1984,9 @@ fn F() { // CHECK:STDOUT: %As.facet: %As.type.6c6 = facet_value Core.FloatLiteral, (%As.impl_witness.738) [concrete] // CHECK:STDOUT: %As.WithSelf.Convert.type.c62: type = fn_type @As.WithSelf.Convert, @As.WithSelf(%f128.b8c, %As.facet) [concrete] // CHECK:STDOUT: %.d5b: type = fn_type_with_self_type %As.WithSelf.Convert.type.c62, %As.facet [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound: = bound_method %float.c64, %Core.FloatLiteral.as.As.impl.Convert.3b3 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.bound: = bound_method %float.96e, %Core.FloatLiteral.as.As.impl.Convert.3b3 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.As.impl.Convert.3b3, @Core.FloatLiteral.as.As.impl.Convert(%int_128) [concrete] -// CHECK:STDOUT: %bound_method.bae: = bound_method %float.c64, %Core.FloatLiteral.as.As.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.7eb: = bound_method %float.96e, %Core.FloatLiteral.as.As.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.709: %f128.b8c = float_value 0.800000000000000000000000000000000039 [concrete] // CHECK:STDOUT: %ptr.402: type = ptr_type %f128.b8c [concrete] // CHECK:STDOUT: %foo__carbon_thunk.type: type = fn_type @foo__carbon_thunk [concrete] @@ -2028,12 +2028,12 @@ fn F() { // CHECK:STDOUT: !entry: // CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.cpp_overload_set.type = name_ref foo, imports.%foo.cpp_overload_set.value [concrete = constants.%foo.cpp_overload_set.value] -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 8e-1 [concrete = constants.%float.c64] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 8e-1 [concrete = constants.%float.96e] // CHECK:STDOUT: %f128: type = type_literal constants.%f128.b8c [concrete = constants.%f128.b8c] // CHECK:STDOUT: %impl.elem0.loc8_15.1: %.d5b = impl_witness_access constants.%As.impl_witness.738, element0 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.3b3] // CHECK:STDOUT: %bound_method.loc8_15.1: = bound_method %float, %impl.elem0.loc8_15.1 [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.bound] // CHECK:STDOUT: %specific_fn.loc8_15.1: = specific_function %impl.elem0.loc8_15.1, @Core.FloatLiteral.as.As.impl.Convert(constants.%int_128) [concrete = constants.%Core.FloatLiteral.as.As.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc8_15.2: = bound_method %float, %specific_fn.loc8_15.1 [concrete = constants.%bound_method.bae] +// CHECK:STDOUT: %bound_method.loc8_15.2: = bound_method %float, %specific_fn.loc8_15.1 [concrete = constants.%bound_method.7eb] // CHECK:STDOUT: %Core.FloatLiteral.as.As.impl.Convert.call: init %f128.b8c = call %bound_method.loc8_15.2(%float) [concrete = constants.%float.709] // CHECK:STDOUT: %.loc8_15.1: %f128.b8c = value_of_initializer %Core.FloatLiteral.as.As.impl.Convert.call [concrete = constants.%float.709] // CHECK:STDOUT: %.loc8_15.2: %f128.b8c = converted %float, %.loc8_15.1 [concrete = constants.%float.709] diff --git a/toolchain/check/testdata/interop/cpp/function/overloads.carbon b/toolchain/check/testdata/interop/cpp/function/overloads.carbon index 9dfa8755164b..34954533d209 100644 --- a/toolchain/check/testdata/interop/cpp/function/overloads.carbon +++ b/toolchain/check/testdata/interop/cpp/function/overloads.carbon @@ -2060,7 +2060,7 @@ fn F() { // CHECK:STDOUT: %pattern_type.0ae: type = pattern_type %f64.d77 [concrete] // CHECK:STDOUT: %foo.cpp_overload_set.type: type = cpp_overload_set_type @foo.cpp_overload_set [concrete] // CHECK:STDOUT: %foo.cpp_overload_set.value: %foo.cpp_overload_set.type = cpp_overload_set_value @foo.cpp_overload_set [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %ptr.bcc: type = ptr_type %f64.d77 [concrete] // CHECK:STDOUT: %pattern_type.0ce: type = pattern_type %ptr.bcc [concrete] // CHECK:STDOUT: %foo__carbon_thunk.type: type = fn_type @foo__carbon_thunk [concrete] @@ -2077,9 +2077,9 @@ fn F() { // CHECK:STDOUT: %ImplicitAs.facet: %ImplicitAs.type.4a8 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.cb2) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.a33: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f64.d77, %ImplicitAs.facet) [concrete] // CHECK:STDOUT: %.6c5: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.a33, %ImplicitAs.facet [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_64) [concrete] -// CHECK:STDOUT: %bound_method.581: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.50c: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.d20: %f64.d77 = float_value 1 [concrete] // CHECK:STDOUT: %Copy.type: type = facet_type <@Copy> [concrete] // CHECK:STDOUT: %Float.as.Copy.impl.Op.type.2fe: type = fn_type @Float.as.Copy.impl.Op, @Float.as.Copy.impl(%N) [symbolic] @@ -2163,11 +2163,11 @@ fn F() { // CHECK:STDOUT: } // CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.cpp_overload_set.type = name_ref foo, imports.%foo.cpp_overload_set.value [concrete = constants.%foo.cpp_overload_set.value] -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %impl.elem0.loc7_31.1: %.6c5 = impl_witness_access constants.%ImplicitAs.impl_witness.cb2, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.239] // CHECK:STDOUT: %bound_method.loc7_31.1: = bound_method %float, %impl.elem0.loc7_31.1 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn.loc7_31.1: = specific_function %impl.elem0.loc7_31.1, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_64) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc7_31.2: = bound_method %float, %specific_fn.loc7_31.1 [concrete = constants.%bound_method.581] +// CHECK:STDOUT: %bound_method.loc7_31.2: = bound_method %float, %specific_fn.loc7_31.1 [concrete = constants.%bound_method.50c] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call: init %f64.d77 = call %bound_method.loc7_31.2(%float) [concrete = constants.%float.d20] // CHECK:STDOUT: %.loc7_31.1: %f64.d77 = value_of_initializer %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%float.d20] // CHECK:STDOUT: %.loc7_31.2: %f64.d77 = converted %float, %.loc7_31.1 [concrete = constants.%float.d20] diff --git a/toolchain/check/testdata/interop/cpp/macros.carbon b/toolchain/check/testdata/interop/cpp/macros.carbon index b363b5bdb80f..90b54a559adc 100644 --- a/toolchain/check/testdata/interop/cpp/macros.carbon +++ b/toolchain/check/testdata/interop/cpp/macros.carbon @@ -1084,9 +1084,9 @@ fn F() { // CHECK:STDOUT: %int_1.5b8: Core.IntLiteral = int_value 1 [concrete] // CHECK:STDOUT: %array_type: type = array_type %int_1.5b8, %f32.97e [concrete] // CHECK:STDOUT: %pattern_type.b36: type = pattern_type %array_type [concrete] -// CHECK:STDOUT: %float.674: Core.FloatLiteral = float_literal_value 10e-1 [concrete] +// CHECK:STDOUT: %float.6da: Core.FloatLiteral = float_literal_value 10e-1 [concrete] // CHECK:STDOUT: %tuple.type: type = tuple_type (Core.FloatLiteral) [concrete] -// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.674) [concrete] +// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%float.6da) [concrete] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete] // CHECK:STDOUT: %ImplicitAs.type.223: type = facet_type <@ImplicitAs, @ImplicitAs(%f32.97e)> [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.type.02f: type = fn_type @Core.FloatLiteral.as.ImplicitAs.impl.Convert, @Core.FloatLiteral.as.ImplicitAs.impl(%N) [symbolic] @@ -1097,10 +1097,10 @@ fn F() { // CHECK:STDOUT: %ImplicitAs.facet.945: %ImplicitAs.type.223 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.bc6) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.e4d: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f32.97e, %ImplicitAs.facet.945) [concrete] // CHECK:STDOUT: %.98d: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.e4d, %ImplicitAs.facet.945 [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55 [concrete] // CHECK:STDOUT: %pattern_type.201: type = pattern_type %f32.97e [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.1e4: = bound_method %float.674, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method.57d: = bound_method %float.6da, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.e3b: %f32.97e = float_value 1 [concrete] // CHECK:STDOUT: %array: %array_type = tuple_value (%float.e3b) [concrete] // CHECK:STDOUT: %Destroy.Op.type: type = fn_type @Destroy.Op [concrete] @@ -1133,12 +1133,12 @@ fn F() { // CHECK:STDOUT: %a.var_patt: %pattern_type.b36 = var_pattern %a.patt [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %a.var: ref %array_type = var %a.var_patt -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.674] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 10e-1 [concrete = constants.%float.6da] // CHECK:STDOUT: %.loc10_42.1: %tuple.type = tuple_literal (%float) [concrete = constants.%tuple] // CHECK:STDOUT: %impl.elem0.loc10_42: %.98d = impl_witness_access constants.%ImplicitAs.impl_witness.bc6, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.e55] // CHECK:STDOUT: %bound_method.loc10_42.1: = bound_method %float, %impl.elem0.loc10_42 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn.loc10_42: = specific_function %impl.elem0.loc10_42, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc10_42.2: = bound_method %float, %specific_fn.loc10_42 [concrete = constants.%bound_method.1e4] +// CHECK:STDOUT: %bound_method.loc10_42.2: = bound_method %float, %specific_fn.loc10_42 [concrete = constants.%bound_method.57d] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call: init %f32.97e = call %bound_method.loc10_42.2(%float) [concrete = constants.%float.e3b] // CHECK:STDOUT: %.loc10_42.2: init %f32.97e = converted %float, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%float.e3b] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0] diff --git a/toolchain/check/testdata/primitives/import_symbolic.carbon b/toolchain/check/testdata/primitives/import_symbolic.carbon index 3d4de6fbfed1..286e680067d4 100644 --- a/toolchain/check/testdata/primitives/import_symbolic.carbon +++ b/toolchain/check/testdata/primitives/import_symbolic.carbon @@ -405,7 +405,7 @@ fn F() -> u32 { // CHECK:STDOUT: %I.facet: %I.type = facet_value %C, (%I.impl_witness) [concrete] // CHECK:STDOUT: %I.assoc_type: type = assoc_entity_type @I [concrete] // CHECK:STDOUT: %assoc0.8b1: %I.assoc_type = assoc_entity element0, imports.%Main.import_ref.fec [concrete] -// CHECK:STDOUT: %float.3fedf4.2: Core.FloatLiteral = float_literal_value 1e-1 [concrete] +// CHECK:STDOUT: %float.d5ab3d.2: Core.FloatLiteral = float_literal_value 1e-1 [concrete] // CHECK:STDOUT: %Copy.type: type = facet_type <@Copy> [concrete] // CHECK:STDOUT: %Copy.impl_witness.ba9: = impl_witness imports.%Copy.impl_witness_table.65a [concrete] // CHECK:STDOUT: %Copy.facet: %Copy.type = facet_value Core.FloatLiteral, (%Copy.impl_witness.ba9) [concrete] @@ -413,15 +413,15 @@ fn F() -> u32 { // CHECK:STDOUT: %.91c: type = fn_type_with_self_type %Copy.WithSelf.Op.type.582, %Copy.facet [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.Copy.impl.Op.type: type = fn_type @Core.FloatLiteral.as.Copy.impl.Op [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.Copy.impl.Op: %Core.FloatLiteral.as.Copy.impl.Op.type = struct_value () [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.Copy.impl.Op.bound: = bound_method %float.3fedf4.2, %Core.FloatLiteral.as.Copy.impl.Op [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.Copy.impl.Op.bound: = bound_method %float.d5ab3d.2, %Core.FloatLiteral.as.Copy.impl.Op [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { // CHECK:STDOUT: %Main.I: type = import_ref Main//float_literal, I, loaded [concrete = constants.%I.type] // CHECK:STDOUT: %Main.C: type = import_ref Main//float_literal, C, loaded [concrete = constants.%C] // CHECK:STDOUT: %Main.import_ref.c2c: %I.assoc_type = import_ref Main//float_literal, loc5_12, loaded [concrete = constants.%assoc0.8b1] -// CHECK:STDOUT: %Main.import_ref.dec: Core.FloatLiteral = import_ref Main//float_literal, loc10_32, loaded [concrete = constants.%float.3fedf4.2] -// CHECK:STDOUT: %I.impl_witness_table = impl_witness_table (%Main.import_ref.dec), @C.as.I.impl [concrete] +// CHECK:STDOUT: %Main.import_ref.78a: Core.FloatLiteral = import_ref Main//float_literal, loc10_32, loaded [concrete = constants.%float.d5ab3d.2] +// CHECK:STDOUT: %I.impl_witness_table = impl_witness_table (%Main.import_ref.78a), @C.as.I.impl [concrete] // CHECK:STDOUT: %Main.import_ref.fec: Core.FloatLiteral = import_ref Main//float_literal, loc5_12, loaded [concrete = %value] // CHECK:STDOUT: %value: Core.FloatLiteral = assoc_const_decl @value [concrete] {} // CHECK:STDOUT: %Core.import_ref.3f0: %Core.FloatLiteral.as.Copy.impl.Op.type = import_ref Core//prelude/copy, loc{{\d+_\d+}}, loaded [concrete = constants.%Core.FloatLiteral.as.Copy.impl.Op] @@ -437,10 +437,10 @@ fn F() -> u32 { // CHECK:STDOUT: %as_type: type = facet_access_type %.loc7_13 [concrete = constants.%C] // CHECK:STDOUT: %.loc7_18: type = converted %.loc7_13, %as_type [concrete = constants.%C] // CHECK:STDOUT: %value.ref: %I.assoc_type = name_ref value, imports.%Main.import_ref.c2c [concrete = constants.%assoc0.8b1] -// CHECK:STDOUT: %impl.elem0.loc7_18.1: Core.FloatLiteral = impl_witness_access constants.%I.impl_witness, element0 [concrete = constants.%float.3fedf4.2] +// CHECK:STDOUT: %impl.elem0.loc7_18.1: Core.FloatLiteral = impl_witness_access constants.%I.impl_witness, element0 [concrete = constants.%float.d5ab3d.2] // CHECK:STDOUT: %impl.elem0.loc7_18.2: %.91c = impl_witness_access constants.%Copy.impl_witness.ba9, element0 [concrete = constants.%Core.FloatLiteral.as.Copy.impl.Op] // CHECK:STDOUT: %bound_method: = bound_method %impl.elem0.loc7_18.1, %impl.elem0.loc7_18.2 [concrete = constants.%Core.FloatLiteral.as.Copy.impl.Op.bound] -// CHECK:STDOUT: %Core.FloatLiteral.as.Copy.impl.Op.call: init Core.FloatLiteral = call %bound_method(%impl.elem0.loc7_18.1) [concrete = constants.%float.3fedf4.2] +// CHECK:STDOUT: %Core.FloatLiteral.as.Copy.impl.Op.call: init Core.FloatLiteral = call %bound_method(%impl.elem0.loc7_18.1) [concrete = constants.%float.d5ab3d.2] // CHECK:STDOUT: return %Core.FloatLiteral.as.Copy.impl.Op.call // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/primitives/numeric_literals.carbon b/toolchain/check/testdata/primitives/numeric_literals.carbon index fe47350f8bde..a58967c276c5 100644 --- a/toolchain/check/testdata/primitives/numeric_literals.carbon +++ b/toolchain/check/testdata/primitives/numeric_literals.carbon @@ -139,12 +139,12 @@ let e: f64 = 5.0e39999999999999999993; // CHECK:STDOUT: %int_8.b85: Core.IntLiteral = int_value 8 [concrete] // CHECK:STDOUT: %int_9.988: Core.IntLiteral = int_value 9 [concrete] // CHECK:STDOUT: %int_2147483647.d89: Core.IntLiteral = int_value 2147483647 [concrete] -// CHECK:STDOUT: %float.7d0: Core.FloatLiteral = float_literal_value 9e-1 [concrete] -// CHECK:STDOUT: %float.4bc: Core.FloatLiteral = float_literal_value 80e-1 [concrete] -// CHECK:STDOUT: %float.24e: Core.FloatLiteral = float_literal_value 800e-1 [concrete] -// CHECK:STDOUT: %float.4d9: Core.FloatLiteral = float_literal_value 10e6 [concrete] -// CHECK:STDOUT: %float.150: Core.FloatLiteral = float_literal_value 10e7 [concrete] -// CHECK:STDOUT: %float.07e: Core.FloatLiteral = float_literal_value 10e-9 [concrete] +// CHECK:STDOUT: %float.b06: Core.FloatLiteral = float_literal_value 9e-1 [concrete] +// CHECK:STDOUT: %float.025: Core.FloatLiteral = float_literal_value 80e-1 [concrete] +// CHECK:STDOUT: %float.3b0: Core.FloatLiteral = float_literal_value 800e-1 [concrete] +// CHECK:STDOUT: %float.d22: Core.FloatLiteral = float_literal_value 10e6 [concrete] +// CHECK:STDOUT: %float.8d2: Core.FloatLiteral = float_literal_value 10e7 [concrete] +// CHECK:STDOUT: %float.48b: Core.FloatLiteral = float_literal_value 10e-9 [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { @@ -157,12 +157,12 @@ let e: f64 = 5.0e39999999999999999993; // CHECK:STDOUT: %int_2147483647.loc13: Core.IntLiteral = int_value 2147483647 [concrete = constants.%int_2147483647.d89] // CHECK:STDOUT: %int_2147483647.loc14: Core.IntLiteral = int_value 2147483647 [concrete = constants.%int_2147483647.d89] // CHECK:STDOUT: -// CHECK:STDOUT: %float.loc19: Core.FloatLiteral = float_literal_value 9e-1 [concrete = constants.%float.7d0] -// CHECK:STDOUT: %float.loc20: Core.FloatLiteral = float_literal_value 80e-1 [concrete = constants.%float.4bc] -// CHECK:STDOUT: %float.loc21: Core.FloatLiteral = float_literal_value 800e-1 [concrete = constants.%float.24e] -// CHECK:STDOUT: %float.loc22: Core.FloatLiteral = float_literal_value 10e6 [concrete = constants.%float.4d9] -// CHECK:STDOUT: %float.loc23: Core.FloatLiteral = float_literal_value 10e7 [concrete = constants.%float.150] -// CHECK:STDOUT: %float.loc24: Core.FloatLiteral = float_literal_value 10e-9 [concrete = constants.%float.07e] +// CHECK:STDOUT: %float.loc19: Core.FloatLiteral = float_literal_value 9e-1 [concrete = constants.%float.b06] +// CHECK:STDOUT: %float.loc20: Core.FloatLiteral = float_literal_value 80e-1 [concrete = constants.%float.025] +// CHECK:STDOUT: %float.loc21: Core.FloatLiteral = float_literal_value 800e-1 [concrete = constants.%float.3b0] +// CHECK:STDOUT: %float.loc22: Core.FloatLiteral = float_literal_value 10e6 [concrete = constants.%float.d22] +// CHECK:STDOUT: %float.loc23: Core.FloatLiteral = float_literal_value 10e7 [concrete = constants.%float.8d2] +// CHECK:STDOUT: %float.loc24: Core.FloatLiteral = float_literal_value 10e-9 [concrete = constants.%float.48b] // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/struct/fail_member_access_type.carbon b/toolchain/check/testdata/struct/fail_member_access_type.carbon index 11cc05a8f912..1fc8dbc12c69 100644 --- a/toolchain/check/testdata/struct/fail_member_access_type.carbon +++ b/toolchain/check/testdata/struct/fail_member_access_type.carbon @@ -28,9 +28,9 @@ var y: i32 = x.b; // CHECK:STDOUT: %f64.d77: type = class_type @Float, @Float(%int_64) [concrete] // CHECK:STDOUT: %struct_type.a.5e8: type = struct_type {.a: %f64.d77} [concrete] // CHECK:STDOUT: %pattern_type.8ce: type = pattern_type %struct_type.a.5e8 [concrete] -// CHECK:STDOUT: %float.126: Core.FloatLiteral = float_literal_value 40e-1 [concrete] +// CHECK:STDOUT: %float.a4e: Core.FloatLiteral = float_literal_value 40e-1 [concrete] // CHECK:STDOUT: %struct_type.a.b4b: type = struct_type {.a: Core.FloatLiteral} [concrete] -// CHECK:STDOUT: %struct.ea2: %struct_type.a.b4b = struct_value (%float.126) [concrete] +// CHECK:STDOUT: %struct.f91: %struct_type.a.b4b = struct_value (%float.a4e) [concrete] // CHECK:STDOUT: %ImplicitAs.type.cc7: type = generic_interface_type @ImplicitAs [concrete] // CHECK:STDOUT: %ImplicitAs.generic: %ImplicitAs.type.cc7 = struct_value () [concrete] // CHECK:STDOUT: %ImplicitAs.type.4a8: type = facet_type <@ImplicitAs, @ImplicitAs(%f64.d77)> [concrete] @@ -43,9 +43,9 @@ var y: i32 = x.b; // CHECK:STDOUT: %ImplicitAs.facet: %ImplicitAs.type.4a8 = facet_value Core.FloatLiteral, (%ImplicitAs.impl_witness.cb2) [concrete] // CHECK:STDOUT: %ImplicitAs.WithSelf.Convert.type.a33: type = fn_type @ImplicitAs.WithSelf.Convert, @ImplicitAs.WithSelf(%f64.d77, %ImplicitAs.facet) [concrete] // CHECK:STDOUT: %.6c5: type = fn_type_with_self_type %ImplicitAs.WithSelf.Convert.type.a33, %ImplicitAs.facet [concrete] -// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.126, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] +// CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %float.a4e, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239 [concrete] // CHECK:STDOUT: %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.FloatLiteral.as.ImplicitAs.impl.Convert.239, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(%int_64) [concrete] -// CHECK:STDOUT: %bound_method: = bound_method %float.126, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] +// CHECK:STDOUT: %bound_method: = bound_method %float.a4e, %Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] // CHECK:STDOUT: %float.d15: %f64.d77 = float_value 4 [concrete] // CHECK:STDOUT: %struct.d6a: %struct_type.a.5e8 = struct_value (%float.d15) [concrete] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] @@ -98,8 +98,8 @@ var y: i32 = x.b; // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 40e-1 [concrete = constants.%float.126] -// CHECK:STDOUT: %.loc15_29.1: %struct_type.a.b4b = struct_literal (%float) [concrete = constants.%struct.ea2] +// CHECK:STDOUT: %float: Core.FloatLiteral = float_literal_value 40e-1 [concrete = constants.%float.a4e] +// CHECK:STDOUT: %.loc15_29.1: %struct_type.a.b4b = struct_literal (%float) [concrete = constants.%struct.f91] // CHECK:STDOUT: %impl.elem0: %.6c5 = impl_witness_access constants.%ImplicitAs.impl_witness.cb2, element0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.239] // CHECK:STDOUT: %bound_method.loc15_29.1: = bound_method %float, %impl.elem0 [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.bound] // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Core.FloatLiteral.as.ImplicitAs.impl.Convert(constants.%int_64) [concrete = constants.%Core.FloatLiteral.as.ImplicitAs.impl.Convert.specific_fn] diff --git a/toolchain/lex/BUILD b/toolchain/lex/BUILD index a8f8e57ce6b4..10534f5a4e8f 100644 --- a/toolchain/lex/BUILD +++ b/toolchain/lex/BUILD @@ -73,6 +73,7 @@ cc_library( ":character_set", ":helpers", "//common:check", + "//toolchain/base:int", "//toolchain/diagnostics:emitter", "//toolchain/diagnostics:format_providers", "@llvm-project//llvm:Support", diff --git a/toolchain/lex/helpers.cpp b/toolchain/lex/helpers.cpp index eefe41c63cad..6063679b0aae 100644 --- a/toolchain/lex/helpers.cpp +++ b/toolchain/lex/helpers.cpp @@ -8,15 +8,13 @@ namespace Carbon::Lex { auto CanLexInt(Diagnostics::Emitter& emitter, llvm::StringRef text) -> bool { - // llvm::getAsInteger is used for parsing, but it's quadratic and visibly slow - // on large integer values. This limit exists to avoid hitting those limits. - // Per https://github.com/carbon-language/carbon-lang/issues/980, it may be - // feasible to optimize integer parsing in order to address performance if - // this limit becomes an issue. + // Integer parsing has poor scaling characteristics for extremely large digit + // amounts. We've done some performance work on this, but this limit exists to + // avoid really extreme cases. // // 2^128 would be 39 decimal digits or 128 binary. In either case, this limit // is far above the threshold for normal ints. - constexpr size_t DigitLimit = 1000; + constexpr size_t DigitLimit = 10000; if (text.size() > DigitLimit) { CARBON_DIAGNOSTIC( TooManyDigits, Error, diff --git a/toolchain/lex/numeric_literal.cpp b/toolchain/lex/numeric_literal.cpp index a5b0828603b2..df3d44eb8477 100644 --- a/toolchain/lex/numeric_literal.cpp +++ b/toolchain/lex/numeric_literal.cpp @@ -12,6 +12,7 @@ #include "common/check.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Support/FormatVariadicDetails.h" +#include "toolchain/base/int.h" #include "toolchain/diagnostics/format_providers.h" #include "toolchain/lex/character_set.h" #include "toolchain/lex/helpers.h" @@ -176,6 +177,93 @@ auto NumericLiteral::Parser::Check() -> bool { CheckExponentPart(); } +// Parses a binary integer literal. +static auto ParseBinary(llvm::StringRef digits) -> llvm::APInt { + llvm::APInt value(std::max(IntStore::MinAPWidth, digits.size()), 0); + int cursor = digits.size() - 1; + for (char c : digits) { + if (c == '1') { + value.setBit(cursor); + } + --cursor; + } + return value; +} + +// Parses a hexadecimal integer literal. +static auto ParseHexadecimal(llvm::StringRef digits) -> llvm::APInt { + llvm::APInt value(std::max(IntStore::MinAPWidth, digits.size() * 4), 0); + int cursor = digits.size() * 4 - 1; + for (char c : digits) { + uint8_t digit = c <= '9' ? (c - '0') : (c - 'A' + 10); + if (digit & 0x8) { + value.setBit(cursor); + } + --cursor; + if (digit & 0x4) { + value.setBit(cursor); + } + --cursor; + if (digit & 0x2) { + value.setBit(cursor); + } + --cursor; + if (digit & 0x1) { + value.setBit(cursor); + } + --cursor; + } + return value; +} + +// Parses a single chunk of up to 19 decimal digits. +static auto ParseDecimalChunk(llvm::StringRef digits) -> uint64_t { + uint64_t chunk_val = 0; + for (char c : digits) { + chunk_val = chunk_val * 10 + (c - '0'); + } + return chunk_val; +} + +// Parsing decimals is complex because they're not a power of 2. We process it +// 19 digits at a time because that's the most that fit into uint64_t, which +// is APInt's internal unit for storage; chunking this way minimizes +// cross-unit arithmetic. +static auto ParseDecimal(llvm::StringRef digits) -> llvm::APInt { + // APInt performance scales based on the number of bits, so be precise. + // TODO: Check if this can be `constexpr` when C++26 is in use. + static const double bits_per_digit = std::log2(10); + llvm::APInt value(std::max(IntStore::MinAPWidth, + std::ceil(digits.size() * bits_per_digit)), + 0); + static constexpr int DigitsPerChunk = 19; + + // If there's only a few digits, we don't need the multiplication logic. + if (digits.size() <= DigitsPerChunk) { + value = ParseDecimalChunk(digits); + return value; + } + + // For the first chunk, we set it up so that all remaining chunks will + // cause equivalent multiplications when adding in. This lets us only + // compute the multiplier once. + int first_chunk_size = digits.size() % DigitsPerChunk; + if (first_chunk_size == 0) { + first_chunk_size = DigitsPerChunk; + } + value = ParseDecimalChunk(digits.take_front(first_chunk_size)); + digits = digits.drop_front(first_chunk_size); + + // For each remaining chunk, multiply the value by 10^19 and add the + // chunk value. + static constexpr uint64_t Mult = 10'000'000'000'000'000'000ULL; + for (; !digits.empty(); digits = digits.drop_front(DigitsPerChunk)) { + value *= Mult; + value += ParseDecimalChunk(digits.take_front(DigitsPerChunk)); + } + return value; +} + // Parse a string that is known to be a valid base-radix integer into an // APInt. If needs_cleaning is true, the string may additionally contain '_' // and '.' characters that should be ignored. @@ -194,11 +282,18 @@ static auto ParseInt(llvm::StringRef digits, NumericLiteral::Radix radix, digits = cleaned; } - llvm::APInt value; - if (digits.getAsInteger(static_cast(radix), value)) { - llvm_unreachable("should never fail"); + digits = digits.ltrim('0'); + + // We don't use LLVM's `getAsInteger` because it has poor performance. + // Instead, we implement our own. + switch (radix) { + case NumericLiteral::Radix::Binary: + return ParseBinary(digits); + case NumericLiteral::Radix::Decimal: + return ParseDecimal(digits); + case NumericLiteral::Radix::Hexadecimal: + return ParseHexadecimal(digits); } - return value; } auto NumericLiteral::Parser::GetMantissa() -> llvm::APInt { diff --git a/toolchain/lex/numeric_literal_benchmark.cpp b/toolchain/lex/numeric_literal_benchmark.cpp index 1c76d3529846..427d39ad5bd2 100644 --- a/toolchain/lex/numeric_literal_benchmark.cpp +++ b/toolchain/lex/numeric_literal_benchmark.cpp @@ -4,6 +4,8 @@ #include +#include + #include "common/check.h" #include "toolchain/diagnostics/null_diagnostics.h" #include "toolchain/lex/numeric_literal.h" @@ -11,6 +13,20 @@ namespace Carbon::Lex { namespace { +// Returns an integer literal string with `prefix` followed by `num_digits` +// entries from `digits` (repeating `digits` as necessary). +static auto MakeIntString(llvm::StringLiteral prefix, + llvm::StringLiteral digits, size_t num_digits) + -> std::string { + std::string s; + s.reserve(prefix.size() + num_digits); + s.append(prefix); + for (size_t i = 0; i < num_digits; i += digits.size()) { + s.append(digits.take_front(std::min(digits.size(), num_digits - i))); + } + return s; +} + static void BM_Lex_Float(benchmark::State& state) { for (auto _ : state) { CARBON_CHECK(NumericLiteral::Lex("0.000001", true)); @@ -23,6 +39,13 @@ static void BM_Lex_Int(benchmark::State& state) { } } +static void BM_Lex_IntDecimalN(benchmark::State& state) { + std::string s = MakeIntString("", "1234567890", state.range(0)); + for (auto _ : state) { + CARBON_CHECK(NumericLiteral::Lex(s, true)); + } +} + static void BM_ComputeValue_Float(benchmark::State& state) { auto val = NumericLiteral::Lex("0.000001", true); CARBON_CHECK(val); @@ -41,10 +64,45 @@ static void BM_ComputeValue_Int(benchmark::State& state) { } } +static void BM_ComputeValue_IntDecimalN(benchmark::State& state) { + std::string s = MakeIntString("", "1234567890", state.range(0)); + auto val = NumericLiteral::Lex(s, true); + auto& emitter = Diagnostics::NullEmitter(); + CARBON_CHECK(val); + for (auto _ : state) { + val->ComputeValue(emitter); + } +} + +static void BM_ComputeValue_IntBinaryN(benchmark::State& state) { + std::string s = MakeIntString("0b", "10", state.range(0)); + auto val = NumericLiteral::Lex(s, true); + auto& emitter = Diagnostics::NullEmitter(); + CARBON_CHECK(val); + for (auto _ : state) { + val->ComputeValue(emitter); + } +} + +static void BM_ComputeValue_IntHexN(benchmark::State& state) { + // 0 is in the middle so that it isn't truncated in parse. + std::string s = MakeIntString("0x", "1234567890ABCDEF", state.range(0)); + auto val = NumericLiteral::Lex(s, true); + auto& emitter = Diagnostics::NullEmitter(); + CARBON_CHECK(val); + for (auto _ : state) { + val->ComputeValue(emitter); + } +} + BENCHMARK(BM_Lex_Float); BENCHMARK(BM_Lex_Int); +BENCHMARK(BM_Lex_IntDecimalN)->RangeMultiplier(10)->Range(1, 10000); BENCHMARK(BM_ComputeValue_Float); BENCHMARK(BM_ComputeValue_Int); +BENCHMARK(BM_ComputeValue_IntDecimalN)->RangeMultiplier(10)->Range(1, 10000); +BENCHMARK(BM_ComputeValue_IntBinaryN)->RangeMultiplier(10)->Range(1, 10000); +BENCHMARK(BM_ComputeValue_IntHexN)->RangeMultiplier(10)->Range(1, 10000); } // namespace } // namespace Carbon::Lex diff --git a/toolchain/lex/numeric_literal_test.cpp b/toolchain/lex/numeric_literal_test.cpp index 94f0fd8d5536..c0ccab572087 100644 --- a/toolchain/lex/numeric_literal_test.cpp +++ b/toolchain/lex/numeric_literal_test.cpp @@ -366,7 +366,7 @@ TEST_F(NumericLiteralTest, ValidatesRealLiterals) { } TEST_F(NumericLiteralTest, TooManyDigits) { - std::string long_number(2000, '1'); + std::string long_number(20000, '1'); EXPECT_THAT(Parse(long_number), HasUnrecoverableError()); EXPECT_TRUE(error_tracker.seen_error()); } diff --git a/toolchain/lex/testdata/numeric_literals.carbon b/toolchain/lex/testdata/numeric_literals.carbon index db92d8ee60a1..95e59569acb7 100644 --- a/toolchain/lex/testdata/numeric_literals.carbon +++ b/toolchain/lex/testdata/numeric_literals.carbon @@ -18,10 +18,10 @@ fn F() { // CHECK:STDOUT: - { index: 2, kind: "Identifier", line: {{ *}}[[@LINE-2]], column: 4, indent: 1, spelling: "F", identifier: 0, has_leading_space: true } // CHECK:STDOUT: - { index: 3, kind: "OpenParen", line: {{ *}}[[@LINE-3]], column: 5, indent: 1, spelling: "(", closing_token: 4 } // CHECK:STDOUT: - { index: 4, kind: "CloseParen", line: {{ *}}[[@LINE-4]], column: 6, indent: 1, spelling: ")", opening_token: 3 } -// CHECK:STDOUT: - { index: 5, kind: "OpenCurlyBrace", line: {{ *}}[[@LINE-5]], column: 8, indent: 1, spelling: "{", closing_token: 56, has_leading_space: true } +// CHECK:STDOUT: - { index: 5, kind: "OpenCurlyBrace", line: {{ *}}[[@LINE-5]], column: 8, indent: 1, spelling: "{", closing_token: 58, has_leading_space: true } // 8 and 9 trigger special behavior in APInt when mishandling signed versus // unsigned, so we pay extra attention to those. - var ints: array(i32, 5) = ( + var ints: array(i32, 6) = ( // CHECK:STDOUT: - { index: 6, kind: "Var", line: {{ *}}[[@LINE-1]], column: 3, indent: 3, spelling: "var", has_leading_space: true } // CHECK:STDOUT: - { index: 7, kind: "Identifier", line: {{ *}}[[@LINE-2]], column: 7, indent: 3, spelling: "ints", identifier: 1, has_leading_space: true } // CHECK:STDOUT: - { index: 8, kind: "Colon", line: {{ *}}[[@LINE-3]], column: 11, indent: 3, spelling: ":" } @@ -29,10 +29,10 @@ fn F() { // CHECK:STDOUT: - { index: 10, kind: "OpenParen", line: {{ *}}[[@LINE-5]], column: 18, indent: 3, spelling: "(", closing_token: 14 } // CHECK:STDOUT: - { index: 11, kind: "IntTypeLiteral", line: {{ *}}[[@LINE-6]], column: 19, indent: 3, spelling: "i32" } // CHECK:STDOUT: - { index: 12, kind: "Comma", line: {{ *}}[[@LINE-7]], column: 22, indent: 3, spelling: "," } - // CHECK:STDOUT: - { index: 13, kind: "IntLiteral", line: {{ *}}[[@LINE-8]], column: 24, indent: 3, spelling: "5", value: "5", has_leading_space: true } + // CHECK:STDOUT: - { index: 13, kind: "IntLiteral", line: {{ *}}[[@LINE-8]], column: 24, indent: 3, spelling: "6", value: "6", has_leading_space: true } // CHECK:STDOUT: - { index: 14, kind: "CloseParen", line: {{ *}}[[@LINE-9]], column: 25, indent: 3, spelling: ")", opening_token: 10 } // CHECK:STDOUT: - { index: 15, kind: "Equal", line: {{ *}}[[@LINE-10]], column: 27, indent: 3, spelling: "=", has_leading_space: true } - // CHECK:STDOUT: - { index: 16, kind: "OpenParen", line: {{ *}}[[@LINE-11]], column: 29, indent: 3, spelling: "(", closing_token: 27, has_leading_space: true } + // CHECK:STDOUT: - { index: 16, kind: "OpenParen", line: {{ *}}[[@LINE-11]], column: 29, indent: 3, spelling: "(", closing_token: 29, has_leading_space: true } 8, // CHECK:STDOUT: - { index: 17, kind: "IntLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "8", value: "8", has_leading_space: true } // CHECK:STDOUT: - { index: 18, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 6, indent: 5, spelling: "," } @@ -48,47 +48,50 @@ fn F() { 39999999999999999993, // CHECK:STDOUT: - { index: 25, kind: "IntLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "39999999999999999993", value: "39999999999999999993", has_leading_space: true } // CHECK:STDOUT: - { index: 26, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 25, indent: 5, spelling: "," } + 12345678901234567890123456789012345678901234567890123456789, + // CHECK:STDOUT: - { index: 27, kind: "IntLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "12345678901234567890123456789012345678901234567890123456789", value: "12345678901234567890123456789012345678901234567890123456789", has_leading_space: true } + // CHECK:STDOUT: - { index: 28, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 64, indent: 5, spelling: "," } ); - // CHECK:STDOUT: - { index: 27, kind: "CloseParen", line: {{ *}}[[@LINE-1]], column: 3, indent: 3, spelling: ")", opening_token: 16, has_leading_space: true } - // CHECK:STDOUT: - { index: 28, kind: "Semi", line: {{ *}}[[@LINE-2]], column: 4, indent: 3, spelling: ";" } + // CHECK:STDOUT: - { index: 29, kind: "CloseParen", line: {{ *}}[[@LINE-1]], column: 3, indent: 3, spelling: ")", opening_token: 16, has_leading_space: true } + // CHECK:STDOUT: - { index: 30, kind: "Semi", line: {{ *}}[[@LINE-2]], column: 4, indent: 3, spelling: ";" } var floats: array(f64, 7) = ( - // CHECK:STDOUT: - { index: 29, kind: "Var", line: {{ *}}[[@LINE-1]], column: 3, indent: 3, spelling: "var", has_leading_space: true } - // CHECK:STDOUT: - { index: 30, kind: "Identifier", line: {{ *}}[[@LINE-2]], column: 7, indent: 3, spelling: "floats", identifier: 2, has_leading_space: true } - // CHECK:STDOUT: - { index: 31, kind: "Colon", line: {{ *}}[[@LINE-3]], column: 13, indent: 3, spelling: ":" } - // CHECK:STDOUT: - { index: 32, kind: "Array", line: {{ *}}[[@LINE-4]], column: 15, indent: 3, spelling: "array", has_leading_space: true } - // CHECK:STDOUT: - { index: 33, kind: "OpenParen", line: {{ *}}[[@LINE-5]], column: 20, indent: 3, spelling: "(", closing_token: 37 } - // CHECK:STDOUT: - { index: 34, kind: "FloatTypeLiteral", line: {{ *}}[[@LINE-6]], column: 21, indent: 3, spelling: "f64" } - // CHECK:STDOUT: - { index: 35, kind: "Comma", line: {{ *}}[[@LINE-7]], column: 24, indent: 3, spelling: "," } - // CHECK:STDOUT: - { index: 36, kind: "IntLiteral", line: {{ *}}[[@LINE-8]], column: 26, indent: 3, spelling: "7", value: "7", has_leading_space: true } - // CHECK:STDOUT: - { index: 37, kind: "CloseParen", line: {{ *}}[[@LINE-9]], column: 27, indent: 3, spelling: ")", opening_token: 33 } - // CHECK:STDOUT: - { index: 38, kind: "Equal", line: {{ *}}[[@LINE-10]], column: 29, indent: 3, spelling: "=", has_leading_space: true } - // CHECK:STDOUT: - { index: 39, kind: "OpenParen", line: {{ *}}[[@LINE-11]], column: 31, indent: 3, spelling: "(", closing_token: 54, has_leading_space: true } + // CHECK:STDOUT: - { index: 31, kind: "Var", line: {{ *}}[[@LINE-1]], column: 3, indent: 3, spelling: "var", has_leading_space: true } + // CHECK:STDOUT: - { index: 32, kind: "Identifier", line: {{ *}}[[@LINE-2]], column: 7, indent: 3, spelling: "floats", identifier: 2, has_leading_space: true } + // CHECK:STDOUT: - { index: 33, kind: "Colon", line: {{ *}}[[@LINE-3]], column: 13, indent: 3, spelling: ":" } + // CHECK:STDOUT: - { index: 34, kind: "Array", line: {{ *}}[[@LINE-4]], column: 15, indent: 3, spelling: "array", has_leading_space: true } + // CHECK:STDOUT: - { index: 35, kind: "OpenParen", line: {{ *}}[[@LINE-5]], column: 20, indent: 3, spelling: "(", closing_token: 39 } + // CHECK:STDOUT: - { index: 36, kind: "FloatTypeLiteral", line: {{ *}}[[@LINE-6]], column: 21, indent: 3, spelling: "f64" } + // CHECK:STDOUT: - { index: 37, kind: "Comma", line: {{ *}}[[@LINE-7]], column: 24, indent: 3, spelling: "," } + // CHECK:STDOUT: - { index: 38, kind: "IntLiteral", line: {{ *}}[[@LINE-8]], column: 26, indent: 3, spelling: "7", value: "7", has_leading_space: true } + // CHECK:STDOUT: - { index: 39, kind: "CloseParen", line: {{ *}}[[@LINE-9]], column: 27, indent: 3, spelling: ")", opening_token: 35 } + // CHECK:STDOUT: - { index: 40, kind: "Equal", line: {{ *}}[[@LINE-10]], column: 29, indent: 3, spelling: "=", has_leading_space: true } + // CHECK:STDOUT: - { index: 41, kind: "OpenParen", line: {{ *}}[[@LINE-11]], column: 31, indent: 3, spelling: "(", closing_token: 56, has_leading_space: true } 0.9, - // CHECK:STDOUT: - { index: 40, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "0.9", value: "9*10^-1", has_leading_space: true } - // CHECK:STDOUT: - { index: 41, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 8, indent: 5, spelling: "," } - 8.0, - // CHECK:STDOUT: - { index: 42, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "8.0", value: "80*10^-1", has_leading_space: true } + // CHECK:STDOUT: - { index: 42, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "0.9", value: "9*10^-1", has_leading_space: true } // CHECK:STDOUT: - { index: 43, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 8, indent: 5, spelling: "," } + 8.0, + // CHECK:STDOUT: - { index: 44, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "8.0", value: "80*10^-1", has_leading_space: true } + // CHECK:STDOUT: - { index: 45, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 8, indent: 5, spelling: "," } 80.0, - // CHECK:STDOUT: - { index: 44, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "80.0", value: "800*10^-1", has_leading_space: true } - // CHECK:STDOUT: - { index: 45, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 9, indent: 5, spelling: "," } + // CHECK:STDOUT: - { index: 46, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "80.0", value: "800*10^-1", has_leading_space: true } + // CHECK:STDOUT: - { index: 47, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 9, indent: 5, spelling: "," } 1.0e7, - // CHECK:STDOUT: - { index: 46, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "1.0e7", value: "10*10^6", has_leading_space: true } - // CHECK:STDOUT: - { index: 47, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 10, indent: 5, spelling: "," } - 1.0e8, - // CHECK:STDOUT: - { index: 48, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "1.0e8", value: "10*10^7", has_leading_space: true } + // CHECK:STDOUT: - { index: 48, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "1.0e7", value: "10*10^6", has_leading_space: true } // CHECK:STDOUT: - { index: 49, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 10, indent: 5, spelling: "," } + 1.0e8, + // CHECK:STDOUT: - { index: 50, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "1.0e8", value: "10*10^7", has_leading_space: true } + // CHECK:STDOUT: - { index: 51, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 10, indent: 5, spelling: "," } 1.0e-8, - // CHECK:STDOUT: - { index: 50, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "1.0e-8", value: "10*10^-9", has_leading_space: true } - // CHECK:STDOUT: - { index: 51, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 11, indent: 5, spelling: "," } + // CHECK:STDOUT: - { index: 52, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "1.0e-8", value: "10*10^-9", has_leading_space: true } + // CHECK:STDOUT: - { index: 53, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 11, indent: 5, spelling: "," } 39999999999999999993.0e39999999999999999993, - // CHECK:STDOUT: - { index: 52, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "39999999999999999993.0e39999999999999999993", value: "399999999999999999930*10^39999999999999999992", has_leading_space: true } - // CHECK:STDOUT: - { index: 53, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 48, indent: 5, spelling: "," } + // CHECK:STDOUT: - { index: 54, kind: "RealLiteral", line: {{ *}}[[@LINE-1]], column: 5, indent: 5, spelling: "39999999999999999993.0e39999999999999999993", value: "399999999999999999930*10^39999999999999999992", has_leading_space: true } + // CHECK:STDOUT: - { index: 55, kind: "Comma", line: {{ *}}[[@LINE-2]], column: 48, indent: 5, spelling: "," } ); - // CHECK:STDOUT: - { index: 54, kind: "CloseParen", line: {{ *}}[[@LINE-1]], column: 3, indent: 3, spelling: ")", opening_token: 39, has_leading_space: true } - // CHECK:STDOUT: - { index: 55, kind: "Semi", line: {{ *}}[[@LINE-2]], column: 4, indent: 3, spelling: ";" } + // CHECK:STDOUT: - { index: 56, kind: "CloseParen", line: {{ *}}[[@LINE-1]], column: 3, indent: 3, spelling: ")", opening_token: 41, has_leading_space: true } + // CHECK:STDOUT: - { index: 57, kind: "Semi", line: {{ *}}[[@LINE-2]], column: 4, indent: 3, spelling: ";" } } -// CHECK:STDOUT: - { index: 56, kind: "CloseCurlyBrace", line: {{ *}}[[@LINE-1]], column: 1, indent: 1, spelling: "}", opening_token: 5, has_leading_space: true } +// CHECK:STDOUT: - { index: 58, kind: "CloseCurlyBrace", line: {{ *}}[[@LINE-1]], column: 1, indent: 1, spelling: "}", opening_token: 5, has_leading_space: true } // --- fail_binary_real.carbon