AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-10-19 03:20:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
f3fbd98ff5
SPIRV-Tools/test/opt/set_spec_const_default_value_test.cpp

1122 lines
42 KiB
C++
Raw Normal View History

Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
// Copyright (c) 2016 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include <vector>
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include "gmock/gmock.h"
#include "test/opt/pass_fixture.h"
Build "spec id->default val str" mapping from string Add function `ParseDefaultValuesString()` to build the spec id->default value string mapping required by `SetSpecConstantDefaultValuePass`.
2016-09-09 15:47:42 +00:00
Move tests into namespaces (#1689) This CL moves the test into namespaces based on their directories.
2018-07-11 13:24:49 +00:00
namespace spvtools {
namespace opt {
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
namespace {
Build "spec id->default val str" mapping from string Add function `ParseDefaultValuesString()` to build the spec id->default value string mapping required by `SetSpecConstantDefaultValuePass`.
2016-09-09 15:47:42 +00:00
using testing::Eq;
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
using SpecIdToValueStrMap =
Move tests into namespaces (#1689) This CL moves the test into namespaces based on their directories.
2018-07-11 13:24:49 +00:00
SetSpecConstantDefaultValuePass::SpecIdToValueStrMap;
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
using SpecIdToValueBitPatternMap =
Move tests into namespaces (#1689) This CL moves the test into namespaces based on their directories.
2018-07-11 13:24:49 +00:00
SetSpecConstantDefaultValuePass::SpecIdToValueBitPatternMap;
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
Build "spec id->default val str" mapping from string Add function `ParseDefaultValuesString()` to build the spec id->default value string mapping required by `SetSpecConstantDefaultValuePass`.
2016-09-09 15:47:42 +00:00
struct DefaultValuesStringParsingTestCase {
const char* default_values_str;
bool expect_success;
SpecIdToValueStrMap expected_map;
};
using DefaultValuesStringParsingTest =
::testing::TestWithParam<DefaultValuesStringParsingTestCase>;
TEST_P(DefaultValuesStringParsingTest, TestCase) {
const auto& tc = GetParam();
Move tests into namespaces (#1689) This CL moves the test into namespaces based on their directories.
2018-07-11 13:24:49 +00:00
auto actual_map = SetSpecConstantDefaultValuePass::ParseDefaultValuesString(
tc.default_values_str);
Build "spec id->default val str" mapping from string Add function `ParseDefaultValuesString()` to build the spec id->default value string mapping required by `SetSpecConstantDefaultValuePass`.
2016-09-09 15:47:42 +00:00
if (tc.expect_success) {
EXPECT_NE(nullptr, actual_map);
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
if (actual_map) {
EXPECT_THAT(*actual_map, Eq(tc.expected_map));
}
Build "spec id->default val str" mapping from string Add function `ParseDefaultValuesString()` to build the spec id->default value string mapping required by `SetSpecConstantDefaultValuePass`.
2016-09-09 15:47:42 +00:00
} else {
EXPECT_EQ(nullptr, actual_map);
}
}
Remove use of deprecated googletest macro (#2286) * Remove use of deprecated googletest macro INSTANTIATE_TEST_CASE_P has been deprecated. We need to use INSTANTIATE_TEST_SUITE_P instead. * Remove extra commas from test suites.
2019-01-29 23:56:52 +00:00
INSTANTIATE_TEST_SUITE_P(
Build "spec id->default val str" mapping from string Add function `ParseDefaultValuesString()` to build the spec id->default value string mapping required by `SetSpecConstantDefaultValuePass`.
2016-09-09 15:47:42 +00:00
ValidString, DefaultValuesStringParsingTest,
::testing::ValuesIn(std::vector<DefaultValuesStringParsingTestCase>{
// 0. empty map
{"", true, SpecIdToValueStrMap{}},
// 1. one pair
{"100:1024", true, SpecIdToValueStrMap{{100, "1024"}}},
// 2. two pairs
{"100:1024 200:2048", true,
SpecIdToValueStrMap{{100, "1024"}, {200, "2048"}}},
// 3. spaces between entries
{"100:1024 \n \r \t \v \f 200:2048", true,
SpecIdToValueStrMap{{100, "1024"}, {200, "2048"}}},
// 4. \t, \n, \r and spaces before spec id
{" \n \r\t \t \v \f 100:1024", true,
SpecIdToValueStrMap{{100, "1024"}}},
// 5. \t, \n, \r and spaces after value string
{"100:1024 \n \r\t \t \v \f ", true,
SpecIdToValueStrMap{{100, "1024"}}},
// 6. maximum spec id
{"4294967295:0", true, SpecIdToValueStrMap{{4294967295, "0"}}},
// 7. minimum spec id
{"0:100", true, SpecIdToValueStrMap{{0, "100"}}},
// 8. random content without spaces are allowed
{"200:random_stuff", true, SpecIdToValueStrMap{{200, "random_stuff"}}},
// 9. support hex format spec id (just because we use the
// ParseNumber() utility)
{"0x100:1024", true, SpecIdToValueStrMap{{256, "1024"}}},
// 10. multiple entries
{"101:1 102:2 103:3 104:4 200:201 9999:1000 0x100:333", true,
SpecIdToValueStrMap{{101, "1"},
{102, "2"},
{103, "3"},
{104, "4"},
{200, "201"},
{9999, "1000"},
{256, "333"}}},
// 11. default value in hex float format
{"100:0x0.3p10", true, SpecIdToValueStrMap{{100, "0x0.3p10"}}},
// 12. default value in decimal float format
{"100:1.5e-13", true, SpecIdToValueStrMap{{100, "1.5e-13"}}},
}));
Remove use of deprecated googletest macro (#2286) * Remove use of deprecated googletest macro INSTANTIATE_TEST_CASE_P has been deprecated. We need to use INSTANTIATE_TEST_SUITE_P instead. * Remove extra commas from test suites.
2019-01-29 23:56:52 +00:00
INSTANTIATE_TEST_SUITE_P(
Build "spec id->default val str" mapping from string Add function `ParseDefaultValuesString()` to build the spec id->default value string mapping required by `SetSpecConstantDefaultValuePass`.
2016-09-09 15:47:42 +00:00
InvalidString, DefaultValuesStringParsingTest,
::testing::ValuesIn(std::vector<DefaultValuesStringParsingTestCase>{
// 0. missing default value
{"100:", false, SpecIdToValueStrMap{}},
// 1. spec id is not an integer
{"100.0:200", false, SpecIdToValueStrMap{}},
// 2. spec id is not a number
{"something_not_a_number:1", false, SpecIdToValueStrMap{}},
// 3. only spec id number
{"100", false, SpecIdToValueStrMap{}},
// 4. same spec id defined multiple times
{"100:20 100:21", false, SpecIdToValueStrMap{}},
// 5. Multiple definition of an identical spec id in different forms
// is not allowed
{"0x100:100 256:200", false, SpecIdToValueStrMap{}},
// 6. empty spec id
{":3", false, SpecIdToValueStrMap{}},
// 7. only colon
{":", false, SpecIdToValueStrMap{}},
// 8. spec id overflow
{"4294967296:200", false, SpecIdToValueStrMap{}},
// 9. spec id less than 0
{"-1:200", false, SpecIdToValueStrMap{}},
// 10. nullptr
{nullptr, false, SpecIdToValueStrMap{}},
// 11. only a number is invalid
{"1234", false, SpecIdToValueStrMap{}},
// 12. invalid entry separator
{"12:34;23:14", false, SpecIdToValueStrMap{}},
// 13. invalid spec id and default value separator
{"12@34", false, SpecIdToValueStrMap{}},
// 14. spaces before colon
{"100 :1024", false, SpecIdToValueStrMap{}},
// 15. spaces after colon
{"100: 1024", false, SpecIdToValueStrMap{}},
// 16. spec id represented in hex float format is invalid
{"0x3p10:200", false, SpecIdToValueStrMap{}},
}));
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
struct SetSpecConstantDefaultValueInStringFormTestCase {
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
const char* code;
SpecIdToValueStrMap default_values;
const char* expected;
};
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
using SetSpecConstantDefaultValueInStringFormParamTest = PassTest<
::testing::TestWithParam<SetSpecConstantDefaultValueInStringFormTestCase>>;
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
TEST_P(SetSpecConstantDefaultValueInStringFormParamTest, TestCase) {
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
const auto& tc = GetParam();
Move tests into namespaces (#1689) This CL moves the test into namespaces based on their directories.
2018-07-11 13:24:49 +00:00
SinglePassRunAndCheck<SetSpecConstantDefaultValuePass>(
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
tc.code, tc.expected, /* skip_nop = */ false, tc.default_values);
}
Remove use of deprecated googletest macro (#2286) * Remove use of deprecated googletest macro INSTANTIATE_TEST_CASE_P has been deprecated. We need to use INSTANTIATE_TEST_SUITE_P instead. * Remove extra commas from test suites.
2019-01-29 23:56:52 +00:00
INSTANTIATE_TEST_SUITE_P(
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
ValidCases, SetSpecConstantDefaultValueInStringFormParamTest,
::testing::ValuesIn(std::vector<
SetSpecConstantDefaultValueInStringFormTestCase>{
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
// 0. Empty.
{"", SpecIdToValueStrMap{}, ""},
// 1. Empty with non-empty values to set.
{"", SpecIdToValueStrMap{{1, "100"}, {2, "200"}}, ""},
// 2. Bool type.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%bool = OpTypeBool\n"
"%1 = OpSpecConstantTrue %bool\n"
"%2 = OpSpecConstantFalse %bool\n",
// default values
SpecIdToValueStrMap{{100, "false"}, {101, "true"}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%bool = OpTypeBool\n"
"%1 = OpSpecConstantFalse %bool\n"
"%2 = OpSpecConstantTrue %bool\n",
},
// 3. 32-bit int type.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"%int = OpTypeInt 32 1\n"
"%1 = OpSpecConstant %int 10\n"
"%2 = OpSpecConstant %int 11\n"
"%3 = OpSpecConstant %int 11\n",
// default values
SpecIdToValueStrMap{
{100, "2147483647"}, {101, "0xffffffff"}, {102, "-42"}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"%int = OpTypeInt 32 1\n"
"%1 = OpSpecConstant %int 2147483647\n"
"%2 = OpSpecConstant %int -1\n"
"%3 = OpSpecConstant %int -42\n",
},
// 4. 64-bit uint type.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%ulong = OpTypeInt 64 0\n"
"%1 = OpSpecConstant %ulong 10\n"
"%2 = OpSpecConstant %ulong 11\n",
// default values
SpecIdToValueStrMap{{100, "18446744073709551614"}, {101, "0x100"}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%ulong = OpTypeInt 64 0\n"
"%1 = OpSpecConstant %ulong 18446744073709551614\n"
"%2 = OpSpecConstant %ulong 256\n",
},
// 5. 32-bit float type.
{
// code
"OpDecorate %1 SpecId 101\n"
"OpDecorate %2 SpecId 102\n"
"%float = OpTypeFloat 32\n"
"%1 = OpSpecConstant %float 200\n"
"%2 = OpSpecConstant %float 201\n",
// default values
SpecIdToValueStrMap{{101, "-0x1.fffffep+128"}, {102, "2.5"}},
// expected
"OpDecorate %1 SpecId 101\n"
"OpDecorate %2 SpecId 102\n"
"%float = OpTypeFloat 32\n"
"%1 = OpSpecConstant %float -0x1.fffffep+128\n"
"%2 = OpSpecConstant %float 2.5\n",
},
// 6. 64-bit float type.
{
// code
"OpDecorate %1 SpecId 201\n"
"OpDecorate %2 SpecId 202\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %double 3.14159265358979\n"
hex_float: Use max_digits10 for the float precision CPPreference.com has this description of digits10: “The value of std::numeric_limits<T>::digits10 is the number of base-10 digits that can be represented by the type T without change, that is, any number with this many significant decimal digits can be converted to a value of type T and back to decimal form, without change due to rounding or overflow.” This means that any number with this many digits can be represented accurately in the corresponding type. A change in any digit in a number after that may or may not cause it a different bitwise representation. Therefore this isn’t necessarily enough precision to accurately represent the value in text. Instead we need max_digits10 which has the following description: “The value of std::numeric_limits<T>::max_digits10 is the number of base-10 digits that are necessary to uniquely represent all distinct values of the type T, such as necessary for serialization/deserialization to text.” The patch includes a test case in hex_float_test which tries to do a round-robin conversion of a number that requires more than 6 decimal places to be accurately represented. This would fail without the patch. Sadly this also breaks a bunch of other tests. Some of the tests in hex_float_test use ldexp and then compare it with a value which is not the same as the one returned by ldexp but instead is the value rounded to 6 decimals. Others use values that are not evenly representable as a binary floating fraction but then happened to generate the same value when rounded to 6 decimals. Where the actual value didn’t seem to matter these have been changed with different values that can be represented as a binary fraction.
2018-03-30 23:35:45 +00:00
"%2 = OpSpecConstant %double 0.14285\n",
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
// default values
SpecIdToValueStrMap{{201, "0x1.fffffffffffffp+1024"},
{202, "-32.5"}},
// expected
"OpDecorate %1 SpecId 201\n"
"OpDecorate %2 SpecId 202\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %double 0x1.fffffffffffffp+1024\n"
"%2 = OpSpecConstant %double -32.5\n",
},
// 7. SpecId not found, expect no modification.
{
// code
"OpDecorate %1 SpecId 201\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %double 3.14159265358979\n",
// default values
SpecIdToValueStrMap{{8888, "0.0"}},
// expected
"OpDecorate %1 SpecId 201\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %double 3.14159265358979\n",
},
// 8. Multiple types of spec constants.
{
// code
"OpDecorate %1 SpecId 201\n"
"OpDecorate %2 SpecId 202\n"
"OpDecorate %3 SpecId 203\n"
"%bool = OpTypeBool\n"
"%int = OpTypeInt 32 1\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %double 3.14159265358979\n"
"%2 = OpSpecConstant %int 1024\n"
"%3 = OpSpecConstantTrue %bool\n",
// default values
SpecIdToValueStrMap{
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
{201, "0x1.fffffffffffffp+1024"},
{202, "2048"},
{203, "false"},
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
},
// expected
"OpDecorate %1 SpecId 201\n"
"OpDecorate %2 SpecId 202\n"
"OpDecorate %3 SpecId 203\n"
"%bool = OpTypeBool\n"
"%int = OpTypeInt 32 1\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %double 0x1.fffffffffffffp+1024\n"
"%2 = OpSpecConstant %int 2048\n"
"%3 = OpSpecConstantFalse %bool\n",
},
// 9. Ignore other decorations.
{
// code
"OpDecorate %1 ArrayStride 4\n"
"%int = OpTypeInt 32 1\n"
"%1 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueStrMap{{4, "0x7fffffff"}},
// expected
"OpDecorate %1 ArrayStride 4\n"
"%int = OpTypeInt 32 1\n"
"%1 = OpSpecConstant %int 100\n",
},
// 10. Distinguish from other decorations.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %1 ArrayStride 4\n"
"%int = OpTypeInt 32 1\n"
"%1 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueStrMap{{4, "0x7fffffff"}, {100, "0xffffffff"}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %1 ArrayStride 4\n"
"%int = OpTypeInt 32 1\n"
"%1 = OpSpecConstant %int -1\n",
},
// 11. Decorate through decoration group.
{
// code
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueStrMap{{100, "0x7fffffff"}},
// expected
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 2147483647\n",
},
// 12. Ignore other decorations in decoration group.
{
// code
"OpDecorate %1 ArrayStride 4\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueStrMap{{4, "0x7fffffff"}},
// expected
"OpDecorate %1 ArrayStride 4\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n",
},
// 13. Distinguish from other decorations in decoration group.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %1 ArrayStride 4\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueStrMap{{100, "0x7fffffff"}, {4, "0x00000001"}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %1 ArrayStride 4\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 2147483647\n",
},
// 14. Unchanged bool default value
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%bool = OpTypeBool\n"
"%1 = OpSpecConstantTrue %bool\n"
"%2 = OpSpecConstantFalse %bool\n",
// default values
SpecIdToValueStrMap{{100, "true"}, {101, "false"}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%bool = OpTypeBool\n"
"%1 = OpSpecConstantTrue %bool\n"
"%2 = OpSpecConstantFalse %bool\n",
},
// 15. Unchanged int default values
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%int = OpTypeInt 32 1\n"
"%ulong = OpTypeInt 64 0\n"
"%1 = OpSpecConstant %int 10\n"
"%2 = OpSpecConstant %ulong 11\n",
// default values
SpecIdToValueStrMap{{100, "10"}, {101, "11"}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%int = OpTypeInt 32 1\n"
"%ulong = OpTypeInt 64 0\n"
"%1 = OpSpecConstant %int 10\n"
"%2 = OpSpecConstant %ulong 11\n",
},
// 16. Unchanged float default values
{
// code
"OpDecorate %1 SpecId 201\n"
"OpDecorate %2 SpecId 202\n"
"%float = OpTypeFloat 32\n"
"%double = OpTypeFloat 64\n"
hex_float: Use max_digits10 for the float precision CPPreference.com has this description of digits10: “The value of std::numeric_limits<T>::digits10 is the number of base-10 digits that can be represented by the type T without change, that is, any number with this many significant decimal digits can be converted to a value of type T and back to decimal form, without change due to rounding or overflow.” This means that any number with this many digits can be represented accurately in the corresponding type. A change in any digit in a number after that may or may not cause it a different bitwise representation. Therefore this isn’t necessarily enough precision to accurately represent the value in text. Instead we need max_digits10 which has the following description: “The value of std::numeric_limits<T>::max_digits10 is the number of base-10 digits that are necessary to uniquely represent all distinct values of the type T, such as necessary for serialization/deserialization to text.” The patch includes a test case in hex_float_test which tries to do a round-robin conversion of a number that requires more than 6 decimal places to be accurately represented. This would fail without the patch. Sadly this also breaks a bunch of other tests. Some of the tests in hex_float_test use ldexp and then compare it with a value which is not the same as the one returned by ldexp but instead is the value rounded to 6 decimals. Others use values that are not evenly representable as a binary floating fraction but then happened to generate the same value when rounded to 6 decimals. Where the actual value didn’t seem to matter these have been changed with different values that can be represented as a binary fraction.
2018-03-30 23:35:45 +00:00
"%1 = OpSpecConstant %float 3.1415\n"
"%2 = OpSpecConstant %double 0.14285\n",
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
// default values
hex_float: Use max_digits10 for the float precision CPPreference.com has this description of digits10: “The value of std::numeric_limits<T>::digits10 is the number of base-10 digits that can be represented by the type T without change, that is, any number with this many significant decimal digits can be converted to a value of type T and back to decimal form, without change due to rounding or overflow.” This means that any number with this many digits can be represented accurately in the corresponding type. A change in any digit in a number after that may or may not cause it a different bitwise representation. Therefore this isn’t necessarily enough precision to accurately represent the value in text. Instead we need max_digits10 which has the following description: “The value of std::numeric_limits<T>::max_digits10 is the number of base-10 digits that are necessary to uniquely represent all distinct values of the type T, such as necessary for serialization/deserialization to text.” The patch includes a test case in hex_float_test which tries to do a round-robin conversion of a number that requires more than 6 decimal places to be accurately represented. This would fail without the patch. Sadly this also breaks a bunch of other tests. Some of the tests in hex_float_test use ldexp and then compare it with a value which is not the same as the one returned by ldexp but instead is the value rounded to 6 decimals. Others use values that are not evenly representable as a binary floating fraction but then happened to generate the same value when rounded to 6 decimals. Where the actual value didn’t seem to matter these have been changed with different values that can be represented as a binary fraction.
2018-03-30 23:35:45 +00:00
SpecIdToValueStrMap{{201, "3.1415"}, {202, "0.14285"}},
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
// expected
"OpDecorate %1 SpecId 201\n"
"OpDecorate %2 SpecId 202\n"
"%float = OpTypeFloat 32\n"
"%double = OpTypeFloat 64\n"
hex_float: Use max_digits10 for the float precision CPPreference.com has this description of digits10: “The value of std::numeric_limits<T>::digits10 is the number of base-10 digits that can be represented by the type T without change, that is, any number with this many significant decimal digits can be converted to a value of type T and back to decimal form, without change due to rounding or overflow.” This means that any number with this many digits can be represented accurately in the corresponding type. A change in any digit in a number after that may or may not cause it a different bitwise representation. Therefore this isn’t necessarily enough precision to accurately represent the value in text. Instead we need max_digits10 which has the following description: “The value of std::numeric_limits<T>::max_digits10 is the number of base-10 digits that are necessary to uniquely represent all distinct values of the type T, such as necessary for serialization/deserialization to text.” The patch includes a test case in hex_float_test which tries to do a round-robin conversion of a number that requires more than 6 decimal places to be accurately represented. This would fail without the patch. Sadly this also breaks a bunch of other tests. Some of the tests in hex_float_test use ldexp and then compare it with a value which is not the same as the one returned by ldexp but instead is the value rounded to 6 decimals. Others use values that are not evenly representable as a binary floating fraction but then happened to generate the same value when rounded to 6 decimals. Where the actual value didn’t seem to matter these have been changed with different values that can be represented as a binary fraction.
2018-03-30 23:35:45 +00:00
"%1 = OpSpecConstant %float 3.1415\n"
"%2 = OpSpecConstant %double 0.14285\n",
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
},
// 17. OpGroupDecorate may have multiple target ids defined by the same
// eligible spec constant
{
// code
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2 %2 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueStrMap{{100, "0xffffffff"}},
// expected
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2 %2 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int -1\n",
},
}));
Remove use of deprecated googletest macro (#2286) * Remove use of deprecated googletest macro INSTANTIATE_TEST_CASE_P has been deprecated. We need to use INSTANTIATE_TEST_SUITE_P instead. * Remove extra commas from test suites.
2019-01-29 23:56:52 +00:00
INSTANTIATE_TEST_SUITE_P(
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
InvalidCases, SetSpecConstantDefaultValueInStringFormParamTest,
::testing::ValuesIn(std::vector<
SetSpecConstantDefaultValueInStringFormTestCase>{
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
// 0. Do not crash when decoration group is not used.
{
// code
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"%int = OpTypeInt 32 1\n"
"%3 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueStrMap{{100, "0x7fffffff"}},
// expected
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"%int = OpTypeInt 32 1\n"
"%3 = OpSpecConstant %int 100\n",
},
// 1. Do not crash when target does not exist.
{
// code
"OpDecorate %1 SpecId 100\n"
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
"%1 = OpDecorationGroup\n"
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
"%int = OpTypeInt 32 1\n",
// default values
SpecIdToValueStrMap{{100, "0x7fffffff"}},
// expected
"OpDecorate %1 SpecId 100\n"
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
"%1 = OpDecorationGroup\n"
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
"%int = OpTypeInt 32 1\n",
},
// 2. Do nothing when SpecId decoration is not attached to a
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
// non-spec-constant instruction.
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
{
// code
"OpDecorate %1 SpecId 100\n"
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
"%1 = OpDecorationGroup\n"
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
"%int = OpTypeInt 32 1\n"
Make friendly number-based names for OpConstant For example: %int_42 = OpConstant %int 42 %int_n42 = OpConstant %int -42 %float_3_14 = OpConstant %float 3.14
2016-10-13 20:22:04 +00:00
"%int_101 = OpConstant %int 101\n",
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
// default values
SpecIdToValueStrMap{{100, "0x7fffffff"}},
// expected
"OpDecorate %1 SpecId 100\n"
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
"%1 = OpDecorationGroup\n"
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
"%int = OpTypeInt 32 1\n"
Make friendly number-based names for OpConstant For example: %int_42 = OpConstant %int 42 %int_n42 = OpConstant %int -42 %float_3_14 = OpConstant %float 3.14
2016-10-13 20:22:04 +00:00
"%int_101 = OpConstant %int 101\n",
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
},
// 3. Do nothing when SpecId decoration is not attached to a
// OpSpecConstant{|True|False} instruction.
{
// code
"OpDecorate %1 SpecId 100\n"
"%int = OpTypeInt 32 1\n"
"%3 = OpSpecConstant %int 101\n"
"%1 = OpSpecConstantOp %int IAdd %3 %3\n",
// default values
SpecIdToValueStrMap{{100, "0x7fffffff"}},
// expected
"OpDecorate %1 SpecId 100\n"
"%int = OpTypeInt 32 1\n"
"%3 = OpSpecConstant %int 101\n"
"%1 = OpSpecConstantOp %int IAdd %3 %3\n",
},
// 4. Do not crash and do nothing when SpecId decoration is applied to
// multiple spec constants.
{
// code
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2 %3 %4\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n"
"%3 = OpSpecConstant %int 200\n"
"%4 = OpSpecConstant %int 300\n",
// default values
SpecIdToValueStrMap{{100, "0xffffffff"}},
// expected
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2 %3 %4\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n"
"%3 = OpSpecConstant %int 200\n"
"%4 = OpSpecConstant %int 300\n",
},
// 5. Do not crash and do nothing when SpecId decoration is attached to
// non-spec-constants (invalid case).
{
// code
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
"%2 = OpDecorationGroup\n"
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
Make friendly number-based names for OpConstant For example: %int_42 = OpConstant %int 42 %int_n42 = OpConstant %int -42 %float_3_14 = OpConstant %float 3.14
2016-10-13 20:22:04 +00:00
"%int_100 = OpConstant %int 100\n",
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
// default values
SpecIdToValueStrMap{{100, "0xffffffff"}},
// expected
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
"%2 = OpDecorationGroup\n"
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
Make friendly number-based names for OpConstant For example: %int_42 = OpConstant %int 42 %int_n42 = OpConstant %int -42 %float_3_14 = OpConstant %float 3.14
2016-10-13 20:22:04 +00:00
"%int_100 = OpConstant %int 100\n",
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
},
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
// 6. Boolean type spec constant cannot be set with numeric values in
// string form. i.e. only 'true' and 'false' are acceptable for setting
// boolean type spec constants. Nothing should be done if numeric values
// in string form are provided.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"OpDecorate %4 SpecId 103\n"
"OpDecorate %5 SpecId 104\n"
"OpDecorate %6 SpecId 105\n"
"%bool = OpTypeBool\n"
"%1 = OpSpecConstantTrue %bool\n"
"%2 = OpSpecConstantFalse %bool\n"
"%3 = OpSpecConstantTrue %bool\n"
"%4 = OpSpecConstantTrue %bool\n"
"%5 = OpSpecConstantTrue %bool\n"
"%6 = OpSpecConstantFalse %bool\n",
// default values
SpecIdToValueStrMap{{100, "0"},
{101, "1"},
{102, "0x0"},
{103, "0.0"},
{104, "-0.0"},
{105, "0x12345678"}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"OpDecorate %4 SpecId 103\n"
"OpDecorate %5 SpecId 104\n"
"OpDecorate %6 SpecId 105\n"
"%bool = OpTypeBool\n"
"%1 = OpSpecConstantTrue %bool\n"
"%2 = OpSpecConstantFalse %bool\n"
"%3 = OpSpecConstantTrue %bool\n"
"%4 = OpSpecConstantTrue %bool\n"
"%5 = OpSpecConstantTrue %bool\n"
"%6 = OpSpecConstantFalse %bool\n",
},
}));
struct SetSpecConstantDefaultValueInBitPatternFormTestCase {
const char* code;
SpecIdToValueBitPatternMap default_values;
const char* expected;
};
using SetSpecConstantDefaultValueInBitPatternFormParamTest =
PassTest<::testing::TestWithParam<
SetSpecConstantDefaultValueInBitPatternFormTestCase>>;
TEST_P(SetSpecConstantDefaultValueInBitPatternFormParamTest, TestCase) {
const auto& tc = GetParam();
Move tests into namespaces (#1689) This CL moves the test into namespaces based on their directories.
2018-07-11 13:24:49 +00:00
SinglePassRunAndCheck<SetSpecConstantDefaultValuePass>(
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
tc.code, tc.expected, /* skip_nop = */ false, tc.default_values);
}
Remove use of deprecated googletest macro (#2286) * Remove use of deprecated googletest macro INSTANTIATE_TEST_CASE_P has been deprecated. We need to use INSTANTIATE_TEST_SUITE_P instead. * Remove extra commas from test suites.
2019-01-29 23:56:52 +00:00
INSTANTIATE_TEST_SUITE_P(
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
ValidCases, SetSpecConstantDefaultValueInBitPatternFormParamTest,
::testing::ValuesIn(std::vector<
SetSpecConstantDefaultValueInBitPatternFormTestCase>{
// 0. Empty.
{"", SpecIdToValueBitPatternMap{}, ""},
// 1. Empty with non-empty values to set.
{"", SpecIdToValueBitPatternMap{{1, {100}}, {2, {200}}}, ""},
// 2. Baisc bool type.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%bool = OpTypeBool\n"
"%1 = OpSpecConstantTrue %bool\n"
"%2 = OpSpecConstantFalse %bool\n",
// default values
SpecIdToValueBitPatternMap{{100, {0x0}}, {101, {0x1}}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%bool = OpTypeBool\n"
"%1 = OpSpecConstantFalse %bool\n"
"%2 = OpSpecConstantTrue %bool\n",
},
// 3. 32-bit int type.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"%int = OpTypeInt 32 1\n"
"%1 = OpSpecConstant %int 10\n"
"%2 = OpSpecConstant %int 11\n"
"%3 = OpSpecConstant %int 11\n",
// default values
SpecIdToValueBitPatternMap{
{100, {2147483647}}, {101, {0xffffffff}}, {102, {0xffffffd6}}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"%int = OpTypeInt 32 1\n"
"%1 = OpSpecConstant %int 2147483647\n"
"%2 = OpSpecConstant %int -1\n"
"%3 = OpSpecConstant %int -42\n",
},
// 4. 64-bit uint type.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%ulong = OpTypeInt 64 0\n"
"%1 = OpSpecConstant %ulong 10\n"
"%2 = OpSpecConstant %ulong 11\n",
// default values
SpecIdToValueBitPatternMap{{100, {0xFFFFFFFE, 0xFFFFFFFF}},
{101, {0x100, 0x0}}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%ulong = OpTypeInt 64 0\n"
"%1 = OpSpecConstant %ulong 18446744073709551614\n"
"%2 = OpSpecConstant %ulong 256\n",
},
// 5. 32-bit float type.
{
// code
"OpDecorate %1 SpecId 101\n"
"OpDecorate %2 SpecId 102\n"
"%float = OpTypeFloat 32\n"
"%1 = OpSpecConstant %float 200\n"
"%2 = OpSpecConstant %float 201\n",
// default values
SpecIdToValueBitPatternMap{{101, {0xffffffff}},
{102, {0x40200000}}},
// expected
"OpDecorate %1 SpecId 101\n"
"OpDecorate %2 SpecId 102\n"
"%float = OpTypeFloat 32\n"
"%1 = OpSpecConstant %float -0x1.fffffep+128\n"
"%2 = OpSpecConstant %float 2.5\n",
},
// 6. 64-bit float type.
{
// code
"OpDecorate %1 SpecId 201\n"
"OpDecorate %2 SpecId 202\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %double 3.14159265358979\n"
hex_float: Use max_digits10 for the float precision CPPreference.com has this description of digits10: “The value of std::numeric_limits<T>::digits10 is the number of base-10 digits that can be represented by the type T without change, that is, any number with this many significant decimal digits can be converted to a value of type T and back to decimal form, without change due to rounding or overflow.” This means that any number with this many digits can be represented accurately in the corresponding type. A change in any digit in a number after that may or may not cause it a different bitwise representation. Therefore this isn’t necessarily enough precision to accurately represent the value in text. Instead we need max_digits10 which has the following description: “The value of std::numeric_limits<T>::max_digits10 is the number of base-10 digits that are necessary to uniquely represent all distinct values of the type T, such as necessary for serialization/deserialization to text.” The patch includes a test case in hex_float_test which tries to do a round-robin conversion of a number that requires more than 6 decimal places to be accurately represented. This would fail without the patch. Sadly this also breaks a bunch of other tests. Some of the tests in hex_float_test use ldexp and then compare it with a value which is not the same as the one returned by ldexp but instead is the value rounded to 6 decimals. Others use values that are not evenly representable as a binary floating fraction but then happened to generate the same value when rounded to 6 decimals. Where the actual value didn’t seem to matter these have been changed with different values that can be represented as a binary fraction.
2018-03-30 23:35:45 +00:00
"%2 = OpSpecConstant %double 0.14285\n",
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
// default values
SpecIdToValueBitPatternMap{{201, {0xffffffff, 0x7fffffff}},
{202, {0x00000000, 0xc0404000}}},
// expected
"OpDecorate %1 SpecId 201\n"
"OpDecorate %2 SpecId 202\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %double 0x1.fffffffffffffp+1024\n"
"%2 = OpSpecConstant %double -32.5\n",
},
// 7. SpecId not found, expect no modification.
{
// code
"OpDecorate %1 SpecId 201\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %double 3.14159265358979\n",
// default values
SpecIdToValueBitPatternMap{{8888, {0x0}}},
// expected
"OpDecorate %1 SpecId 201\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %double 3.14159265358979\n",
},
// 8. Multiple types of spec constants.
{
// code
"OpDecorate %1 SpecId 201\n"
"OpDecorate %2 SpecId 202\n"
"OpDecorate %3 SpecId 203\n"
"%bool = OpTypeBool\n"
"%int = OpTypeInt 32 1\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %double 3.14159265358979\n"
"%2 = OpSpecConstant %int 1024\n"
"%3 = OpSpecConstantTrue %bool\n",
// default values
SpecIdToValueBitPatternMap{
{201, {0xffffffff, 0x7fffffff}},
{202, {0x00000800}},
{203, {0x0}},
},
// expected
"OpDecorate %1 SpecId 201\n"
"OpDecorate %2 SpecId 202\n"
"OpDecorate %3 SpecId 203\n"
"%bool = OpTypeBool\n"
"%int = OpTypeInt 32 1\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %double 0x1.fffffffffffffp+1024\n"
"%2 = OpSpecConstant %int 2048\n"
"%3 = OpSpecConstantFalse %bool\n",
},
// 9. Ignore other decorations.
{
// code
"OpDecorate %1 ArrayStride 4\n"
"%int = OpTypeInt 32 1\n"
"%1 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueBitPatternMap{{4, {0x7fffffff}}},
// expected
"OpDecorate %1 ArrayStride 4\n"
"%int = OpTypeInt 32 1\n"
"%1 = OpSpecConstant %int 100\n",
},
// 10. Distinguish from other decorations.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %1 ArrayStride 4\n"
"%int = OpTypeInt 32 1\n"
"%1 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueBitPatternMap{{4, {0x7fffffff}}, {100, {0xffffffff}}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %1 ArrayStride 4\n"
"%int = OpTypeInt 32 1\n"
"%1 = OpSpecConstant %int -1\n",
},
// 11. Decorate through decoration group.
{
// code
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueBitPatternMap{{100, {0x7fffffff}}},
// expected
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 2147483647\n",
},
// 12. Ignore other decorations in decoration group.
{
// code
"OpDecorate %1 ArrayStride 4\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueBitPatternMap{{4, {0x7fffffff}}},
// expected
"OpDecorate %1 ArrayStride 4\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n",
},
// 13. Distinguish from other decorations in decoration group.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %1 ArrayStride 4\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueBitPatternMap{{100, {0x7fffffff}}, {4, {0x00000001}}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %1 ArrayStride 4\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 2147483647\n",
},
// 14. Unchanged bool default value
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%bool = OpTypeBool\n"
"%1 = OpSpecConstantTrue %bool\n"
"%2 = OpSpecConstantFalse %bool\n",
// default values
SpecIdToValueBitPatternMap{{100, {0x1}}, {101, {0x0}}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%bool = OpTypeBool\n"
"%1 = OpSpecConstantTrue %bool\n"
"%2 = OpSpecConstantFalse %bool\n",
},
// 15. Unchanged int default values
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%int = OpTypeInt 32 1\n"
"%ulong = OpTypeInt 64 0\n"
"%1 = OpSpecConstant %int 10\n"
"%2 = OpSpecConstant %ulong 11\n",
// default values
SpecIdToValueBitPatternMap{{100, {10}}, {101, {11, 0}}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"%int = OpTypeInt 32 1\n"
"%ulong = OpTypeInt 64 0\n"
"%1 = OpSpecConstant %int 10\n"
"%2 = OpSpecConstant %ulong 11\n",
},
// 16. Unchanged float default values
{
// code
"OpDecorate %1 SpecId 201\n"
"OpDecorate %2 SpecId 202\n"
"%float = OpTypeFloat 32\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %float 3.25\n"
"%2 = OpSpecConstant %double 1.25\n",
// default values
SpecIdToValueBitPatternMap{{201, {0x40500000}},
{202, {0x00000000, 0x3ff40000}}},
// expected
"OpDecorate %1 SpecId 201\n"
"OpDecorate %2 SpecId 202\n"
"%float = OpTypeFloat 32\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %float 3.25\n"
"%2 = OpSpecConstant %double 1.25\n",
},
// 17. OpGroupDecorate may have multiple target ids defined by the same
// eligible spec constant
{
// code
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2 %2 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueBitPatternMap{{100, {0xffffffff}}},
// expected
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2 %2 %2\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int -1\n",
},
// 18. For Boolean type spec constants,if any word in the bit pattern
// is not zero, it can be considered as a 'true', otherwise, it can be
// considered as a 'false'.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"%bool = OpTypeBool\n"
"%1 = OpSpecConstantTrue %bool\n"
"%2 = OpSpecConstantFalse %bool\n"
"%3 = OpSpecConstantFalse %bool\n",
// default values
SpecIdToValueBitPatternMap{
{100, {0x0, 0x0, 0x0, 0x0}},
{101, {0x10101010}},
{102, {0x0, 0x0, 0x0, 0x2}},
},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"%bool = OpTypeBool\n"
"%1 = OpSpecConstantFalse %bool\n"
"%2 = OpSpecConstantTrue %bool\n"
"%3 = OpSpecConstantTrue %bool\n",
},
opt/spec_constants: fix bit pattern width checks. (#4588) * test: add a test to show 8/16-bit * opt/spec_constants: fix bit pattern width checks. The input bit patterns are always at least 32-bits, so let the test pass for 8/16-bit values as well. This shouldn't have any effect on the 64-bit patterns I assume this was introduced for.
2021-10-20 15:53:24 +00:00
// 19. 16-bit int type.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"%short = OpTypeInt 16 1\n"
"%1 = OpSpecConstant %short 10\n"
"%2 = OpSpecConstant %short 11\n"
"%3 = OpSpecConstant %short 11\n",
// default values
SpecIdToValueBitPatternMap{
{100, {32768}}, {101, {0xffff}}, {102, {0xffffffd6}}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"%short = OpTypeInt 16 1\n"
"%1 = OpSpecConstant %short 32768\n"
"%2 = OpSpecConstant %short 65535\n"
"%3 = OpSpecConstant %short -42\n",
},
// 20. 8-bit int type.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"%char = OpTypeInt 8 1\n"
"%1 = OpSpecConstant %char 10\n"
"%2 = OpSpecConstant %char 11\n"
"%3 = OpSpecConstant %char 11\n",
// default values
SpecIdToValueBitPatternMap{
{100, {128}}, {101, {129}}, {102, {0xffffffd6}}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"%char = OpTypeInt 8 1\n"
"%1 = OpSpecConstant %char 128\n"
"%2 = OpSpecConstant %char 129\n"
"%3 = OpSpecConstant %char -42\n",
},
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
}));
Remove use of deprecated googletest macro (#2286) * Remove use of deprecated googletest macro INSTANTIATE_TEST_CASE_P has been deprecated. We need to use INSTANTIATE_TEST_SUITE_P instead. * Remove extra commas from test suites.
2019-01-29 23:56:52 +00:00
INSTANTIATE_TEST_SUITE_P(
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
InvalidCases, SetSpecConstantDefaultValueInBitPatternFormParamTest,
::testing::ValuesIn(std::vector<
SetSpecConstantDefaultValueInBitPatternFormTestCase>{
// 0. Do not crash when decoration group is not used.
{
// code
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"%int = OpTypeInt 32 1\n"
"%3 = OpSpecConstant %int 100\n",
// default values
SpecIdToValueBitPatternMap{{100, {0x7fffffff}}},
// expected
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"%int = OpTypeInt 32 1\n"
"%3 = OpSpecConstant %int 100\n",
},
// 1. Do not crash when target does not exist.
{
// code
"OpDecorate %1 SpecId 100\n"
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
"%1 = OpDecorationGroup\n"
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
"%int = OpTypeInt 32 1\n",
// default values
SpecIdToValueBitPatternMap{{100, {0x7fffffff}}},
// expected
"OpDecorate %1 SpecId 100\n"
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
"%1 = OpDecorationGroup\n"
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
"%int = OpTypeInt 32 1\n",
},
// 2. Do nothing when SpecId decoration is not attached to a
// non-spec-constant instruction.
{
// code
"OpDecorate %1 SpecId 100\n"
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
"%1 = OpDecorationGroup\n"
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
"%int = OpTypeInt 32 1\n"
"%int_101 = OpConstant %int 101\n",
// default values
SpecIdToValueBitPatternMap{{100, {0x7fffffff}}},
// expected
"OpDecorate %1 SpecId 100\n"
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
"%1 = OpDecorationGroup\n"
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
"%int = OpTypeInt 32 1\n"
"%int_101 = OpConstant %int 101\n",
},
// 3. Do nothing when SpecId decoration is not attached to a
// OpSpecConstant{|True|False} instruction.
{
// code
"OpDecorate %1 SpecId 100\n"
"%int = OpTypeInt 32 1\n"
"%3 = OpSpecConstant %int 101\n"
"%1 = OpSpecConstantOp %int IAdd %3 %3\n",
// default values
SpecIdToValueBitPatternMap{{100, {0x7fffffff}}},
// expected
"OpDecorate %1 SpecId 100\n"
"%int = OpTypeInt 32 1\n"
"%3 = OpSpecConstant %int 101\n"
"%1 = OpSpecConstantOp %int IAdd %3 %3\n",
},
// 4. Do not crash and do nothing when SpecId decoration is applied to
// multiple spec constants.
{
// code
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2 %3 %4\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n"
"%3 = OpSpecConstant %int 200\n"
"%4 = OpSpecConstant %int 300\n",
// default values
SpecIdToValueBitPatternMap{{100, {0xffffffff}}},
// expected
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
"OpGroupDecorate %1 %2 %3 %4\n"
"%int = OpTypeInt 32 1\n"
"%2 = OpSpecConstant %int 100\n"
"%3 = OpSpecConstant %int 200\n"
"%4 = OpSpecConstant %int 300\n",
},
// 5. Do not crash and do nothing when SpecId decoration is attached to
// non-spec-constants (invalid case).
{
// code
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
"%2 = OpDecorationGroup\n"
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%int_100 = OpConstant %int 100\n",
// default values
SpecIdToValueBitPatternMap{{100, {0xffffffff}}},
// expected
"OpDecorate %1 SpecId 100\n"
"%1 = OpDecorationGroup\n"
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
"%2 = OpDecorationGroup\n"
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
"OpGroupDecorate %1 %2\n"
"%int = OpTypeInt 32 1\n"
"%int_100 = OpConstant %int 100\n",
},
// 6. Incompatible input bit pattern with the type. Nothing should be
// done in such a case.
{
// code
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"%int = OpTypeInt 32 1\n"
"%ulong = OpTypeInt 64 0\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %int 100\n"
"%2 = OpSpecConstant %ulong 200\n"
hex_float: Use max_digits10 for the float precision CPPreference.com has this description of digits10: “The value of std::numeric_limits<T>::digits10 is the number of base-10 digits that can be represented by the type T without change, that is, any number with this many significant decimal digits can be converted to a value of type T and back to decimal form, without change due to rounding or overflow.” This means that any number with this many digits can be represented accurately in the corresponding type. A change in any digit in a number after that may or may not cause it a different bitwise representation. Therefore this isn’t necessarily enough precision to accurately represent the value in text. Instead we need max_digits10 which has the following description: “The value of std::numeric_limits<T>::max_digits10 is the number of base-10 digits that are necessary to uniquely represent all distinct values of the type T, such as necessary for serialization/deserialization to text.” The patch includes a test case in hex_float_test which tries to do a round-robin conversion of a number that requires more than 6 decimal places to be accurately represented. This would fail without the patch. Sadly this also breaks a bunch of other tests. Some of the tests in hex_float_test use ldexp and then compare it with a value which is not the same as the one returned by ldexp but instead is the value rounded to 6 decimals. Others use values that are not evenly representable as a binary floating fraction but then happened to generate the same value when rounded to 6 decimals. Where the actual value didn’t seem to matter these have been changed with different values that can be represented as a binary fraction.
2018-03-30 23:35:45 +00:00
"%3 = OpSpecConstant %double 3.141592653\n",
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
// default values
SpecIdToValueBitPatternMap{
{100, {10, 0}}, {101, {11}}, {102, {0xffffffff}}},
// expected
"OpDecorate %1 SpecId 100\n"
"OpDecorate %2 SpecId 101\n"
"OpDecorate %3 SpecId 102\n"
"%int = OpTypeInt 32 1\n"
"%ulong = OpTypeInt 64 0\n"
"%double = OpTypeFloat 64\n"
"%1 = OpSpecConstant %int 100\n"
"%2 = OpSpecConstant %ulong 200\n"
hex_float: Use max_digits10 for the float precision CPPreference.com has this description of digits10: “The value of std::numeric_limits<T>::digits10 is the number of base-10 digits that can be represented by the type T without change, that is, any number with this many significant decimal digits can be converted to a value of type T and back to decimal form, without change due to rounding or overflow.” This means that any number with this many digits can be represented accurately in the corresponding type. A change in any digit in a number after that may or may not cause it a different bitwise representation. Therefore this isn’t necessarily enough precision to accurately represent the value in text. Instead we need max_digits10 which has the following description: “The value of std::numeric_limits<T>::max_digits10 is the number of base-10 digits that are necessary to uniquely represent all distinct values of the type T, such as necessary for serialization/deserialization to text.” The patch includes a test case in hex_float_test which tries to do a round-robin conversion of a number that requires more than 6 decimal places to be accurately represented. This would fail without the patch. Sadly this also breaks a bunch of other tests. Some of the tests in hex_float_test use ldexp and then compare it with a value which is not the same as the one returned by ldexp but instead is the value rounded to 6 decimals. Others use values that are not evenly representable as a binary floating fraction but then happened to generate the same value when rounded to 6 decimals. Where the actual value didn’t seem to matter these have been changed with different values that can be represented as a binary fraction.
2018-03-30 23:35:45 +00:00
"%3 = OpSpecConstant %double 3.141592653\n",
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
},
Set default values for spec const decorated by SpecId The pass instance is constructed with a map from spec id (uint32_t) to default values in string format. The default value strings will be parsed to numbers according to the target spec constant type. If the Spec Id decoration is found to be applied on multiple different target ids, that decoration instruction (OpDecorate or OpGroupDecorate) will be skipped. But other decoration instrucitons may still be processed.
2016-08-30 18:57:56 +00:00
}));
Move tests into namespaces (#1689) This CL moves the test into namespaces based on their directories.
2018-07-11 13:24:49 +00:00
} // namespace
} // namespace opt
} // namespace spvtools
Reference in New Issue Copy Permalink