diff --git a/xls/dslx/cpp_transpiler/BUILD b/xls/dslx/cpp_transpiler/BUILD index 889b11fdbc..7ba2986c42 100644 --- a/xls/dslx/cpp_transpiler/BUILD +++ b/xls/dslx/cpp_transpiler/BUILD @@ -67,6 +67,7 @@ cc_library( "//xls/dslx/type_system:type_info", "//xls/dslx/type_system_v2:import_utils", "//xls/dslx/type_system_v2:type_annotation_utils", + "@com_google_absl//absl/algorithm:container", "@com_google_absl//absl/base:no_destructor", "@com_google_absl//absl/container:flat_hash_map", "@com_google_absl//absl/container:flat_hash_set", @@ -74,6 +75,7 @@ cc_library( "@com_google_absl//absl/status:statusor", "@com_google_absl//absl/strings", "@com_google_absl//absl/strings:str_format", + "@com_google_absl//absl/types:span", ], ) @@ -98,6 +100,7 @@ cc_library( "@com_google_absl//absl/status:statusor", "@com_google_absl//absl/strings", "@com_google_absl//absl/strings:str_format", + "@com_google_absl//absl/types:span", "@com_google_absl//absl/types:variant", ], ) diff --git a/xls/dslx/cpp_transpiler/cpp_emitter.cc b/xls/dslx/cpp_transpiler/cpp_emitter.cc index ab72ff3b31..1b96f74d4a 100644 --- a/xls/dslx/cpp_transpiler/cpp_emitter.cc +++ b/xls/dslx/cpp_transpiler/cpp_emitter.cc @@ -14,8 +14,10 @@ #include "xls/dslx/cpp_transpiler/cpp_emitter.h" +#include #include #include +#include #include #include #include @@ -24,14 +26,17 @@ #include #include +#include "absl/algorithm/container.h" #include "absl/base/no_destructor.h" #include "absl/container/flat_hash_map.h" #include "absl/container/flat_hash_set.h" #include "absl/status/status.h" #include "absl/status/statusor.h" +#include "absl/strings/match.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_format.h" #include "absl/strings/str_join.h" +#include "absl/types/span.h" #include "xls/common/case_converters.h" #include "xls/common/indent.h" #include "xls/common/status/ret_check.h" @@ -418,6 +423,10 @@ class TypeRefCppEmitter : public CppEmitter { // std::array. class ArrayCppEmitter : public CppEmitter { public: + // NOTE: until we implement variable name tracking across generated scopes, + // prefixes must be kept unique across all emitters and generators + std::string kArrayVarPrefix = "elements"; + explicit ArrayCppEmitter(const CppType& cpp_type, std::string_view dslx_type, int64_t array_size, std::unique_ptr element_emitter) @@ -455,6 +464,8 @@ class ArrayCppEmitter : public CppEmitter { std::string AssignToValue(std::string_view lhs, std::string_view rhs, int64_t nesting) const override { + std::string tmp_var_name = + UniqueVarName({std::string(rhs)}, kArrayVarPrefix); std::string ind_var = absl::StrCat("i", nesting); std::vector loop_body; @@ -462,16 +473,18 @@ class ArrayCppEmitter : public CppEmitter { std::string element_assignment = element_emitter_->AssignToValue( "element", absl::StrFormat("%s[%s]", rhs, ind_var), nesting + 1); loop_body.push_back(element_assignment); - loop_body.push_back("elements.push_back(element);"); + loop_body.push_back( + absl::StrFormat("%s.push_back(element);", tmp_var_name)); std::vector pieces; - pieces.push_back("std::vector<::xls::Value> elements;"); + pieces.push_back( + absl::StrFormat("std::vector<::xls::Value> %s;", tmp_var_name)); pieces.push_back(absl::StrFormat("for (int64_t %s = 0; %s < %d; ++%s) {", ind_var, ind_var, array_size(), ind_var)); pieces.push_back(Indent(absl::StrJoin(loop_body, "\n"), 2)); pieces.push_back("}"); - pieces.push_back( - absl::StrFormat("%s = ::xls::Value::ArrayOrDie(elements);", lhs)); + pieces.push_back(absl::StrFormat("%s = ::xls::Value::ArrayOrDie(%s);", lhs, + tmp_var_name)); std::string lines = absl::StrJoin(pieces, "\n"); return absl::StrCat("{\n", Indent(lines, 2), "\n}"); @@ -575,6 +588,10 @@ class ArrayCppEmitter : public CppEmitter { // std::tuple. class TupleCppEmitter : public CppEmitter { public: + // NOTE: until we implement variable name tracking across generated scopes, + // prefixes must be kept unique across all emitters and generators + std::string kTupleVarPrefix = "entries"; + explicit TupleCppEmitter( const CppType& cpp_type, std::string_view dslx_type, std::vector> element_emitters) @@ -606,16 +623,20 @@ class TupleCppEmitter : public CppEmitter { std::string AssignToValue(std::string_view lhs, std::string_view rhs, int64_t nesting) const override { std::vector pieces; - pieces.push_back("std::vector<::xls::Value> members;"); - pieces.push_back(absl::StrFormat("members.resize(%d);", size())); + std::vector user_defined_names{std::string(rhs)}; + std::string tmp_var_name = + UniqueVarName(user_defined_names, kTupleVarPrefix); + pieces.push_back( + absl::StrFormat("std::vector<::xls::Value> %s;", tmp_var_name)); + pieces.push_back(absl::StrFormat("%s.resize(%d);", tmp_var_name, size())); for (int64_t i = 0; i < size(); ++i) { std::string assignment = element_emitters_[i]->AssignToValue( - absl::StrFormat("members[%d]", i), + absl::StrFormat("%s[%d]", tmp_var_name, i), absl::StrFormat("std::get<%d>(%s)", i, rhs), nesting + 1); pieces.push_back(assignment); } pieces.push_back( - absl::StrFormat("%s = ::xls::Value::Tuple(members);", lhs)); + absl::StrFormat("%s = ::xls::Value::Tuple(%s);", lhs, tmp_var_name)); return absl::StrFormat("{\n%s\n}", Indent(absl::StrJoin(pieces, "\n"), 2)); } @@ -803,8 +824,29 @@ std::string SanitizeCppName(std::string_view name) { return std::string{name}; } +std::string PreserveTrimmedCharacter(std::string_view original, + std::string_view sanitized, + char c_to_preserve) { + bool all_match_so_far = true; + auto still_underscore = [&](char c) -> bool { + all_match_so_far &= (c == c_to_preserve); + return all_match_so_far; + }; + int64_t leading_underscores = + std::count_if(original.begin(), original.end(), still_underscore); + all_match_so_far = true; + int64_t trailing_underscores = + std::count_if(original.rbegin(), original.rend(), still_underscore); + return absl::StrCat(std::string(leading_underscores, c_to_preserve), + sanitized, + std::string(trailing_underscores, c_to_preserve)); +} + std::string DslxTypeNameToCpp(std::string_view dslx_type) { - return SanitizeCppName(Camelize(dslx_type)); + std::string cpp_name = SanitizeCppName(Camelize(dslx_type)); + // Retain trimmed underscores to ensure names are unique. This matters for + // user defined names only differing by underscores. + return PreserveTrimmedCharacter(dslx_type, cpp_name, '_'); } std::string DslxModuleNameToCppNamespace(std::string_view dslx_module) { @@ -856,4 +898,27 @@ std::string DslxModuleNameToCppNamespace(std::string_view dslx_module) { "Unsupported TypeAnnotation kind: ", type_annotation->ToString())); } +std::string UniqueVarName(absl::Span user_names, + std::string_view prefix) { + std::string unique_name = std::string(prefix); + if (!absl::c_contains(user_names, unique_name)) { + return unique_name; + } + std::vector existing_user_names; + absl::c_copy_if(user_names, std::back_inserter(existing_user_names), + [prefix](std::string_view name) { + return absl::StartsWith(name, prefix); + }); + absl::c_sort(existing_user_names); + // Appending a character avoids collision with previous names because the + // potentially colliding names are sorted. Names [x, x_, x__, ...] will be + // caught by subsequent iterations and enough "_" will be appended. + for (int64_t i = 0; i < existing_user_names.size(); ++i) { + if (existing_user_names[i] == unique_name) { + unique_name += "_"; + } + } + return unique_name; +} + } // namespace xls::dslx diff --git a/xls/dslx/cpp_transpiler/cpp_emitter.h b/xls/dslx/cpp_transpiler/cpp_emitter.h index de954c8e03..4ddca218aa 100644 --- a/xls/dslx/cpp_transpiler/cpp_emitter.h +++ b/xls/dslx/cpp_transpiler/cpp_emitter.h @@ -23,6 +23,7 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" +#include "absl/types/span.h" #include "xls/dslx/frontend/ast.h" #include "xls/dslx/import_data.h" #include "xls/dslx/type_system/type_info.h" @@ -40,6 +41,9 @@ std::string DslxTypeNameToCpp(std::string_view dslx_type); // (https://abseil.io/tips/130). std::string DslxModuleNameToCppNamespace(std::string_view dslx_module); +std::string UniqueVarName(absl::Span user_names, + std::string_view prefix); + struct CppType { std::string name; std::string namespace_prefix = ""; diff --git a/xls/dslx/cpp_transpiler/cpp_transpiler_test.cc b/xls/dslx/cpp_transpiler/cpp_transpiler_test.cc index c211b13094..8692402448 100644 --- a/xls/dslx/cpp_transpiler/cpp_transpiler_test.cc +++ b/xls/dslx/cpp_transpiler/cpp_transpiler_test.cc @@ -179,7 +179,9 @@ struct MyStruct { y: u15, z: u8, w: s63, - v: u1, + result: u1, + result__: u1, + result_: u1, })"; auto import_data = CreateImportDataForTest(); diff --git a/xls/dslx/cpp_transpiler/cpp_type_generator.cc b/xls/dslx/cpp_transpiler/cpp_type_generator.cc index 3d0dfa2301..094fe7d26d 100644 --- a/xls/dslx/cpp_transpiler/cpp_type_generator.cc +++ b/xls/dslx/cpp_transpiler/cpp_type_generator.cc @@ -28,6 +28,7 @@ #include "absl/strings/str_cat.h" #include "absl/strings/str_format.h" #include "absl/strings/str_join.h" +#include "absl/types/span.h" #include "absl/types/variant.h" #include "xls/common/indent.h" #include "xls/common/status/status_macros.h" @@ -465,6 +466,11 @@ class TypeAliasCppTypeGenerator : public CppTypeGenerator { // A type generator for emitting a C++ struct for representing a DSLX struct. class StructCppTypeGenerator : public CppTypeGenerator { public: + // NOTE: until we implement variable name tracking across generated scopes, + // prefixes must be kept unique across all emitters and generators + std::string kResultVarPrefix = "result"; + std::string kListVarPrefix = "members"; + explicit StructCppTypeGenerator( std::string_view cpp_type, std::string_view dslx_type, const StructDef* struct_def, @@ -558,6 +564,8 @@ class StructCppTypeGenerator : public CppTypeGenerator { protected: CppSource FromValueMethod() const { + std::string tmp_var_name = + UniqueVarName(cpp_member_names_, kResultVarPrefix); std::vector pieces; pieces.push_back(absl::StrFormat( "if (!value.IsTuple() || value.size() != %d) {", struct_def_->size())); @@ -566,14 +574,14 @@ class StructCppTypeGenerator : public CppTypeGenerator { "tuple of %d elements.\");", struct_def_->size())); pieces.push_back("}"); - pieces.push_back(absl::StrFormat("%s result;", cpp_type())); + pieces.push_back(absl::StrFormat("%s %s;", cpp_type(), tmp_var_name)); for (int i = 0; i < struct_def_->members().size(); i++) { std::string assignment = member_emitters_[i]->AssignFromValue( - /*lhs=*/absl::StrFormat("result.%s", cpp_member_names_[i]), + /*lhs=*/absl::StrFormat("%s.%s", tmp_var_name, cpp_member_names_[i]), /*rhs=*/absl::StrFormat("value.element(%d)", i), /*nesting=*/0); pieces.push_back(assignment); } - pieces.push_back("return result;"); + pieces.push_back(absl::StrFormat("return %s;", tmp_var_name)); std::string body = absl::StrJoin(pieces, "\n"); return CppSource{ @@ -587,17 +595,20 @@ class StructCppTypeGenerator : public CppTypeGenerator { } CppSource ToValueMethod() const { + std::string tmp_var_name = UniqueVarName(cpp_member_names_, kListVarPrefix); std::vector pieces; - pieces.push_back("std::vector<::xls::Value> members;"); pieces.push_back( - absl::StrFormat("members.resize(%d);", struct_def_->members().size())); + absl::StrFormat("std::vector<::xls::Value> %s;", tmp_var_name)); + pieces.push_back(absl::StrFormat("%s.resize(%d);", tmp_var_name, + struct_def_->members().size())); for (int i = 0; i < struct_def_->members().size(); i++) { std::string assignment = member_emitters_[i]->AssignToValue( - /*lhs=*/absl::StrFormat("members[%d]", i), + /*lhs=*/absl::StrFormat("%s[%d]", tmp_var_name, i), /*rhs=*/cpp_member_names_[i], /*nesting=*/0); pieces.push_back(assignment); } - pieces.push_back("return ::xls::Value::Tuple(members);"); + pieces.push_back( + absl::StrFormat("return ::xls::Value::Tuple(%s);", tmp_var_name)); std::string body = absl::StrJoin(pieces, "\n"); return CppSource{ @@ -626,19 +637,21 @@ class StructCppTypeGenerator : public CppTypeGenerator { } CppSource ToStringMethod() const { + std::string tmp_var_name = + UniqueVarName(cpp_member_names_, kResultVarPrefix); std::vector pieces; - pieces.push_back( - absl::StrFormat("std::string result = \"%s {\\n\";", cpp_type())); + pieces.push_back(absl::StrFormat("std::string %s = \"%s {\\n\";", + tmp_var_name, cpp_type())); for (int i = 0; i < struct_def_->members().size(); i++) { - pieces.push_back(absl::StrFormat( - "result += __indent(indent + 1) + \"%s: \";", cpp_member_names_[i])); + pieces.push_back(absl::StrFormat("%s += __indent(indent + 1) + \"%s: \";", + tmp_var_name, cpp_member_names_[i])); std::string to_string = member_emitters_[i]->ToString( - "result", "indent + 2", cpp_member_names_[i], /*nesting=*/0); + tmp_var_name, "indent + 2", cpp_member_names_[i], /*nesting=*/0); pieces.push_back(to_string); - pieces.push_back("result += \",\\n\";"); + pieces.push_back(tmp_var_name + " += \",\\n\";"); } - pieces.push_back("result += __indent(indent) + \"}\";"); - pieces.push_back("return result;"); + pieces.push_back(tmp_var_name + " += __indent(indent) + \"}\";"); + pieces.push_back(absl::StrFormat("return %s;", tmp_var_name)); std::string body = absl::StrJoin(pieces, "\n"); return CppSource{.header = "std::string ToString(int indent = 0) const;", @@ -648,19 +661,21 @@ class StructCppTypeGenerator : public CppTypeGenerator { } CppSource ToDslxStringMethod() const { + std::string tmp_var_name = + UniqueVarName(cpp_member_names_, kResultVarPrefix); std::vector pieces; - pieces.push_back( - absl::StrFormat("std::string result = \"%s {\\n\";", dslx_type())); + pieces.push_back(absl::StrFormat("std::string %s = \"%s {\\n\";", + tmp_var_name, dslx_type())); for (int i = 0; i < struct_def_->members().size(); i++) { - pieces.push_back(absl::StrFormat( - "result += __indent(indent + 1) + \"%s: \";", cpp_member_names_[i])); + pieces.push_back(absl::StrFormat("%s += __indent(indent + 1) + \"%s: \";", + tmp_var_name, cpp_member_names_[i])); std::string to_string = member_emitters_[i]->ToDslxString( - "result", "indent + 2", cpp_member_names_[i], /*nesting=*/0); + tmp_var_name, "indent + 2", cpp_member_names_[i], /*nesting=*/0); pieces.push_back(to_string); - pieces.push_back("result += \",\\n\";"); + pieces.push_back(tmp_var_name + " += \",\\n\";"); } - pieces.push_back("result += __indent(indent) + \"}\";"); - pieces.push_back("return result;"); + pieces.push_back(tmp_var_name + " += __indent(indent) + \"}\";"); + pieces.push_back(absl::StrFormat("return %s;", tmp_var_name)); std::string body = absl::StrJoin(pieces, "\n"); return CppSource{ diff --git a/xls/dslx/cpp_transpiler/testdata/BasicStruct.cctxt b/xls/dslx/cpp_transpiler/testdata/BasicStruct.cctxt index 2667e82b9d..fdf2d5e931 100644 --- a/xls/dslx/cpp_transpiler/testdata/BasicStruct.cctxt +++ b/xls/dslx/cpp_transpiler/testdata/BasicStruct.cctxt @@ -39,36 +39,44 @@ namespace my_module { absl::StatusOr MyStruct::FromValue(const ::xls::Value& value) { - if (!value.IsTuple() || value.size() != 5) { - return absl::InvalidArgumentError("Value is not a tuple of 5 elements."); + if (!value.IsTuple() || value.size() != 7) { + return absl::InvalidArgumentError("Value is not a tuple of 7 elements."); } - MyStruct result; + MyStruct result___; if (!value.element(0).IsBits() || value.element(0).bits().bit_count() != 32) { return absl::InvalidArgumentError("Value is not a bits type of 32 bits."); } - result.x = value.element(0).bits().ToUint64().value(); + result___.x = value.element(0).bits().ToUint64().value(); if (!value.element(1).IsBits() || value.element(1).bits().bit_count() != 15) { return absl::InvalidArgumentError("Value is not a bits type of 15 bits."); } - result.y = value.element(1).bits().ToUint64().value(); + result___.y = value.element(1).bits().ToUint64().value(); if (!value.element(2).IsBits() || value.element(2).bits().bit_count() != 8) { return absl::InvalidArgumentError("Value is not a bits type of 8 bits."); } - result.z = value.element(2).bits().ToUint64().value(); + result___.z = value.element(2).bits().ToUint64().value(); if (!value.element(3).IsBits() || value.element(3).bits().bit_count() != 63) { return absl::InvalidArgumentError("Value is not a bits type of 63 bits."); } - result.w = value.element(3).bits().ToInt64().value(); + result___.w = value.element(3).bits().ToInt64().value(); if (!value.element(4).IsBits() || value.element(4).bits().bit_count() != 1) { return absl::InvalidArgumentError("Value is not a bits type of 1 bits."); } - result.v = value.element(4).bits().ToUint64().value(); - return result; + result___.result = value.element(4).bits().ToUint64().value(); + if (!value.element(5).IsBits() || value.element(5).bits().bit_count() != 1) { + return absl::InvalidArgumentError("Value is not a bits type of 1 bits."); + } + result___.result__ = value.element(5).bits().ToUint64().value(); + if (!value.element(6).IsBits() || value.element(6).bits().bit_count() != 1) { + return absl::InvalidArgumentError("Value is not a bits type of 1 bits."); + } + result___.result_ = value.element(6).bits().ToUint64().value(); + return result___; } absl::StatusOr<::xls::Value> MyStruct::ToValue() const { std::vector<::xls::Value> members; - members.resize(5); + members.resize(7); if (!FitsInNBitsUnsigned(x, 32)) { return absl::InvalidArgumentError(absl::StrFormat("Unsigned value %#x does not fit in 32 bits", x)); } @@ -85,53 +93,73 @@ absl::StatusOr<::xls::Value> MyStruct::ToValue() const { return absl::InvalidArgumentError(absl::StrFormat("Signed value %#x does not fit in 63 bits", w)); } members[3] = ::xls::Value(::xls::SBits(w, 63)); - if (!FitsInNBitsUnsigned(v, 1)) { - return absl::InvalidArgumentError(absl::StrFormat("Unsigned value %#x does not fit in 1 bits", v)); + if (!FitsInNBitsUnsigned(result, 1)) { + return absl::InvalidArgumentError(absl::StrFormat("Unsigned value %#x does not fit in 1 bits", result)); } - members[4] = ::xls::Value(::xls::UBits(v, 1)); + members[4] = ::xls::Value(::xls::UBits(result, 1)); + if (!FitsInNBitsUnsigned(result__, 1)) { + return absl::InvalidArgumentError(absl::StrFormat("Unsigned value %#x does not fit in 1 bits", result__)); + } + members[5] = ::xls::Value(::xls::UBits(result__, 1)); + if (!FitsInNBitsUnsigned(result_, 1)) { + return absl::InvalidArgumentError(absl::StrFormat("Unsigned value %#x does not fit in 1 bits", result_)); + } + members[6] = ::xls::Value(::xls::UBits(result_, 1)); return ::xls::Value::Tuple(members); } std::string MyStruct::ToString(int indent) const { - std::string result = "MyStruct {\n"; - result += __indent(indent + 1) + "x: "; - result += "bits[32]:" + absl::StrFormat("0x%x", x); - result += ",\n"; - result += __indent(indent + 1) + "y: "; - result += "bits[15]:" + absl::StrFormat("0x%x", y); - result += ",\n"; - result += __indent(indent + 1) + "z: "; - result += "bits[8]:" + absl::StrFormat("0x%x", z); - result += ",\n"; - result += __indent(indent + 1) + "w: "; - result += "bits[63]:" + absl::StrFormat("0x%x", w); - result += ",\n"; - result += __indent(indent + 1) + "v: "; - result += "bits[1]:" + absl::StrFormat("0x%x", v); - result += ",\n"; - result += __indent(indent) + "}"; - return result; + std::string result___ = "MyStruct {\n"; + result___ += __indent(indent + 1) + "x: "; + result___ += "bits[32]:" + absl::StrFormat("0x%x", x); + result___ += ",\n"; + result___ += __indent(indent + 1) + "y: "; + result___ += "bits[15]:" + absl::StrFormat("0x%x", y); + result___ += ",\n"; + result___ += __indent(indent + 1) + "z: "; + result___ += "bits[8]:" + absl::StrFormat("0x%x", z); + result___ += ",\n"; + result___ += __indent(indent + 1) + "w: "; + result___ += "bits[63]:" + absl::StrFormat("0x%x", w); + result___ += ",\n"; + result___ += __indent(indent + 1) + "result: "; + result___ += "bits[1]:" + absl::StrFormat("0x%x", result); + result___ += ",\n"; + result___ += __indent(indent + 1) + "result__: "; + result___ += "bits[1]:" + absl::StrFormat("0x%x", result__); + result___ += ",\n"; + result___ += __indent(indent + 1) + "result_: "; + result___ += "bits[1]:" + absl::StrFormat("0x%x", result_); + result___ += ",\n"; + result___ += __indent(indent) + "}"; + return result___; } std::string MyStruct::ToDslxString(int indent) const { - std::string result = "MyStruct {\n"; - result += __indent(indent + 1) + "x: "; - result += "u32:" + absl::StrFormat("0x%x", x); - result += ",\n"; - result += __indent(indent + 1) + "y: "; - result += "u15:" + absl::StrFormat("0x%x", y); - result += ",\n"; - result += __indent(indent + 1) + "z: "; - result += "u8:" + absl::StrFormat("0x%x", z); - result += ",\n"; - result += __indent(indent + 1) + "w: "; - result += "s63:" + absl::StrFormat("%d", w); - result += ",\n"; - result += __indent(indent + 1) + "v: "; - result += "u1:" + absl::StrFormat("0x%x", v); - result += ",\n"; - result += __indent(indent) + "}"; - return result; + std::string result___ = "MyStruct {\n"; + result___ += __indent(indent + 1) + "x: "; + result___ += "u32:" + absl::StrFormat("0x%x", x); + result___ += ",\n"; + result___ += __indent(indent + 1) + "y: "; + result___ += "u15:" + absl::StrFormat("0x%x", y); + result___ += ",\n"; + result___ += __indent(indent + 1) + "z: "; + result___ += "u8:" + absl::StrFormat("0x%x", z); + result___ += ",\n"; + result___ += __indent(indent + 1) + "w: "; + result___ += "s63:" + absl::StrFormat("%d", w); + result___ += ",\n"; + result___ += __indent(indent + 1) + "result: "; + result___ += "u1:" + absl::StrFormat("0x%x", result); + result___ += ",\n"; + result___ += __indent(indent + 1) + "result__: "; + result___ += "u1:" + absl::StrFormat("0x%x", result__); + result___ += ",\n"; + result___ += __indent(indent + 1) + "result_: "; + result___ += "u1:" + absl::StrFormat("0x%x", result_); + result___ += ",\n"; + result___ += __indent(indent) + "}"; + return result___; } absl::Status MyStruct::Verify() const { @@ -147,14 +175,20 @@ absl::Status MyStruct::Verify() const { if (!FitsInNBitsSigned(w, 63)) { return absl::InvalidArgumentError(absl::StrCat("MyStruct.w value does not fit in signed 63 bits: ", absl::StrFormat("0x%x", w))); } - if (!FitsInNBitsUnsigned(v, 1)) { - return absl::InvalidArgumentError(absl::StrCat("MyStruct.v value does not fit in 1 bits: ", absl::StrFormat("0x%x", v))); + if (!FitsInNBitsUnsigned(result, 1)) { + return absl::InvalidArgumentError(absl::StrCat("MyStruct.result value does not fit in 1 bits: ", absl::StrFormat("0x%x", result))); + } + if (!FitsInNBitsUnsigned(result__, 1)) { + return absl::InvalidArgumentError(absl::StrCat("MyStruct.result__ value does not fit in 1 bits: ", absl::StrFormat("0x%x", result__))); + } + if (!FitsInNBitsUnsigned(result_, 1)) { + return absl::InvalidArgumentError(absl::StrCat("MyStruct.result_ value does not fit in 1 bits: ", absl::StrFormat("0x%x", result_))); } return absl::OkStatus(); } bool MyStruct::operator==(const MyStruct& other) const { - return x == other.x && y == other.y && z == other.z && w == other.w && v == other.v; + return x == other.x && y == other.y && z == other.z && w == other.w && result == other.result && result__ == other.result__ && result_ == other.result_; } std::ostream& operator<<(std::ostream& os, const MyStruct& data) { diff --git a/xls/dslx/cpp_transpiler/testdata/BasicStruct.htxt b/xls/dslx/cpp_transpiler/testdata/BasicStruct.htxt index ab54ba1c49..d24ec5de0b 100644 --- a/xls/dslx/cpp_transpiler/testdata/BasicStruct.htxt +++ b/xls/dslx/cpp_transpiler/testdata/BasicStruct.htxt @@ -18,13 +18,17 @@ struct MyStruct { uint16_t y; uint8_t z; int64_t w; - bool v; + bool result; + bool result__; + bool result_; static constexpr int64_t kXWidth = 32; static constexpr int64_t kYWidth = 15; static constexpr int64_t kZWidth = 8; static constexpr int64_t kWWidth = 63; - static constexpr int64_t kVWidth = 1; + static constexpr int64_t kResultWidth = 1; + static constexpr int64_t kResult__Width = 1; + static constexpr int64_t kResult_Width = 1; static absl::StatusOr FromValue(const ::xls::Value& value); absl::StatusOr<::xls::Value> ToValue() const; diff --git a/xls/dslx/cpp_transpiler/testdata/BasicTypedefs.cctxt b/xls/dslx/cpp_transpiler/testdata/BasicTypedefs.cctxt index 59da6707e5..a9052d6a0a 100644 --- a/xls/dslx/cpp_transpiler/testdata/BasicTypedefs.cctxt +++ b/xls/dslx/cpp_transpiler/testdata/BasicTypedefs.cctxt @@ -501,21 +501,21 @@ std::string MyFirstTupleToDslxString(const MyFirstTuple& value, int64_t indent) absl::StatusOr<::xls::Value> MyFirstTupleToValue(const MyFirstTuple& input) { ::xls::Value value; { - std::vector<::xls::Value> members; - members.resize(6); + std::vector<::xls::Value> entries; + entries.resize(6); if (!FitsInNBitsUnsigned(std::get<0>(input), 7)) { return absl::InvalidArgumentError(absl::StrFormat("Unsigned value %#x does not fit in 7 bits", std::get<0>(input))); } - members[0] = ::xls::Value(::xls::UBits(std::get<0>(input), 7)); + entries[0] = ::xls::Value(::xls::UBits(std::get<0>(input), 7)); if (!FitsInNBitsSigned(std::get<1>(input), 8)) { return absl::InvalidArgumentError(absl::StrFormat("Signed value %#x does not fit in 8 bits", std::get<1>(input))); } - members[1] = ::xls::Value(::xls::SBits(std::get<1>(input), 8)); - XLS_ASSIGN_OR_RETURN(members[2], MyTypeToValue(std::get<2>(input))); - XLS_ASSIGN_OR_RETURN(members[3], MySignedTypeToValue(std::get<3>(input))); - XLS_ASSIGN_OR_RETURN(members[4], MyArrayType1ToValue(std::get<4>(input))); - XLS_ASSIGN_OR_RETURN(members[5], MyArrayType2ToValue(std::get<5>(input))); - value = ::xls::Value::Tuple(members); + entries[1] = ::xls::Value(::xls::SBits(std::get<1>(input), 8)); + XLS_ASSIGN_OR_RETURN(entries[2], MyTypeToValue(std::get<2>(input))); + XLS_ASSIGN_OR_RETURN(entries[3], MySignedTypeToValue(std::get<3>(input))); + XLS_ASSIGN_OR_RETURN(entries[4], MyArrayType1ToValue(std::get<4>(input))); + XLS_ASSIGN_OR_RETURN(entries[5], MyArrayType2ToValue(std::get<5>(input))); + value = ::xls::Value::Tuple(entries); } return value; } diff --git a/xls/dslx/cpp_transpiler/testdata/StructWithTuples.cctxt b/xls/dslx/cpp_transpiler/testdata/StructWithTuples.cctxt index e14e3f94cc..62dc4fe907 100644 --- a/xls/dslx/cpp_transpiler/testdata/StructWithTuples.cctxt +++ b/xls/dslx/cpp_transpiler/testdata/StructWithTuples.cctxt @@ -61,17 +61,17 @@ absl::StatusOr<::xls::Value> Foo::ToValue() const { std::vector<::xls::Value> members; members.resize(1); { - std::vector<::xls::Value> members; - members.resize(2); + std::vector<::xls::Value> entries; + entries.resize(2); if (!FitsInNBitsUnsigned(std::get<0>(a), 32)) { return absl::InvalidArgumentError(absl::StrFormat("Unsigned value %#x does not fit in 32 bits", std::get<0>(a))); } - members[0] = ::xls::Value(::xls::UBits(std::get<0>(a), 32)); + entries[0] = ::xls::Value(::xls::UBits(std::get<0>(a), 32)); if (!FitsInNBitsUnsigned(std::get<1>(a), 32)) { return absl::InvalidArgumentError(absl::StrFormat("Unsigned value %#x does not fit in 32 bits", std::get<1>(a))); } - members[1] = ::xls::Value(::xls::UBits(std::get<1>(a), 32)); - members[0] = ::xls::Value::Tuple(members); + entries[1] = ::xls::Value(::xls::UBits(std::get<1>(a), 32)); + members[0] = ::xls::Value::Tuple(entries); } return ::xls::Value::Tuple(members); }