Revert "[platform] Fix Utils::IsAbsoluteUint and rename to MagnitudeIsUint."
This reverts commit 2ea5507fc380bb1bc5b1375e446b84f55aa89538.
Reason for revert: Broke vm-kernel-precomp-linux-debug-simarm_x64
Original change's description:
> [platform] Fix Utils::IsAbsoluteUint and rename to MagnitudeIsUint.
>
> Also remove previous (incorrect) uses in datastream.cc and
> image_snapshot.cc, now that Utils::IsInt<T>(N, value) can now
> be run for values of N >= sizeof(T).
>
> Fixes https://github.com/dart-lang/sdk/issues/46572
>
> TEST=language/generic/super_bounded_types_test passes on NNBD simarm,
> added value that triggered failure to vm/cc/MagnitudeIsUint
>
> Cq-Include-Trybots: luci.dart.try:vm-kernel-nnbd-linux-release-simarm-try
> Change-Id: Ibc2d2bb5037a8fdee11fc26fa2a313149d3ca274
> Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/206083
> Commit-Queue: Tess Strickland <sstrickl@google.com>
> Reviewed-by: Daco Harkes <dacoharkes@google.com>
TBR=vegorov@google.com,dacoharkes@google.com,sstrickl@google.com
Change-Id: I5194ba777d8811bb5557338c6b071ea152b93d44
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Cq-Include-Trybots: luci.dart.try:vm-kernel-nnbd-linux-release-simarm-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/206143
Reviewed-by: Liam Appelbe <liama@google.com>
Commit-Queue: Liam Appelbe <liama@google.com>
diff --git a/runtime/platform/utils.h b/runtime/platform/utils.h
index a1d6b1b..98f1a1c 100644
--- a/runtime/platform/utils.h
+++ b/runtime/platform/utils.h
@@ -229,22 +229,12 @@
return value <= limit;
}
- // Check whether the magnitude of value fits in N bits. This differs from
- // IsInt(N + 1, value) only in that this returns false for the minimum value
- // of a N+1 bit two's complement value.
- //
- // Primarily used for testing whether a two's complement value can be used in
- // a place where the sign is replaced with a marker that says whether the
- // magnitude is added or subtracted, e.g., the U bit (bit 23) in some ARM7
- // instructions.
+ // Check whether the magnitude of value fits in N bits, i.e., whether an
+ // (N+1)-bit sign-magnitude representation can hold value.
template <typename T>
- static inline bool MagnitudeIsUint(intptr_t N, T value) {
+ static inline bool IsAbsoluteUint(intptr_t N, T value) {
ASSERT(N >= 1);
- if constexpr (std::is_signed<T>::value) {
- using Unsigned = typename std::make_unsigned<T>::type;
- if (value < 0) return IsUint<Unsigned>(N, -value);
- }
- return IsUint(N, value);
+ return IsInt(N + 1, value);
}
static inline int32_t Low16Bits(int32_t value) {
diff --git a/runtime/vm/compiler/assembler/assembler_arm.cc b/runtime/vm/compiler/assembler/assembler_arm.cc
index d285792..7cf8272 100644
--- a/runtime/vm/compiler/assembler/assembler_arm.cc
+++ b/runtime/vm/compiler/assembler/assembler_arm.cc
@@ -2336,20 +2336,19 @@
case kUnsignedTwoBytes:
case kWordPair: {
*offset_mask = 0xff;
- return Utils::MagnitudeIsUint(8, offset); // Addressing mode 3.
+ return Utils::IsAbsoluteUint(8, offset); // Addressing mode 3.
}
case kUnsignedByte:
case kFourBytes:
case kUnsignedFourBytes: {
*offset_mask = 0xfff;
- return Utils::MagnitudeIsUint(12, offset); // Addressing mode 2.
+ return Utils::IsAbsoluteUint(12, offset); // Addressing mode 2.
}
case kSWord:
case kDWord: {
*offset_mask = 0x3fc; // Multiple of 4.
// VFP addressing mode.
- return (Utils::MagnitudeIsUint(10, offset) &&
- Utils::IsAligned(offset, 4));
+ return (Utils::IsAbsoluteUint(10, offset) && Utils::IsAligned(offset, 4));
}
case kRegList: {
*offset_mask = 0x0;
@@ -2370,21 +2369,20 @@
case kUnsignedTwoBytes:
case kWordPair: {
*offset_mask = 0xff;
- return Utils::MagnitudeIsUint(8, offset); // Addressing mode 3.
+ return Utils::IsAbsoluteUint(8, offset); // Addressing mode 3.
}
case kByte:
case kUnsignedByte:
case kFourBytes:
case kUnsignedFourBytes: {
*offset_mask = 0xfff;
- return Utils::MagnitudeIsUint(12, offset); // Addressing mode 2.
+ return Utils::IsAbsoluteUint(12, offset); // Addressing mode 2.
}
case kSWord:
case kDWord: {
*offset_mask = 0x3fc; // Multiple of 4.
// VFP addressing mode.
- return (Utils::MagnitudeIsUint(10, offset) &&
- Utils::IsAligned(offset, 4));
+ return (Utils::IsAbsoluteUint(10, offset) && Utils::IsAligned(offset, 4));
}
case kRegList: {
*offset_mask = 0x0;
diff --git a/runtime/vm/compiler/assembler/assembler_arm.h b/runtime/vm/compiler/assembler/assembler_arm.h
index c41b62d..09162f4 100644
--- a/runtime/vm/compiler/assembler/assembler_arm.h
+++ b/runtime/vm/compiler/assembler/assembler_arm.h
@@ -238,7 +238,7 @@
}
explicit Address(Register rn, int32_t offset = 0, Mode am = Offset) {
- ASSERT(Utils::MagnitudeIsUint(12, offset));
+ ASSERT(Utils::IsAbsoluteUint(12, offset));
kind_ = Immediate;
if (offset < 0) {
encoding_ = (am ^ (1 << kUShift)) | -offset; // Flip U to adjust sign.
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
index b71c702..979db7e 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
@@ -712,7 +712,7 @@
} else {
__ add(LR, DISPATCH_TABLE_REG,
compiler::Operand(cid_reg, LSL, compiler::target::kWordSizeLog2));
- if (!Utils::MagnitudeIsUint(12, offset)) {
+ if (!Utils::IsAbsoluteUint(12, offset)) {
const intptr_t adjust = offset & -(1 << 12);
__ AddImmediate(LR, LR, adjust);
offset -= adjust;
diff --git a/runtime/vm/compiler/backend/il_arm.cc b/runtime/vm/compiler/backend/il_arm.cc
index 0c07ad2..80aaa47 100644
--- a/runtime/vm/compiler/backend/il_arm.cc
+++ b/runtime/vm/compiler/backend/il_arm.cc
@@ -1855,7 +1855,7 @@
const intptr_t base_offset =
(is_external ? 0 : (Instance::DataOffsetFor(cid) - kHeapObjectTag));
const int64_t offset = index * scale + base_offset;
- if (!Utils::MagnitudeIsUint(12, offset)) {
+ if (!Utils::IsAbsoluteUint(12, offset)) {
return false;
}
if (compiler::Address::CanHoldImmediateOffset(is_load, cid, offset)) {
diff --git a/runtime/vm/datastream.cc b/runtime/vm/datastream.cc
index 8236bf2..6d398fe 100644
--- a/runtime/vm/datastream.cc
+++ b/runtime/vm/datastream.cc
@@ -10,7 +10,8 @@
namespace dart {
void BaseWriteStream::WriteTargetWord(word value) {
- ASSERT(Utils::IsInt(compiler::target::kBitsPerWord, value));
+ ASSERT(compiler::target::kBitsPerWord == kBitsPerWord ||
+ Utils::IsAbsoluteUint(compiler::target::kBitsPerWord, value));
WriteFixed(static_cast<compiler::target::word>(value));
}
diff --git a/runtime/vm/image_snapshot.cc b/runtime/vm/image_snapshot.cc
index 715bd93..658892b 100644
--- a/runtime/vm/image_snapshot.cc
+++ b/runtime/vm/image_snapshot.cc
@@ -1207,7 +1207,8 @@
}
intptr_t AssemblyImageWriter::WriteTargetWord(word value) {
- ASSERT(Utils::IsInt(compiler::target::kBitsPerWord, value));
+ ASSERT(compiler::target::kBitsPerWord == kBitsPerWord ||
+ Utils::IsAbsoluteUint(compiler::target::kBitsPerWord, value));
// Padding is helpful for comparing the .S with --disassemble.
assembly_stream_->Printf("%s 0x%.*" Px "\n", kWordDirective,
2 * compiler::target::kWordSize, value);
diff --git a/runtime/vm/utils_test.cc b/runtime/vm/utils_test.cc
index 2b0369f..ba4e296 100644
--- a/runtime/vm/utils_test.cc
+++ b/runtime/vm/utils_test.cc
@@ -290,26 +290,22 @@
EXPECT(!Utils::IsUint(32, 4294967296LL));
}
-VM_UNIT_TEST_CASE(MagnitudeIsUint) {
- EXPECT(Utils::MagnitudeIsUint(8, 16));
- EXPECT(Utils::MagnitudeIsUint(8, 0));
- EXPECT(Utils::MagnitudeIsUint(8, -128));
- EXPECT(Utils::MagnitudeIsUint(8, 255));
- EXPECT(!Utils::MagnitudeIsUint(8, 256));
- EXPECT(Utils::MagnitudeIsUint(12, 4095));
- EXPECT(Utils::MagnitudeIsUint(12, -4095));
- EXPECT(!Utils::MagnitudeIsUint(12, 4096));
- EXPECT(!Utils::MagnitudeIsUint(12, -4096));
- EXPECT(Utils::MagnitudeIsUint(16, 16));
- EXPECT(Utils::MagnitudeIsUint(16, 0));
- EXPECT(Utils::MagnitudeIsUint(16, 65535));
- EXPECT(Utils::MagnitudeIsUint(16, -32768));
- EXPECT(!Utils::MagnitudeIsUint(16, 65536));
- EXPECT(Utils::MagnitudeIsUint(32, 16LL));
- EXPECT(Utils::MagnitudeIsUint(32, 0LL));
- EXPECT(Utils::MagnitudeIsUint(32, -2147483648LL));
- EXPECT(Utils::MagnitudeIsUint(32, 4294967295LL));
- EXPECT(!Utils::MagnitudeIsUint(32, 4294967296LL));
+VM_UNIT_TEST_CASE(IsAbsoluteUint) {
+ EXPECT(Utils::IsAbsoluteUint(8, 16));
+ EXPECT(Utils::IsAbsoluteUint(8, 0));
+ EXPECT(Utils::IsAbsoluteUint(8, -128));
+ EXPECT(Utils::IsAbsoluteUint(8, 255));
+ EXPECT(!Utils::IsAbsoluteUint(8, 256));
+ EXPECT(Utils::IsAbsoluteUint(16, 16));
+ EXPECT(Utils::IsAbsoluteUint(16, 0));
+ EXPECT(Utils::IsAbsoluteUint(16, 65535));
+ EXPECT(Utils::IsAbsoluteUint(16, -32768));
+ EXPECT(!Utils::IsAbsoluteUint(16, 65536));
+ EXPECT(Utils::IsAbsoluteUint(32, 16LL));
+ EXPECT(Utils::IsAbsoluteUint(32, 0LL));
+ EXPECT(Utils::IsAbsoluteUint(32, -2147483648LL));
+ EXPECT(Utils::IsAbsoluteUint(32, 4294967295LL));
+ EXPECT(!Utils::IsAbsoluteUint(32, 4294967296LL));
}
VM_UNIT_TEST_CASE(LowBits) {
